ccem 2.0.0-beta → 2.0.0-beta.11

package/dist/index.js

@@ -7,28 +7,435 @@ import inquirer from "inquirer";
 import chalk7 from "chalk";
 import Table3 from "cli-table3";
 import { spawn as spawn3 } from "child_process";
-import * as fs7 from "fs";
-import * as path5 from "path";
-import { fileURLToPath } from "url";
-import { encrypt as encrypt2, decrypt as decrypt2, ENV_PRESETS, PERMISSION_PRESETS as PERMISSION_PRESETS4, getCcemConfigDir, ensureCcemDir as ensureCcemDir3, getCcemConfigPath, getLegacyConfigPath } from "@ccem/core";
+import * as fs8 from "fs";
+import * as path6 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// ../../packages/core/dist/chunk-6STWB3RD.js
+var TIER_MODEL_ALIASES = /* @__PURE__ */ new Set(["opus", "sonnet", "haiku"]);
+function normalizeEnvConfig(envConfig, defaultRuntimeModel = "opus") {
+  const hasTierDefaults = Boolean(envConfig.ANTHROPIC_DEFAULT_OPUS_MODEL) || Boolean(envConfig.ANTHROPIC_DEFAULT_SONNET_MODEL) || Boolean(envConfig.ANTHROPIC_DEFAULT_HAIKU_MODEL);
+  const defaultOpusModel = envConfig.ANTHROPIC_DEFAULT_OPUS_MODEL ?? (hasTierDefaults ? void 0 : envConfig.ANTHROPIC_MODEL);
+  const defaultSonnetModel = envConfig.ANTHROPIC_DEFAULT_SONNET_MODEL ?? defaultOpusModel ?? (hasTierDefaults ? void 0 : envConfig.ANTHROPIC_MODEL);
+  const defaultHaikuModel = envConfig.ANTHROPIC_DEFAULT_HAIKU_MODEL ?? envConfig.ANTHROPIC_SMALL_FAST_MODEL;
+  return {
+    ...envConfig.ANTHROPIC_BASE_URL && {
+      ANTHROPIC_BASE_URL: envConfig.ANTHROPIC_BASE_URL
+    },
+    ...(envConfig.ANTHROPIC_AUTH_TOKEN ?? envConfig.ANTHROPIC_API_KEY) && {
+      ANTHROPIC_AUTH_TOKEN: envConfig.ANTHROPIC_AUTH_TOKEN ?? envConfig.ANTHROPIC_API_KEY
+    },
+    ...defaultOpusModel && {
+      ANTHROPIC_DEFAULT_OPUS_MODEL: defaultOpusModel
+    },
+    ...defaultSonnetModel && {
+      ANTHROPIC_DEFAULT_SONNET_MODEL: defaultSonnetModel
+    },
+    ...defaultHaikuModel && {
+      ANTHROPIC_DEFAULT_HAIKU_MODEL: defaultHaikuModel
+    },
+    ANTHROPIC_MODEL: hasTierDefaults ? envConfig.ANTHROPIC_MODEL ?? defaultRuntimeModel : defaultRuntimeModel,
+    ...envConfig.CLAUDE_CODE_SUBAGENT_MODEL && {
+      CLAUDE_CODE_SUBAGENT_MODEL: envConfig.CLAUDE_CODE_SUBAGENT_MODEL
+    }
+  };
+}
+function shouldRecoverTierModel(model) {
+  return !model || TIER_MODEL_ALIASES.has(model);
+}
+function recoverEnvConfigFromLegacy(currentEnvConfig, legacyEnvConfig) {
+  const current = normalizeEnvConfig(currentEnvConfig);
+  const legacy = normalizeEnvConfig(legacyEnvConfig);
+  return {
+    ...current,
+    ...!current.ANTHROPIC_AUTH_TOKEN && legacy.ANTHROPIC_AUTH_TOKEN && {
+      ANTHROPIC_AUTH_TOKEN: legacy.ANTHROPIC_AUTH_TOKEN
+    },
+    ...shouldRecoverTierModel(current.ANTHROPIC_DEFAULT_OPUS_MODEL) && legacy.ANTHROPIC_DEFAULT_OPUS_MODEL && {
+      ANTHROPIC_DEFAULT_OPUS_MODEL: legacy.ANTHROPIC_DEFAULT_OPUS_MODEL
+    },
+    ...shouldRecoverTierModel(current.ANTHROPIC_DEFAULT_SONNET_MODEL) && legacy.ANTHROPIC_DEFAULT_SONNET_MODEL && {
+      ANTHROPIC_DEFAULT_SONNET_MODEL: legacy.ANTHROPIC_DEFAULT_SONNET_MODEL
+    },
+    ...shouldRecoverTierModel(current.ANTHROPIC_DEFAULT_HAIKU_MODEL) && legacy.ANTHROPIC_DEFAULT_HAIKU_MODEL && {
+      ANTHROPIC_DEFAULT_HAIKU_MODEL: legacy.ANTHROPIC_DEFAULT_HAIKU_MODEL
+    },
+    ...!current.CLAUDE_CODE_SUBAGENT_MODEL && legacy.CLAUDE_CODE_SUBAGENT_MODEL && {
+      CLAUDE_CODE_SUBAGENT_MODEL: legacy.CLAUDE_CODE_SUBAGENT_MODEL
+    }
+  };
+}
+var ENV_PRESETS = {
+  "GLM": {
+    ANTHROPIC_BASE_URL: "https://open.bigmodel.cn/api/anthropic",
+    ANTHROPIC_DEFAULT_OPUS_MODEL: "glm-5",
+    ANTHROPIC_DEFAULT_SONNET_MODEL: "glm-5",
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: "glm-4.5-air",
+    ANTHROPIC_MODEL: "opus"
+  },
+  "KIMI": {
+    ANTHROPIC_BASE_URL: "https://api.moonshot.cn/anthropic",
+    ANTHROPIC_DEFAULT_OPUS_MODEL: "kimi-k2.5",
+    ANTHROPIC_DEFAULT_SONNET_MODEL: "kimi-k2.5",
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: "kimi-k2.5",
+    ANTHROPIC_MODEL: "opus"
+  },
+  "KimiCodePlan": {
+    ANTHROPIC_BASE_URL: "https://api.kimi.com/coding/",
+    ANTHROPIC_DEFAULT_OPUS_MODEL: "kimi-for-coding",
+    ANTHROPIC_DEFAULT_SONNET_MODEL: "kimi-for-coding",
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: "kimi-for-coding",
+    ANTHROPIC_MODEL: "opus"
+  },
+  "MiniMax": {
+    ANTHROPIC_BASE_URL: "https://api.minimaxi.com/anthropic",
+    ANTHROPIC_DEFAULT_OPUS_MODEL: "MiniMax-M2.7",
+    ANTHROPIC_DEFAULT_SONNET_MODEL: "MiniMax-M2.7",
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: "MiniMax-M2.7-highspeed",
+    ANTHROPIC_MODEL: "opus"
+  },
+  "DeepSeek": {
+    ANTHROPIC_BASE_URL: "https://api.deepseek.com/anthropic",
+    ANTHROPIC_DEFAULT_OPUS_MODEL: "deepseek-chat",
+    ANTHROPIC_DEFAULT_SONNET_MODEL: "deepseek-chat",
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: "deepseek-chat",
+    ANTHROPIC_MODEL: "opus"
+  },
+  "Bailian": {
+    ANTHROPIC_BASE_URL: "https://dashscope.aliyuncs.com/api/v2/apps/claude-code-proxy",
+    ANTHROPIC_DEFAULT_OPUS_MODEL: "qwen3-coder-plus",
+    ANTHROPIC_DEFAULT_SONNET_MODEL: "qwen3-coder-plus",
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: "qwen3-coder-flash",
+    ANTHROPIC_MODEL: "opus"
+  },
+  "BailianCodePlan": {
+    ANTHROPIC_BASE_URL: "https://coding.dashscope.aliyuncs.com/api/v2/apps/claude-code-proxy",
+    ANTHROPIC_DEFAULT_OPUS_MODEL: "qwen3-coder-plus",
+    ANTHROPIC_DEFAULT_SONNET_MODEL: "qwen3-coder-plus",
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: "qwen3-coder-plus",
+    ANTHROPIC_MODEL: "opus"
+  },
+  "OpenRouter": {
+    ANTHROPIC_BASE_URL: "https://openrouter.ai/api/v1",
+    ANTHROPIC_DEFAULT_OPUS_MODEL: "anthropic/claude-opus-4-1",
+    ANTHROPIC_DEFAULT_SONNET_MODEL: "anthropic/claude-opus-4-1",
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: "anthropic/claude-3.5-haiku",
+    ANTHROPIC_MODEL: "opus"
+  }
+};
+var PERMISSION_PRESETS = {
+  "yolo": {
+    name: "YOLO \u6A21\u5F0F",
+    description: "\u5168\u90E8\u653E\u5F00\uFF0C\u65E0\u4EFB\u4F55\u9650\u5236",
+    permissionMode: "bypassPermissions",
+    permissions: {
+      allow: [
+        "Bash(*)",
+        "Read(*)",
+        "Edit(*)",
+        "Write(*)",
+        "WebFetch(*)",
+        "WebSearch(*)",
+        "Glob(*)",
+        "Grep(*)",
+        "LSP(*)",
+        "NotebookEdit(*)"
+      ],
+      deny: []
+    }
+  },
+  "dev": {
+    name: "\u5F00\u53D1\u6A21\u5F0F",
+    description: "\u65E5\u5E38\u5F00\u53D1\u6743\u9650\uFF0C\u4FDD\u62A4\u654F\u611F\u6587\u4EF6",
+    permissionMode: "acceptEdits",
+    permissions: {
+      allow: [
+        "Read(*)",
+        "Edit(*)",
+        "Write(*)",
+        "Glob(*)",
+        "Grep(*)",
+        "LSP(*)",
+        "NotebookEdit(*)",
+        "Bash(npm:*)",
+        "Bash(pnpm:*)",
+        "Bash(yarn:*)",
+        "Bash(bun:*)",
+        "Bash(node:*)",
+        "Bash(npx:*)",
+        "Bash(git:*)",
+        "Bash(tsc:*)",
+        "Bash(tsx:*)",
+        "Bash(eslint:*)",
+        "Bash(prettier:*)",
+        "Bash(jest:*)",
+        "Bash(vitest:*)",
+        "Bash(cargo:*)",
+        "Bash(python:*)",
+        "Bash(pip:*)",
+        "Bash(go:*)",
+        "Bash(make:*)",
+        "Bash(cmake:*)",
+        "Bash(ls:*)",
+        "Bash(cat:*)",
+        "Bash(head:*)",
+        "Bash(tail:*)",
+        "Bash(find:*)",
+        "Bash(wc:*)",
+        "Bash(mkdir:*)",
+        "Bash(cp:*)",
+        "Bash(mv:*)",
+        "Bash(touch:*)",
+        "WebSearch"
+      ],
+      deny: [
+        "Read(.env)",
+        "Read(.env.*)",
+        "Read(**/secrets/**)",
+        "Read(**/*.pem)",
+        "Read(**/*.key)",
+        "Read(**/*credential*)",
+        "Bash(rm -rf:*)",
+        "Bash(sudo:*)",
+        "Bash(chmod:*)",
+        "Bash(chown:*)"
+      ]
+    }
+  },
+  "readonly": {
+    name: "\u53EA\u8BFB\u6A21\u5F0F",
+    description: "\u4EC5\u5141\u8BB8\u8BFB\u53D6\u548C\u641C\u7D22\uFF0C\u7981\u6B62\u4EFB\u4F55\u4FEE\u6539",
+    permissionMode: "plan",
+    permissions: {
+      allow: [
+        "Read(*)",
+        "Glob(*)",
+        "Grep(*)",
+        "LSP(*)",
+        "Bash(git status:*)",
+        "Bash(git log:*)",
+        "Bash(git diff:*)",
+        "Bash(git branch:*)",
+        "Bash(git show:*)",
+        "Bash(ls:*)",
+        "Bash(cat:*)",
+        "Bash(head:*)",
+        "Bash(tail:*)",
+        "Bash(find:*)",
+        "Bash(wc:*)",
+        "Bash(file:*)",
+        "WebSearch"
+      ],
+      deny: [
+        "Edit(*)",
+        "Write(*)",
+        "NotebookEdit(*)",
+        "Bash(rm:*)",
+        "Bash(mv:*)",
+        "Bash(cp:*)",
+        "Bash(mkdir:*)",
+        "Bash(touch:*)",
+        "Bash(git add:*)",
+        "Bash(git commit:*)",
+        "Bash(git push:*)",
+        "Bash(git checkout:*)",
+        "Bash(git reset:*)",
+        "Bash(npm install:*)",
+        "Bash(pnpm install:*)",
+        "Bash(yarn add:*)"
+      ]
+    }
+  },
+  "safe": {
+    name: "\u5B89\u5168\u6A21\u5F0F",
+    description: "\u4FDD\u5B88\u6743\u9650\uFF0C\u9002\u5408\u4E0D\u719F\u6089\u7684\u4EE3\u7801\u5E93",
+    permissionMode: "default",
+    permissions: {
+      allow: [
+        "Read(*)",
+        "Glob(*)",
+        "Grep(*)",
+        "LSP(*)",
+        "Bash(git status:*)",
+        "Bash(git log:*)",
+        "Bash(git diff:*)",
+        "Bash(ls:*)",
+        "Bash(cat:*)",
+        "Bash(head:*)",
+        "Bash(tail:*)",
+        "Bash(find:*)",
+        "Bash(wc:*)"
+      ],
+      deny: [
+        "Read(.env)",
+        "Read(.env.*)",
+        "Read(**/secrets/**)",
+        "Read(**/*.pem)",
+        "Read(**/*.key)",
+        "Read(**/*credential*)",
+        "Read(**/*password*)",
+        "Edit(*)",
+        "Write(*)",
+        "NotebookEdit(*)",
+        "Bash(curl:*)",
+        "Bash(wget:*)",
+        "Bash(ssh:*)",
+        "Bash(scp:*)",
+        "Bash(rm:*)",
+        "Bash(mv:*)",
+        "WebFetch(*)"
+      ]
+    }
+  },
+  "ci": {
+    name: "CI/CD \u6A21\u5F0F",
+    description: "\u9002\u5408\u81EA\u52A8\u5316\u6D41\u6C34\u7EBF\u7684\u6743\u9650",
+    permissionMode: "default",
+    permissions: {
+      allow: [
+        "Read(*)",
+        "Edit(*)",
+        "Write(*)",
+        "Glob(*)",
+        "Grep(*)",
+        "LSP(*)",
+        "Bash(npm:*)",
+        "Bash(pnpm:*)",
+        "Bash(yarn:*)",
+        "Bash(node:*)",
+        "Bash(git:*)",
+        "Bash(docker:*)",
+        "Bash(make:*)",
+        "Bash(cargo:*)",
+        "Bash(go:*)",
+        "Bash(python:*)",
+        "Bash(pip:*)",
+        "Bash(pytest:*)",
+        "Bash(jest:*)",
+        "Bash(vitest:*)"
+      ],
+      deny: [
+        "Read(.env.local)",
+        "Read(**/secrets/**)",
+        "Bash(sudo:*)",
+        "Bash(ssh:*)",
+        "Bash(scp:*)",
+        "WebFetch(*)",
+        "WebSearch"
+      ]
+    }
+  },
+  "audit": {
+    name: "\u5BA1\u8BA1\u6A21\u5F0F",
+    description: "\u4EC5\u8BFB\u53D6\u548C\u641C\u7D22\uFF0C\u7528\u4E8E\u5B89\u5168\u5BA1\u8BA1",
+    permissionMode: "plan",
+    permissions: {
+      allow: [
+        "Read(*)",
+        "Glob(*)",
+        "Grep(*)",
+        "LSP(*)",
+        "Bash(git log:*)",
+        "Bash(git blame:*)",
+        "Bash(git show:*)",
+        "Bash(git diff:*)",
+        "Bash(ls:*)",
+        "Bash(find:*)",
+        "Bash(wc:*)",
+        "Bash(file:*)",
+        "Bash(stat:*)"
+      ],
+      deny: [
+        "Edit(*)",
+        "Write(*)",
+        "NotebookEdit(*)",
+        "Bash(rm:*)",
+        "Bash(mv:*)",
+        "Bash(cp:*)",
+        "Bash(curl:*)",
+        "Bash(wget:*)",
+        "Bash(ssh:*)",
+        "WebFetch(*)"
+      ]
+    }
+  }
+};
+var getPermissionModeNames = () => {
+  return Object.keys(PERMISSION_PRESETS);
+};
+
+// ../../packages/core/dist/index.js
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+var ALGORITHM = "aes-256-cbc";
+var SECRET_KEY = crypto.scryptSync("claude-code-env-manager-secret", "salt", 32);
+var encrypt = (text) => {
+  if (!text) return text;
+  const iv = crypto.randomBytes(16);
+  const cipher = crypto.createCipheriv(ALGORITHM, SECRET_KEY, iv);
+  let encrypted = cipher.update(text, "utf8", "hex");
+  encrypted += cipher.final("hex");
+  return `enc:${iv.toString("hex")}:${encrypted}`;
+};
+var decrypt = (text) => {
+  if (!text || !text.startsWith("enc:")) return text;
+  try {
+    const parts = text.split(":");
+    if (parts.length !== 3) return text;
+    const iv = Buffer.from(parts[1], "hex");
+    const encryptedText = parts[2];
+    const decipher = crypto.createDecipheriv(ALGORITHM, SECRET_KEY, iv);
+    let decrypted = decipher.update(encryptedText, "hex", "utf8");
+    decrypted += decipher.final("utf8");
+    return decrypted;
+  } catch {
+    return text;
+  }
+};
+var getHomeDir = () => {
+  return process.env.HOME || process.env.USERPROFILE || "";
+};
+var getCcemConfigDir = () => {
+  return path.join(getHomeDir(), ".ccem");
+};
+var getCcemConfigPath = () => {
+  return path.join(getCcemConfigDir(), "config.json");
+};
+var ensureCcemDir = () => {
+  const ccemDir = getCcemConfigDir();
+  if (!fs.existsSync(ccemDir)) {
+    fs.mkdirSync(ccemDir, { recursive: true });
+  }
+  return ccemDir;
+};
+var getLegacyConfigPath = () => {
+  const home = getHomeDir();
+  if (process.platform === "darwin") {
+    return path.join(home, "Library", "Preferences", "claude-code-env-manager-nodejs", "config.json");
+  }
+  return path.join(home, ".config", "claude-code-env-manager-nodejs", "config.json");
+};
 
 // src/ui.ts
 import chalk from "chalk";
 import Table from "cli-table3";
-import { PERMISSION_PRESETS } from "@ccem/core";
 
 // src/usage.ts
-import * as fs from "fs";
+import * as fs2 from "fs";
 import * as fsPromises from "fs/promises";
-import * as path from "path";
+import * as path2 from "path";
 import * as os from "os";
 import * as readline from "readline";
-var CLAUDE_PROJECTS_DIR = path.join(os.homedir(), ".claude", "projects");
-var CCEM_DIR = path.join(os.homedir(), ".ccem");
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path2.dirname(__filename);
+var CLAUDE_PROJECTS_DIR = path2.join(os.homedir(), ".claude", "projects");
+var CCEM_DIR = path2.join(os.homedir(), ".ccem");
 var CACHE_VERSION = 1;
-var getCachePath = () => path.join(CCEM_DIR, "usage-cache.json");
-var getPricesPath = () => path.join(CCEM_DIR, "model-prices.json");
-async function ensureCcemDir() {
+var getCachePath = () => path2.join(CCEM_DIR, "usage-cache.json");
+var getPricesPath = () => path2.join(CCEM_DIR, "model-prices.json");
+async function ensureCcemDir2() {
   try {
     await fsPromises.access(CCEM_DIR);
   } catch {
@@ -37,7 +444,7 @@ async function ensureCcemDir() {
 }
 var LITELLM_PRICES_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
 var getBundledPricesPath = () => {
-  return path.join(__dirname, "..", "model-prices.json");
+  return path2.join(__dirname, "..", "model-prices.json");
 };
 var DEFAULT_PRICES = {
   "claude-opus-4-5": {
@@ -66,7 +473,7 @@ function normalizeModelName(model) {
 var pricesCache = null;
 async function loadPrices() {
   if (pricesCache) return pricesCache;
-  await ensureCcemDir();
+  await ensureCcemDir2();
   const pricesPath = getPricesPath();
   try {
     const response = await fetch(LITELLM_PRICES_URL, { signal: AbortSignal.timeout(1e3) });
@@ -156,8 +563,8 @@ async function getFileMetaAsync(filePath) {
 function loadCacheSync() {
   try {
     const cachePath = getCachePath();
-    if (!fs.existsSync(cachePath)) return null;
-    const data = JSON.parse(fs.readFileSync(cachePath, "utf-8"));
+    if (!fs2.existsSync(cachePath)) return null;
+    const data = JSON.parse(fs2.readFileSync(cachePath, "utf-8"));
     if (data.version !== CACHE_VERSION) return null;
     return data;
   } catch {
@@ -216,7 +623,7 @@ function getUsageStatsFromCache() {
 }
 async function saveCacheAsync(cache) {
   try {
-    await ensureCcemDir();
+    await ensureCcemDir2();
     await fsPromises.writeFile(getCachePath(), JSON.stringify(cache, null, 2));
   } catch {
   }
@@ -224,7 +631,7 @@ async function saveCacheAsync(cache) {
 async function parseJSONLFileAsync(filePath, prices, signal) {
   const entries = [];
   try {
-    const fileStream = fs.createReadStream(filePath, { encoding: "utf-8" });
+    const fileStream = fs2.createReadStream(filePath, { encoding: "utf-8" });
     const rl = readline.createInterface({
       input: fileStream,
       crlfDelay: Infinity
@@ -278,14 +685,14 @@ async function getAllJSONLFilesAsync() {
     if (!projectsDirExists) return files;
     const projects = await fsPromises.readdir(CLAUDE_PROJECTS_DIR);
     for (const project of projects) {
-      const projectPath = path.join(CLAUDE_PROJECTS_DIR, project);
+      const projectPath = path2.join(CLAUDE_PROJECTS_DIR, project);
       try {
         const stat2 = await fsPromises.stat(projectPath);
         if (stat2.isDirectory()) {
           const projectFiles = await fsPromises.readdir(projectPath);
           for (const file of projectFiles) {
             if (file.endsWith(".jsonl")) {
-              files.push(path.join(projectPath, file));
+              files.push(path2.join(projectPath, file));
             }
           }
         }
@@ -496,9 +903,10 @@ var renderLogoWithEnvPanel = (envName, env, defaultMode) => {
   const titleShort = theme.primary("CCEM");
   const envLabel = theme.muted("Env:   ") + theme.primary(envName);
   const baseUrl = env.ANTHROPIC_BASE_URL || "-";
-  const model = env.ANTHROPIC_MODEL || "-";
-  const fastModel = env.ANTHROPIC_SMALL_FAST_MODEL || "-";
-  const apiKey = env.ANTHROPIC_API_KEY ? env.ANTHROPIC_API_KEY.slice(0, 2) + "\u2022\u2022\u2022\u2022" + env.ANTHROPIC_API_KEY.slice(-4) : "-";
+  const runtimeModel = env.ANTHROPIC_MODEL || "-";
+  const opusModel = env.ANTHROPIC_DEFAULT_OPUS_MODEL || "-";
+  const haikuModel = env.ANTHROPIC_DEFAULT_HAIKU_MODEL || "-";
+  const authToken = env.ANTHROPIC_AUTH_TOKEN ? env.ANTHROPIC_AUTH_TOKEN.slice(0, 2) + "\u2022\u2022\u2022\u2022" + env.ANTHROPIC_AUTH_TOKEN.slice(-4) : "-";
   const truncate = (s, max) => s.length > max ? s.slice(0, max - 3) + "..." : s;
   const maskUrl = (url, max) => {
     if (url.length <= max) return url;
@@ -506,10 +914,10 @@ var renderLogoWithEnvPanel = (envName, env, defaultMode) => {
       const parsed = new URL(url);
       const protocol = parsed.protocol + "//";
       const host = parsed.host;
-      const path6 = parsed.pathname + parsed.search;
+      const path7 = parsed.pathname + parsed.search;
       const hostStart = host.slice(0, 8);
       const hostEnd = host.slice(-4);
-      const pathPart = path6.length > 10 ? path6.slice(0, 7) + "..." : path6;
+      const pathPart = path7.length > 10 ? path7.slice(0, 7) + "..." : path7;
       return `${protocol}${hostStart}...${hostEnd}${pathPart}`;
     } catch {
       return truncate(url, max);
@@ -520,15 +928,15 @@ var renderLogoWithEnvPanel = (envName, env, defaultMode) => {
   if (isNarrow) {
     envLines = [
       envLabel,
-      theme.muted("Model:".padEnd(labelWidth)) + theme.dim(truncate(model, 25)),
-      theme.muted("Key:".padEnd(labelWidth)) + theme.dim(apiKey)
+      theme.muted("Opus:".padEnd(labelWidth)) + theme.dim(truncate(opusModel, 25)),
+      theme.muted("Token:".padEnd(labelWidth)) + theme.dim(authToken)
     ];
   } else {
     envLines = [
       envLabel + (defaultMode && PERMISSION_PRESETS[defaultMode] ? "  " + theme.accent(`[${PERMISSION_PRESETS[defaultMode].name}]`) : ""),
       theme.muted("URL:".padEnd(labelWidth)) + theme.dim(maskUrl(baseUrl, 40)),
-      theme.muted("Model:".padEnd(labelWidth)) + theme.dim(truncate(model, 15)) + "  " + theme.muted("Fast:".padEnd(labelWidth)) + theme.dim(truncate(fastModel, 15)),
-      theme.muted("Key:".padEnd(labelWidth)) + theme.dim(apiKey)
+      theme.muted("Run:".padEnd(labelWidth)) + theme.dim(truncate(runtimeModel, 12)) + "  " + theme.muted("Opus:".padEnd(labelWidth)) + theme.dim(truncate(opusModel, 15)),
+      theme.muted("Haiku:".padEnd(labelWidth)) + theme.dim(truncate(haikuModel, 15)) + "  " + theme.muted("Token:".padEnd(labelWidth)) + theme.dim(authToken)
     ];
   }
   const lines = [];
@@ -947,74 +1355,86 @@ var selectEnvWithKeys = (registries, current) => {
 };
 
 // src/permissions.ts
-import fs4 from "fs";
+import fs5 from "fs";
 import chalk3 from "chalk";
 import Table2 from "cli-table3";
-import { PERMISSION_PRESETS as PERMISSION_PRESETS3, getPermissionModeNames } from "@ccem/core";
 
 // src/utils.ts
-import crypto from "crypto";
-import fs2 from "fs";
-import path2 from "path";
-var SECRET_KEY = crypto.scryptSync("claude-code-env-manager-secret", "salt", 32);
+import crypto2 from "crypto";
+import fs3 from "fs";
+import path3 from "path";
+var SECRET_KEY2 = crypto2.scryptSync("claude-code-env-manager-secret", "salt", 32);
 var findProjectRoot = () => {
   let currentDir = process.cwd();
-  const root = path2.parse(currentDir).root;
+  const root = path3.parse(currentDir).root;
   while (currentDir !== root) {
-    if (fs2.existsSync(path2.join(currentDir, ".git")) || fs2.existsSync(path2.join(currentDir, "package.json"))) {
+    if (fs3.existsSync(path3.join(currentDir, ".git")) || fs3.existsSync(path3.join(currentDir, "package.json"))) {
       return currentDir;
     }
-    currentDir = path2.dirname(currentDir);
+    currentDir = path3.dirname(currentDir);
   }
   return process.cwd();
 };
 var getSettingsPath = (useLocal = true) => {
   const projectRoot = findProjectRoot();
-  const claudeDir = path2.join(projectRoot, ".claude");
+  const claudeDir = path3.join(projectRoot, ".claude");
   const filename = useLocal ? "settings.local.json" : "settings.json";
-  return path2.join(claudeDir, filename);
+  return path3.join(claudeDir, filename);
 };
 var ensureClaudeDir = () => {
   const projectRoot = findProjectRoot();
-  const claudeDir = path2.join(projectRoot, ".claude");
-  if (!fs2.existsSync(claudeDir)) {
-    fs2.mkdirSync(claudeDir, { recursive: true });
+  const claudeDir = path3.join(projectRoot, ".claude");
+  if (!fs3.existsSync(claudeDir)) {
+    fs3.mkdirSync(claudeDir, { recursive: true });
   }
   return claudeDir;
 };
-var getHomeDir = () => {
+var getHomeDir2 = () => {
   return process.env.HOME || process.env.USERPROFILE || "";
 };
 var getGlobalClaudeConfigPath = () => {
-  return path2.join(getHomeDir(), ".claude.json");
+  return path3.join(getHomeDir2(), ".claude.json");
 };
 var getGlobalClaudeSettingsPath = () => {
-  return path2.join(getHomeDir(), ".claude", "settings.json");
+  return path3.join(getHomeDir2(), ".claude", "settings.json");
 };
 var ensureGlobalClaudeDir = () => {
-  const claudeDir = path2.join(getHomeDir(), ".claude");
-  if (!fs2.existsSync(claudeDir)) {
-    fs2.mkdirSync(claudeDir, { recursive: true });
+  const claudeDir = path3.join(getHomeDir2(), ".claude");
+  if (!fs3.existsSync(claudeDir)) {
+    fs3.mkdirSync(claudeDir, { recursive: true });
   }
   return claudeDir;
 };
 
 // src/launcher.ts
 import { spawn } from "child_process";
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 import chalk2 from "chalk";
-import { decrypt, PERMISSION_PRESETS as PERMISSION_PRESETS2, ensureCcemDir as ensureCcemDir2 } from "@ccem/core";
+var MANAGED_CLAUDE_ENV_KEYS = [
+  "ANTHROPIC_BASE_URL",
+  "ANTHROPIC_AUTH_TOKEN",
+  "ANTHROPIC_DEFAULT_OPUS_MODEL",
+  "ANTHROPIC_DEFAULT_SONNET_MODEL",
+  "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+  "ANTHROPIC_MODEL",
+  "CLAUDE_CODE_SUBAGENT_MODEL",
+  "ANTHROPIC_API_KEY",
+  "ANTHROPIC_SMALL_FAST_MODEL"
+];
 function buildEnvVars(envConfig) {
   const vars = {};
   if (envConfig.ANTHROPIC_BASE_URL) vars.ANTHROPIC_BASE_URL = envConfig.ANTHROPIC_BASE_URL;
-  if (envConfig.ANTHROPIC_API_KEY) vars.ANTHROPIC_API_KEY = decrypt(envConfig.ANTHROPIC_API_KEY);
+  if (envConfig.ANTHROPIC_AUTH_TOKEN) vars.ANTHROPIC_AUTH_TOKEN = decrypt(envConfig.ANTHROPIC_AUTH_TOKEN);
+  if (envConfig.ANTHROPIC_DEFAULT_OPUS_MODEL) vars.ANTHROPIC_DEFAULT_OPUS_MODEL = envConfig.ANTHROPIC_DEFAULT_OPUS_MODEL;
+  if (envConfig.ANTHROPIC_DEFAULT_SONNET_MODEL) vars.ANTHROPIC_DEFAULT_SONNET_MODEL = envConfig.ANTHROPIC_DEFAULT_SONNET_MODEL;
+  if (envConfig.ANTHROPIC_DEFAULT_HAIKU_MODEL) vars.ANTHROPIC_DEFAULT_HAIKU_MODEL = envConfig.ANTHROPIC_DEFAULT_HAIKU_MODEL;
   if (envConfig.ANTHROPIC_MODEL) vars.ANTHROPIC_MODEL = envConfig.ANTHROPIC_MODEL;
-  if (envConfig.ANTHROPIC_SMALL_FAST_MODEL) vars.ANTHROPIC_SMALL_FAST_MODEL = envConfig.ANTHROPIC_SMALL_FAST_MODEL;
+  if (envConfig.CLAUDE_CODE_SUBAGENT_MODEL) vars.CLAUDE_CODE_SUBAGENT_MODEL = envConfig.CLAUDE_CODE_SUBAGENT_MODEL;
   return vars;
 }
 function buildPermArgs(modeName) {
-  const preset = PERMISSION_PRESETS2[modeName];
+  const preset = PERMISSION_PRESETS[modeName];
   if (!preset) return [];
   const args = ["--permission-mode", preset.permissionMode];
   if (preset.permissions.allow.length > 0) {
@@ -1028,22 +1448,25 @@ function buildPermArgs(modeName) {
   return args;
 }
 function ensureSessionsDir() {
-  const dir = path3.join(ensureCcemDir2(), "sessions");
-  if (!fs3.existsSync(dir)) {
-    fs3.mkdirSync(dir, { recursive: true });
+  const dir = path4.join(ensureCcemDir(), "sessions");
+  if (!fs4.existsSync(dir)) {
+    fs4.mkdirSync(dir, { recursive: true });
   }
   return dir;
 }
 async function launchClaude(options) {
   const { envConfig, permMode, workingDir, sessionId, resumeSessionId, silent } = options;
   const env = { ...process.env };
+  for (const key of MANAGED_CLAUDE_ENV_KEYS) {
+    delete env[key];
+  }
   if (envConfig) {
     Object.assign(env, buildEnvVars(envConfig));
   }
   delete env.CLAUDECODE;
   const args = [];
   if (permMode) {
-    const preset = PERMISSION_PRESETS2[permMode];
+    const preset = PERMISSION_PRESETS[permMode];
     if (preset) {
       if (!silent) {
         console.log(chalk2.green(`\u5DF2\u5E94\u7528 ${preset.name}\uFF08\u4E34\u65F6\uFF09`));
@@ -1066,14 +1489,15 @@ async function launchClaude(options) {
   return new Promise((resolve2) => {
     const child = spawn("claude", args, {
       stdio: "inherit",
-      shell: true,
+      shell: false,
+      // 直接执行二进制，避免 shell 注入风险
       env
     });
     child.on("exit", (code) => {
       if (sessionId) {
         try {
-          fs3.writeFileSync(
-            path3.join(sessionsDir, `${sessionId}.exit`),
+          fs4.writeFileSync(
+            path4.join(sessionsDir, `${sessionId}.exit`),
             String(code ?? 0)
           );
         } catch {
@@ -1090,14 +1514,14 @@ async function launchClaude(options) {
 
 // src/permissions.ts
 var readSettings = (settingsPath) => {
-  if (fs4.existsSync(settingsPath)) {
+  if (fs5.existsSync(settingsPath)) {
     try {
-      const content = fs4.readFileSync(settingsPath, "utf-8");
+      const content = fs5.readFileSync(settingsPath, "utf-8");
       return JSON.parse(content);
     } catch {
       console.warn(chalk3.yellow(`\u8B66\u544A: \u65E0\u6CD5\u89E3\u6790 ${settingsPath}\uFF0C\u5C06\u521B\u5EFA\u5907\u4EFD`));
       const backupPath = settingsPath + ".error." + Date.now();
-      fs4.copyFileSync(settingsPath, backupPath);
+      fs5.copyFileSync(settingsPath, backupPath);
       console.log(chalk3.gray(`\u5907\u4EFD\u5DF2\u4FDD\u5B58\u5230: ${backupPath}`));
       return {};
     }
@@ -1106,7 +1530,7 @@ var readSettings = (settingsPath) => {
 };
 var writeSettings = (settingsPath, config3) => {
   ensureClaudeDir();
-  fs4.writeFileSync(settingsPath, JSON.stringify(config3, null, 2) + "\n");
+  fs5.writeFileSync(settingsPath, JSON.stringify(config3, null, 2) + "\n");
 };
 var mergePermissions = (existing, preset) => {
   const existingAllow = existing.permissions?.allow || [];
@@ -1122,7 +1546,7 @@ var mergePermissions = (existing, preset) => {
   };
 };
 var applyPermissionMode = (modeName) => {
-  const preset = PERMISSION_PRESETS3[modeName];
+  const preset = PERMISSION_PRESETS[modeName];
   if (!preset) {
     console.error(chalk3.red(`\u672A\u77E5\u7684\u6743\u9650\u6A21\u5F0F: ${modeName}`));
     console.log(chalk3.yellow("\u53EF\u7528\u6A21\u5F0F: " + getPermissionModeNames().join(", ")));
@@ -1138,14 +1562,14 @@ var applyPermissionMode = (modeName) => {
 };
 var resetPermissions = () => {
   const settingsPath = getSettingsPath(true);
-  if (!fs4.existsSync(settingsPath)) {
+  if (!fs5.existsSync(settingsPath)) {
     console.log(chalk3.yellow("\u6CA1\u6709\u81EA\u5B9A\u4E49\u6743\u9650\u914D\u7F6E\u9700\u8981\u91CD\u7F6E"));
     return;
   }
   const config3 = readSettings(settingsPath);
   delete config3.permissions;
   if (Object.keys(config3).length === 0) {
-    fs4.unlinkSync(settingsPath);
+    fs5.unlinkSync(settingsPath);
     console.log(chalk3.green("\u5DF2\u5220\u9664\u914D\u7F6E\u6587\u4EF6\uFF08\u6587\u4EF6\u4E3A\u7A7A\uFF09"));
   } else {
     writeSettings(settingsPath, config3);
@@ -1155,7 +1579,7 @@ var resetPermissions = () => {
 };
 var showCurrentMode = () => {
   const settingsPath = getSettingsPath(true);
-  if (!fs4.existsSync(settingsPath)) {
+  if (!fs5.existsSync(settingsPath)) {
     console.log(chalk3.yellow("\u672A\u914D\u7F6E\u81EA\u5B9A\u4E49\u6743\u9650"));
     console.log(chalk3.gray(`\u6587\u4EF6\u4E0D\u5B58\u5728: ${settingsPath}`));
     return;
@@ -1165,7 +1589,7 @@ var showCurrentMode = () => {
     console.log(chalk3.yellow("\u672A\u914D\u7F6E\u81EA\u5B9A\u4E49\u6743\u9650"));
     return;
   }
-  const matchedPreset = Object.entries(PERMISSION_PRESETS3).find(([_, preset]) => {
+  const matchedPreset = Object.entries(PERMISSION_PRESETS).find(([_, preset]) => {
     const configAllow = new Set(config3.permissions?.allow || []);
     const configDeny = new Set(config3.permissions?.deny || []);
     const presetAllow = new Set(preset.permissions.allow);
@@ -1197,7 +1621,7 @@ var listAvailableModes = () => {
     style: { head: ["cyan"] },
     colWidths: [15, 15, 50]
   });
-  Object.entries(PERMISSION_PRESETS3).forEach(([key, preset]) => {
+  Object.entries(PERMISSION_PRESETS).forEach(([key, preset]) => {
     table.push([preset.name, `--${key}`, preset.description]);
   });
   console.log(chalk3.bold("\u53EF\u7528\u6743\u9650\u6A21\u5F0F:\n"));
@@ -1206,7 +1630,7 @@ var listAvailableModes = () => {
   console.log(chalk3.gray("\u6C38\u4E45\u6A21\u5F0F: ccem setup perms --<mode>"));
 };
 var runWithTempPermissions = async (modeName, envConfig) => {
-  const preset = PERMISSION_PRESETS3[modeName];
+  const preset = PERMISSION_PRESETS[modeName];
   if (!preset) {
     console.error(chalk3.red(`\u672A\u77E5\u7684\u6743\u9650\u6A21\u5F0F: ${modeName}`));
     console.log(chalk3.yellow("\u53EF\u7528\u6A21\u5F0F: " + getPermissionModeNames().join(", ")));
@@ -1216,13 +1640,13 @@ var runWithTempPermissions = async (modeName, envConfig) => {
 };
 
 // src/setup.ts
-import fs5 from "fs";
+import fs6 from "fs";
 import chalk4 from "chalk";
 import { spawn as spawn2 } from "child_process";
 var readJsonFile = (filePath) => {
-  if (fs5.existsSync(filePath)) {
+  if (fs6.existsSync(filePath)) {
     try {
-      const content = fs5.readFileSync(filePath, "utf-8");
+      const content = fs6.readFileSync(filePath, "utf-8");
       return JSON.parse(content);
     } catch {
       console.warn(chalk4.yellow(`\u8B66\u544A: \u65E0\u6CD5\u89E3\u6790 ${filePath}`));
@@ -1232,7 +1656,7 @@ var readJsonFile = (filePath) => {
   return {};
 };
 var writeJsonFile = (filePath, data) => {
-  fs5.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+  fs6.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
 };
 var setupOnboarding = () => {
   const configPath = getGlobalClaudeConfigPath();
@@ -1332,14 +1756,19 @@ var setupMcpTool = () => {
     });
   });
 };
-var runSetupInit = async () => {
+var runSetupInit = async (options = {}) => {
   console.log(chalk4.bold("\n\u{1F527} Claude Code \u521D\u59CB\u5316\u8BBE\u7F6E\n"));
   console.log(chalk4.cyan("1. \u8BBE\u7F6E onboarding \u72B6\u6001"));
   const step1 = setupOnboarding();
   console.log(chalk4.cyan("\n2. \u914D\u7F6E\u9690\u79C1\u8BBE\u7F6E"));
   const step2 = setupEnvSettings();
-  console.log(chalk4.cyan("\n3. \u5B89\u88C5 MCP \u5DE5\u5177"));
-  const step3 = await setupMcpTool();
+  let step3 = true;
+  if (options.chrome) {
+    console.log(chalk4.cyan("\n3. \u5B89\u88C5 MCP \u5DE5\u5177"));
+    step3 = await setupMcpTool();
+  } else {
+    console.log(chalk4.gray("\n3. \u5B89\u88C5 MCP \u5DE5\u5177\uFF08\u5DF2\u8DF3\u8FC7\uFF0C\u4F7F\u7528 --chrome \u542F\u7528\uFF09"));
+  }
   console.log("");
   if (step1 && step2 && step3) {
     console.log(chalk4.green.bold("\u2705 \u521D\u59CB\u5316\u5B8C\u6210\uFF01"));
@@ -1354,8 +1783,8 @@ var runSetupInit = async () => {
 
 // src/skills.ts
 import { execSync } from "child_process";
-import * as fs6 from "fs";
-import * as path4 from "path";
+import * as fs7 from "fs";
+import * as path5 from "path";
 import chalk5 from "chalk";
 var SKILL_GROUPS = {
   official: { label: "\u5B98\u65B9", icon: "\u{1F3E2}" },
@@ -1524,12 +1953,12 @@ function parseGitHubUrl(url) {
   };
 }
 function getSkillsDir() {
-  return path4.join(process.cwd(), ".claude", "skills");
+  return path5.join(process.cwd(), ".claude", "skills");
 }
 function ensureSkillsDir() {
   const skillsDir = getSkillsDir();
-  if (!fs6.existsSync(skillsDir)) {
-    fs6.mkdirSync(skillsDir, { recursive: true });
+  if (!fs7.existsSync(skillsDir)) {
+    fs7.mkdirSync(skillsDir, { recursive: true });
   } else {
     cleanupTempDirs(skillsDir);
   }
@@ -1537,11 +1966,11 @@ function ensureSkillsDir() {
 }
 function cleanupTempDirs(skillsDir) {
   try {
-    const entries = fs6.readdirSync(skillsDir, { withFileTypes: true });
+    const entries = fs7.readdirSync(skillsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory() && entry.name.startsWith(".tmp-")) {
-        const tmpPath = path4.join(skillsDir, entry.name);
-        fs6.rmSync(tmpPath, { recursive: true });
+        const tmpPath = path5.join(skillsDir, entry.name);
+        fs7.rmSync(tmpPath, { recursive: true });
       }
     }
   } catch {
@@ -1549,24 +1978,24 @@ function cleanupTempDirs(skillsDir) {
 }
 function downloadSkillWithGit(owner, repo, branch, repoPath, targetName) {
   const skillsDir = ensureSkillsDir();
-  const targetDir = path4.join(skillsDir, targetName);
-  if (fs6.existsSync(targetDir)) {
+  const targetDir = path5.join(skillsDir, targetName);
+  if (fs7.existsSync(targetDir)) {
     console.log(chalk5.yellow(`Skill "${targetName}" already exists. Updating...`));
-    fs6.rmSync(targetDir, { recursive: true });
+    fs7.rmSync(targetDir, { recursive: true });
   }
   const repoUrl = `https://github.com/${owner}/${repo}.git`;
-  const tempDir = path4.join(skillsDir, `.tmp-${Date.now()}`);
+  const tempDir = path5.join(skillsDir, `.tmp-${Date.now()}`);
   try {
-    fs6.mkdirSync(tempDir, { recursive: true });
+    fs7.mkdirSync(tempDir, { recursive: true });
     execSync(`git init`, { cwd: tempDir, stdio: "pipe" });
     execSync(`git remote add origin ${repoUrl}`, { cwd: tempDir, stdio: "pipe" });
     execSync(`git config core.sparseCheckout true`, { cwd: tempDir, stdio: "pipe" });
-    const sparseFile = path4.join(tempDir, ".git", "info", "sparse-checkout");
-    fs6.writeFileSync(sparseFile, repoPath ? `${repoPath}/
+    const sparseFile = path5.join(tempDir, ".git", "info", "sparse-checkout");
+    fs7.writeFileSync(sparseFile, repoPath ? `${repoPath}/
 ` : "*\n");
     execSync(`git pull --depth=1 origin ${branch}`, { cwd: tempDir, stdio: "pipe" });
-    const sourceDir = repoPath ? path4.join(tempDir, repoPath) : tempDir;
-    if (!fs6.existsSync(sourceDir)) {
+    const sourceDir = repoPath ? path5.join(tempDir, repoPath) : tempDir;
+    if (!fs7.existsSync(sourceDir)) {
       throw new Error(`Path "${repoPath}" not found in repository`);
     }
     copyDir(sourceDir, targetDir);
@@ -1577,22 +2006,22 @@ function downloadSkillWithGit(owner, repo, branch, repoPath, targetName) {
     console.error(chalk5.red(`Failed to download skill: ${errMsg}`));
     return false;
   } finally {
-    if (fs6.existsSync(tempDir)) {
-      fs6.rmSync(tempDir, { recursive: true });
+    if (fs7.existsSync(tempDir)) {
+      fs7.rmSync(tempDir, { recursive: true });
     }
   }
 }
 function copyDir(src, dest) {
-  fs6.mkdirSync(dest, { recursive: true });
-  const entries = fs6.readdirSync(src, { withFileTypes: true });
+  fs7.mkdirSync(dest, { recursive: true });
+  const entries = fs7.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === ".git") continue;
-    const srcPath = path4.join(src, entry.name);
-    const destPath = path4.join(dest, entry.name);
+    const srcPath = path5.join(src, entry.name);
+    const destPath = path5.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDir(srcPath, destPath);
     } else {
-      fs6.copyFileSync(srcPath, destPath);
+      fs7.copyFileSync(srcPath, destPath);
     }
   }
 }
@@ -1638,7 +2067,7 @@ function addSkillFromGitHub(urlOrPreset) {
   }
   let skillName;
   if (parsed.path) {
-    skillName = path4.basename(parsed.path);
+    skillName = path5.basename(parsed.path);
   } else {
     skillName = parsed.repo;
   }
@@ -1652,23 +2081,23 @@ function addSkillFromGitHub(urlOrPreset) {
 }
 function listInstalledSkills() {
   const skillsDir = getSkillsDir();
-  if (!fs6.existsSync(skillsDir)) {
+  if (!fs7.existsSync(skillsDir)) {
     return [];
   }
-  const entries = fs6.readdirSync(skillsDir, { withFileTypes: true });
+  const entries = fs7.readdirSync(skillsDir, { withFileTypes: true });
   return entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => ({
     name: entry.name,
-    path: path4.join(skillsDir, entry.name)
+    path: path5.join(skillsDir, entry.name)
   }));
 }
 function removeSkill(name) {
   const skillsDir = getSkillsDir();
-  const targetDir = path4.join(skillsDir, name);
-  if (!fs6.existsSync(targetDir)) {
+  const targetDir = path5.join(skillsDir, name);
+  if (!fs7.existsSync(targetDir)) {
     console.error(chalk5.red(`Skill "${name}" not found`));
     return false;
   }
-  fs6.rmSync(targetDir, { recursive: true });
+  fs7.rmSync(targetDir, { recursive: true });
   console.log(chalk5.green(`Removed skill "${name}"`));
   return true;
 }
@@ -1826,19 +2255,20 @@ async function runSkillSelector() {
 }
 
 // src/remote.ts
-import crypto2 from "crypto";
+import crypto3 from "crypto";
 import chalk6 from "chalk";
 import Conf from "conf";
-import { encrypt } from "@ccem/core";
 var config = new Conf({
-  projectName: "claude-code-env-manager"
+  projectName: "claude-code-env-manager",
+  cwd: getCcemConfigDir()
+  // 使用统一的配置目录
 });
 var decryptWithSecret = (encryptedBase64, secret) => {
-  const key = crypto2.scryptSync(secret, "ccem-salt", 32);
+  const key = crypto3.scryptSync(secret, "ccem-salt", 32);
   const combined = Buffer.from(encryptedBase64, "base64");
   const iv = combined.subarray(0, 16);
   const encryptedHex = combined.subarray(16).toString("hex");
-  const decipher = crypto2.createDecipheriv("aes-256-cbc", key, iv);
+  const decipher = crypto3.createDecipheriv("aes-256-cbc", key, iv);
   let decrypted = decipher.update(encryptedHex, "hex", "utf8");
   decrypted += decipher.final("utf8");
   return decrypted;
@@ -1859,7 +2289,11 @@ var loadFromRemote = async (url, secret) => {
   console.log(chalk6.gray("Fetching from remote..."));
   let response;
   try {
-    response = await fetch(url);
+    response = await fetch(url, {
+      headers: {
+        "X-CCEM-Key": secret
+      }
+    });
   } catch (err) {
     console.error(chalk6.red("Error: Failed to connect to server"));
     console.error(chalk6.gray(err.message));
@@ -1906,9 +2340,10 @@ var loadFromRemote = async (url, secret) => {
   for (const [name, envConfig] of Object.entries(decrypted.environments)) {
     const uniqueName = getUniqueName(name, existingNames);
     const renamed = uniqueName !== name;
-    const configToSave = { ...envConfig };
-    if (configToSave.ANTHROPIC_API_KEY) {
-      configToSave.ANTHROPIC_API_KEY = encrypt(configToSave.ANTHROPIC_API_KEY);
+    const normalizedConfig = normalizeEnvConfig(envConfig);
+    const configToSave = { ...normalizedConfig };
+    if (configToSave.ANTHROPIC_AUTH_TOKEN) {
+      configToSave.ANTHROPIC_AUTH_TOKEN = encrypt(configToSave.ANTHROPIC_AUTH_TOKEN);
     }
     registries[uniqueName] = configToSave;
     existingNames.add(uniqueName);
@@ -1929,6 +2364,7 @@ Loaded ${results.length} environment(s) from remote:`));
     }
   }
   console.log(chalk6.gray("\nRun 'ccem ls' to see all environments."));
+  return results;
 };
 
 // src/cron-skill.ts
@@ -2074,28 +2510,182 @@ Replace \\\`TARGET_ID\\\` or \\\`TARGET_NAME\\\` with the user's selection.
 `;
 
 // src/index.ts
-var __filename = fileURLToPath(import.meta.url);
-var __dirname2 = path5.dirname(__filename);
-var pkgPath = path5.resolve(__dirname2, "..", "package.json");
-var pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path6.dirname(__filename2);
+var pkgPath = path6.resolve(__dirname2, "..", "package.json");
+var pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
 var program = new Command();
-ensureCcemDir3();
+var DEFAULT_OFFICIAL_ENV = {
+  ANTHROPIC_BASE_URL: "https://api.anthropic.com",
+  ANTHROPIC_DEFAULT_OPUS_MODEL: "claude-opus-4-1-20250805",
+  ANTHROPIC_DEFAULT_SONNET_MODEL: "claude-opus-4-1-20250805",
+  ANTHROPIC_DEFAULT_HAIKU_MODEL: "claude-3-5-haiku-20241022",
+  ANTHROPIC_MODEL: "opus"
+};
+var MANAGED_CLAUDE_ENV_KEYS2 = [
+  "ANTHROPIC_BASE_URL",
+  "ANTHROPIC_AUTH_TOKEN",
+  "ANTHROPIC_DEFAULT_OPUS_MODEL",
+  "ANTHROPIC_DEFAULT_SONNET_MODEL",
+  "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+  "ANTHROPIC_MODEL",
+  "CLAUDE_CODE_SUBAGENT_MODEL",
+  "ANTHROPIC_API_KEY",
+  "ANTHROPIC_SMALL_FAST_MODEL"
+];
+var shellQuote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
+var clearManagedClaudeEnv = (env) => {
+  for (const key of MANAGED_CLAUDE_ENV_KEYS2) {
+    delete env[key];
+  }
+};
+var buildResolvedEnvVars = (env) => {
+  const resolved = {};
+  if (env.ANTHROPIC_BASE_URL) resolved.ANTHROPIC_BASE_URL = env.ANTHROPIC_BASE_URL;
+  if (env.ANTHROPIC_AUTH_TOKEN) resolved.ANTHROPIC_AUTH_TOKEN = decrypt(env.ANTHROPIC_AUTH_TOKEN);
+  if (env.ANTHROPIC_DEFAULT_OPUS_MODEL) resolved.ANTHROPIC_DEFAULT_OPUS_MODEL = env.ANTHROPIC_DEFAULT_OPUS_MODEL;
+  if (env.ANTHROPIC_DEFAULT_SONNET_MODEL) resolved.ANTHROPIC_DEFAULT_SONNET_MODEL = env.ANTHROPIC_DEFAULT_SONNET_MODEL;
+  if (env.ANTHROPIC_DEFAULT_HAIKU_MODEL) resolved.ANTHROPIC_DEFAULT_HAIKU_MODEL = env.ANTHROPIC_DEFAULT_HAIKU_MODEL;
+  if (env.ANTHROPIC_MODEL) resolved.ANTHROPIC_MODEL = env.ANTHROPIC_MODEL;
+  if (env.CLAUDE_CODE_SUBAGENT_MODEL) resolved.CLAUDE_CODE_SUBAGENT_MODEL = env.CLAUDE_CODE_SUBAGENT_MODEL;
+  return resolved;
+};
+var buildShellEnvCommands = (env) => {
+  const resolved = buildResolvedEnvVars(env);
+  return MANAGED_CLAUDE_ENV_KEYS2.map(
+    (key) => resolved[key] ? `export ${key}=${shellQuote(resolved[key])}` : `unset ${key}`
+  );
+};
+ensureCcemDir();
 var config2 = new Conf2({
   projectName: "claude-code-env-manager",
   cwd: getCcemConfigDir(),
   // 使用新路径
   defaults: {
     registries: {
-      "official": {
-        ANTHROPIC_BASE_URL: "https://api.anthropic.com",
-        ANTHROPIC_MODEL: "claude-sonnet-4-5-20250929",
-        ANTHROPIC_SMALL_FAST_MODEL: "claude-haiku-4-5-20251001"
-      }
+      official: DEFAULT_OFFICIAL_ENV
     },
     current: "official",
     defaultMode: null
   }
 });
+var recoverRegistriesFromLegacy = (registries) => {
+  const currentAuthCount = Object.values(registries).filter(
+    (env) => Boolean(env.ANTHROPIC_AUTH_TOKEN)
+  ).length;
+  if (currentAuthCount > 0) {
+    return registries;
+  }
+  const legacyConfigPath = getLegacyConfigPath();
+  if (!fs8.existsSync(legacyConfigPath)) {
+    return registries;
+  }
+  try {
+    const legacyRaw = JSON.parse(fs8.readFileSync(legacyConfigPath, "utf-8"));
+    const legacyRegistries = legacyRaw.registries ?? {};
+    let changed = false;
+    const recovered = { ...registries };
+    for (const [name, envConfig] of Object.entries(registries)) {
+      const legacyEnvConfig = legacyRegistries[name];
+      if (!legacyEnvConfig) {
+        continue;
+      }
+      const recoveredEnv = recoverEnvConfigFromLegacy(envConfig, legacyEnvConfig);
+      if (JSON.stringify(recoveredEnv) !== JSON.stringify(envConfig)) {
+        recovered[name] = recoveredEnv;
+        changed = true;
+      }
+    }
+    return changed ? recovered : registries;
+  } catch {
+    return registries;
+  }
+};
+var getRegistries = () => {
+  const rawRegistries = config2.get("registries") ?? {};
+  const normalizedEntries = Object.entries(rawRegistries).map(([name, envConfig]) => [
+    name,
+    normalizeEnvConfig(envConfig ?? {})
+  ]);
+  const normalizedRegistries = Object.fromEntries(normalizedEntries);
+  const repairedRegistries = recoverRegistriesFromLegacy(normalizedRegistries);
+  if (!repairedRegistries.official) {
+    repairedRegistries.official = { ...DEFAULT_OFFICIAL_ENV };
+  }
+  const changed = Object.keys(rawRegistries).length !== Object.keys(repairedRegistries).length || JSON.stringify(rawRegistries) !== JSON.stringify(repairedRegistries);
+  if (changed) {
+    config2.set("registries", repairedRegistries);
+  }
+  return repairedRegistries;
+};
+var setRegistries = (registries) => {
+  config2.set("registries", registries);
+};
+var getDecryptedAuthToken = (envConfig) => {
+  return envConfig.ANTHROPIC_AUTH_TOKEN ? decrypt(envConfig.ANTHROPIC_AUTH_TOKEN) : void 0;
+};
+var applyPromptAnswers = (current, answers, keepCurrentSecret) => {
+  const next = {
+    ...current,
+    ANTHROPIC_BASE_URL: answers.ANTHROPIC_BASE_URL?.trim() || current.ANTHROPIC_BASE_URL,
+    ANTHROPIC_DEFAULT_OPUS_MODEL: answers.ANTHROPIC_DEFAULT_OPUS_MODEL?.trim() || current.ANTHROPIC_DEFAULT_OPUS_MODEL,
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: answers.ANTHROPIC_DEFAULT_HAIKU_MODEL?.trim() || current.ANTHROPIC_DEFAULT_HAIKU_MODEL,
+    ANTHROPIC_DEFAULT_SONNET_MODEL: answers.ANTHROPIC_DEFAULT_SONNET_MODEL?.trim() || answers.ANTHROPIC_DEFAULT_OPUS_MODEL?.trim() || current.ANTHROPIC_DEFAULT_SONNET_MODEL || current.ANTHROPIC_DEFAULT_OPUS_MODEL,
+    ANTHROPIC_MODEL: answers.ANTHROPIC_MODEL?.trim() || current.ANTHROPIC_MODEL || "opus",
+    CLAUDE_CODE_SUBAGENT_MODEL: answers.CLAUDE_CODE_SUBAGENT_MODEL?.trim() || current.CLAUDE_CODE_SUBAGENT_MODEL
+  };
+  if (!keepCurrentSecret) {
+    next.ANTHROPIC_AUTH_TOKEN = answers.ANTHROPIC_AUTH_TOKEN ? encrypt(answers.ANTHROPIC_AUTH_TOKEN) : void 0;
+  } else if (answers.ANTHROPIC_AUTH_TOKEN) {
+    next.ANTHROPIC_AUTH_TOKEN = encrypt(answers.ANTHROPIC_AUTH_TOKEN);
+  }
+  return normalizeEnvConfig(next);
+};
+var promptForEnvironmentConfig = async (current = {}, keepCurrentSecret = false) => {
+  return inquirer.prompt([
+    {
+      type: "input",
+      name: "ANTHROPIC_BASE_URL",
+      message: "ANTHROPIC_BASE_URL:",
+      default: current.ANTHROPIC_BASE_URL || DEFAULT_OFFICIAL_ENV.ANTHROPIC_BASE_URL
+    },
+    {
+      type: "password",
+      name: "ANTHROPIC_AUTH_TOKEN",
+      message: keepCurrentSecret ? "ANTHROPIC_AUTH_TOKEN (leave empty to keep current):" : "ANTHROPIC_AUTH_TOKEN:"
+    },
+    {
+      type: "input",
+      name: "ANTHROPIC_DEFAULT_OPUS_MODEL",
+      message: "ANTHROPIC_DEFAULT_OPUS_MODEL:",
+      default: current.ANTHROPIC_DEFAULT_OPUS_MODEL || DEFAULT_OFFICIAL_ENV.ANTHROPIC_DEFAULT_OPUS_MODEL
+    },
+    {
+      type: "input",
+      name: "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+      message: "ANTHROPIC_DEFAULT_HAIKU_MODEL:",
+      default: current.ANTHROPIC_DEFAULT_HAIKU_MODEL || DEFAULT_OFFICIAL_ENV.ANTHROPIC_DEFAULT_HAIKU_MODEL
+    },
+    {
+      type: "input",
+      name: "ANTHROPIC_DEFAULT_SONNET_MODEL",
+      message: "ANTHROPIC_DEFAULT_SONNET_MODEL (blank = same as opus):",
+      default: current.ANTHROPIC_DEFAULT_SONNET_MODEL || current.ANTHROPIC_DEFAULT_OPUS_MODEL || ""
+    },
+    {
+      type: "input",
+      name: "ANTHROPIC_MODEL",
+      message: "ANTHROPIC_MODEL (e.g. opus, opusplan, sonnet):",
+      default: current.ANTHROPIC_MODEL || "opus"
+    },
+    {
+      type: "input",
+      name: "CLAUDE_CODE_SUBAGENT_MODEL",
+      message: "CLAUDE_CODE_SUBAGENT_MODEL (optional):",
+      default: current.CLAUDE_CODE_SUBAGENT_MODEL || ""
+    }
+  ]);
+};
 var PERMISSION_MODES = ["yolo", "dev", "readonly", "safe", "ci", "audit"];
 var usageStats = null;
 var usageLoading = true;
@@ -2132,9 +2722,9 @@ var initUsageStats = (onUpdate) => {
 };
 program.name("ccem").description("Claude Code Environment Manager - \u7BA1\u7406 Claude Code \u73AF\u5883\u53D8\u91CF\u548C\u6743\u9650").version(pkg.version).option("--mode", "\u67E5\u770B\u5F53\u524D\u6743\u9650\u6A21\u5F0F").option("--list-modes", "\u5217\u51FA\u6240\u6709\u53EF\u7528\u6743\u9650\u6A21\u5F0F");
 PERMISSION_MODES.forEach((mode) => {
-  const preset = PERMISSION_PRESETS4[mode];
+  const preset = PERMISSION_PRESETS[mode];
   program.command(mode).description(`\u4E34\u65F6\u5E94\u7528 ${preset.name}\uFF0C\u9000\u51FA\u540E\u8FD8\u539F`).action(async () => {
-    const registries = config2.get("registries");
+    const registries = getRegistries();
     const current = config2.get("current");
     const envConfig = registries[current];
     await runWithTempPermissions(mode, envConfig);
@@ -2143,15 +2733,18 @@ PERMISSION_MODES.forEach((mode) => {
 var showCurrentEnv = (usageStats2, usageLoading2) => {
   if (!process.stdout.isTTY) return;
   const current = config2.get("current");
-  const registries = config2.get("registries");
+  const registries = getRegistries();
   const env = registries[current];
   const defaultMode = config2.get("defaultMode");
   if (!env) return;
   console.log(renderLogoWithEnvPanel(current, {
     ANTHROPIC_BASE_URL: env.ANTHROPIC_BASE_URL,
-    ANTHROPIC_API_KEY: env.ANTHROPIC_API_KEY ? decrypt2(env.ANTHROPIC_API_KEY) : void 0,
+    ANTHROPIC_AUTH_TOKEN: getDecryptedAuthToken(env),
+    ANTHROPIC_DEFAULT_OPUS_MODEL: env.ANTHROPIC_DEFAULT_OPUS_MODEL,
+    ANTHROPIC_DEFAULT_SONNET_MODEL: env.ANTHROPIC_DEFAULT_SONNET_MODEL,
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: env.ANTHROPIC_DEFAULT_HAIKU_MODEL,
     ANTHROPIC_MODEL: env.ANTHROPIC_MODEL,
-    ANTHROPIC_SMALL_FAST_MODEL: env.ANTHROPIC_SMALL_FAST_MODEL
+    CLAUDE_CODE_SUBAGENT_MODEL: env.CLAUDE_CODE_SUBAGENT_MODEL
   }, defaultMode));
   console.log("");
   console.log(renderUsageLine(usageStats2, usageLoading2));
@@ -2159,7 +2752,7 @@ var showCurrentEnv = (usageStats2, usageLoading2) => {
   console.log("");
 };
 var switchEnvironment = async (name) => {
-  const registries = config2.get("registries");
+  const registries = getRegistries();
   if (!registries[name]) {
     console.error(chalk7.red(`Environment '${name}' not found.`));
     return;
@@ -2172,11 +2765,7 @@ var switchEnvironment = async (name) => {
   }
   showCurrentEnv(null, false);
   const env = registries[name];
-  const exportCmds = [];
-  if (env.ANTHROPIC_BASE_URL) exportCmds.push(`export ANTHROPIC_BASE_URL="${env.ANTHROPIC_BASE_URL}"`);
-  if (env.ANTHROPIC_API_KEY) exportCmds.push(`export ANTHROPIC_API_KEY="${decrypt2(env.ANTHROPIC_API_KEY)}"`);
-  if (env.ANTHROPIC_MODEL) exportCmds.push(`export ANTHROPIC_MODEL="${env.ANTHROPIC_MODEL}"`);
-  if (env.ANTHROPIC_SMALL_FAST_MODEL) exportCmds.push(`export ANTHROPIC_SMALL_FAST_MODEL="${env.ANTHROPIC_SMALL_FAST_MODEL}"`);
+  const exportCmds = buildShellEnvCommands(env);
   if (process.stdout.isTTY) {
     console.log(chalk7.yellow("\nTo apply to current shell immediately, run:"));
     console.log(chalk7.cyan("eval $(ccem env)"));
@@ -2186,11 +2775,92 @@ var switchEnvironment = async (name) => {
     exportCmds.forEach((cmd) => console.log(cmd));
   }
 };
+var getSessionsFilePath = () => path6.join(getCcemConfigDir(), "sessions.json");
+var getRuntimeStateFilePath = () => path6.join(getCcemConfigDir(), "runtime-state.json");
+var parseJsonFile = (filePath) => {
+  if (!fs8.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(fs8.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+};
+var readInteractiveAttachSessions = () => {
+  const sessionsById = /* @__PURE__ */ new Map();
+  const runtimeState = parseJsonFile(getRuntimeStateFilePath());
+  const persistedSessions = parseJsonFile(getSessionsFilePath()) ?? [];
+  for (const entry of runtimeState?.sessions ?? []) {
+    if (entry.runtime_kind && entry.runtime_kind !== "interactive") {
+      continue;
+    }
+    const fallback = persistedSessions.find((session) => session.id === entry.runtime_id);
+    const tmuxTarget = entry.tmux_session && entry.tmux_window ? `${entry.tmux_session}:${entry.tmux_window}` : fallback?.window_id ?? null;
+    if (!tmuxTarget) {
+      continue;
+    }
+    sessionsById.set(entry.runtime_id, {
+      id: entry.runtime_id,
+      projectDir: entry.project_dir,
+      envName: entry.env_name,
+      permMode: entry.perm_mode,
+      status: fallback?.status ?? "running",
+      tmuxTarget,
+      sortTime: entry.saved_at
+    });
+  }
+  for (const session of persistedSessions) {
+    if (session.status !== "running" || session.terminal_type !== "embedded" || !session.window_id) {
+      continue;
+    }
+    if (sessionsById.has(session.id)) {
+      continue;
+    }
+    sessionsById.set(session.id, {
+      id: session.id,
+      projectDir: session.working_dir,
+      envName: session.env_name,
+      permMode: session.perm_mode,
+      status: session.status,
+      tmuxTarget: session.window_id,
+      sortTime: session.start_time
+    });
+  }
+  return [...sessionsById.values()].sort(
+    (left, right) => right.sortTime.localeCompare(left.sortTime)
+  );
+};
+var findAttachSession = (id) => {
+  const sessions = readInteractiveAttachSessions();
+  if (!id) {
+    return sessions[0];
+  }
+  const exact = sessions.find((session) => session.id === id);
+  if (exact) {
+    return exact;
+  }
+  return sessions.find((session) => session.id.startsWith(id));
+};
+var attachTmuxTarget = (target) => {
+  const args = process.env.TMUX ? ["switch-client", "-t", target] : ["attach-session", "-t", target];
+  return new Promise((resolve2, reject) => {
+    const child = spawn3("tmux", args, { stdio: "inherit" });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0 || code === null) {
+        resolve2();
+      } else {
+        reject(new Error(`tmux exited with code ${code}`));
+      }
+    });
+  });
+};
 program.command("ls").description("List all configured environments").action(() => {
-  const registries = config2.get("registries");
+  const registries = getRegistries();
   const current = config2.get("current");
   const table = new Table3({
-    head: ["Name", "Base URL", "Model"],
+    head: ["Name", "Base URL", "Opus"],
     style: { head: ["cyan"] }
   });
   Object.keys(registries).forEach((name) => {
@@ -2199,7 +2869,7 @@ program.command("ls").description("List all configured environments").action(()
     table.push([
       prefix + name,
       reg.ANTHROPIC_BASE_URL || "-",
-      reg.ANTHROPIC_MODEL || "-"
+      reg.ANTHROPIC_DEFAULT_OPUS_MODEL || "-"
     ]);
   });
   console.log(table.toString());
@@ -2207,8 +2877,42 @@ program.command("ls").description("List all configured environments").action(()
 program.command("use <name>").description("Switch to a specific environment").action(async (name) => {
   await switchEnvironment(name);
 });
+program.command("sessions").description("List tmux-backed interactive sessions").action(() => {
+  const sessions = readInteractiveAttachSessions();
+  if (sessions.length === 0) {
+    console.log(chalk7.yellow("No tmux-backed interactive sessions found."));
+    return;
+  }
+  const table = new Table3({
+    head: ["ID", "Project", "Env", "Status", "Tmux"],
+    style: { head: ["cyan"] }
+  });
+  sessions.forEach((session) => {
+    table.push([
+      session.id,
+      session.projectDir,
+      session.envName,
+      session.status,
+      session.tmuxTarget
+    ]);
+  });
+  console.log(table.toString());
+});
+program.command("attach [id]").description("Attach to a tmux-backed interactive session").action(async (id) => {
+  const session = findAttachSession(id);
+  if (!session) {
+    console.error(chalk7.red(id ? `Interactive session '${id}' not found.` : "No interactive session available to attach."));
+    process.exit(1);
+  }
+  try {
+    await attachTmuxTarget(session.tmuxTarget);
+  } catch (error) {
+    console.error(chalk7.red(`Failed to attach ${session.tmuxTarget}: ${String(error)}`));
+    process.exit(1);
+  }
+});
 program.command("add <name>").description("Add a new environment configuration").action(async (name) => {
-  const registries = config2.get("registries");
+  const registries = getRegistries();
   if (registries[name]) {
     console.log(chalk7.red(`Environment '${name}' already exists.`));
     return;
@@ -2233,40 +2937,13 @@ program.command("add <name>").description("Add a new environment configuration")
     ]);
     presetConfig = ENV_PRESETS[presetName];
   }
-  const answers = await inquirer.prompt([
-    {
-      type: "input",
-      name: "ANTHROPIC_BASE_URL",
-      message: "Enter ANTHROPIC_BASE_URL:",
-      default: presetConfig.ANTHROPIC_BASE_URL || "https://api.anthropic.com"
-    },
-    {
-      type: "password",
-      name: "ANTHROPIC_API_KEY",
-      message: "Enter ANTHROPIC_API_KEY:"
-    },
-    {
-      type: "input",
-      name: "ANTHROPIC_MODEL",
-      message: "Enter ANTHROPIC_MODEL:",
-      default: presetConfig.ANTHROPIC_MODEL || "claude-sonnet-4-5-20250929"
-    },
-    {
-      type: "input",
-      name: "ANTHROPIC_SMALL_FAST_MODEL",
-      message: "Enter ANTHROPIC_SMALL_FAST_MODEL:",
-      default: presetConfig.ANTHROPIC_SMALL_FAST_MODEL || "claude-haiku-4-5-20251001"
-    }
-  ]);
-  if (answers.ANTHROPIC_API_KEY) {
-    answers.ANTHROPIC_API_KEY = encrypt2(answers.ANTHROPIC_API_KEY);
-  }
-  registries[name] = answers;
-  config2.set("registries", registries);
+  const answers = await promptForEnvironmentConfig(presetConfig);
+  registries[name] = applyPromptAnswers(normalizeEnvConfig(presetConfig), answers, false);
+  setRegistries(registries);
   console.log(chalk7.green(`Environment '${name}' added successfully.`));
 });
 program.command("del <name>").description("Delete an environment configuration").action((name) => {
-  const registries = config2.get("registries");
+  const registries = getRegistries();
   if (!registries[name]) {
     console.log(chalk7.red(`Environment '${name}' not found.`));
     return;
@@ -2276,7 +2953,7 @@ program.command("del <name>").description("Delete an environment configuration")
     return;
   }
   delete registries[name];
-  config2.set("registries", registries);
+  setRegistries(registries);
   const current = config2.get("current");
   if (current === name) {
     config2.set("current", "official");
@@ -2285,7 +2962,7 @@ program.command("del <name>").description("Delete an environment configuration")
   console.log(chalk7.green(`Environment '${name}' deleted.`));
 });
 program.command("rename <old> <new>").description("Rename an environment configuration").action((oldName, newName) => {
-  const registries = config2.get("registries");
+  const registries = getRegistries();
   if (!registries[oldName]) {
     console.log(chalk7.red(`Environment '${oldName}' not found.`));
     return;
@@ -2300,7 +2977,7 @@ program.command("rename <old> <new>").description("Rename an environment configu
   }
   registries[newName] = registries[oldName];
   delete registries[oldName];
-  config2.set("registries", registries);
+  setRegistries(registries);
   const current = config2.get("current");
   if (current === oldName) {
     config2.set("current", newName);
@@ -2308,7 +2985,7 @@ program.command("rename <old> <new>").description("Rename an environment configu
   console.log(chalk7.green(`Environment '${oldName}' renamed to '${newName}'.`));
 });
 program.command("cp <source> <target>").description("Copy an environment configuration").action(async (source, target) => {
-  const registries = config2.get("registries");
+  const registries = getRegistries();
   if (!registries[source]) {
     console.log(chalk7.red(`Environment '${source}' not found.`));
     return;
@@ -2318,7 +2995,7 @@ program.command("cp <source> <target>").description("Copy an environment configu
     return;
   }
   registries[target] = { ...registries[source] };
-  config2.set("registries", registries);
+  setRegistries(registries);
   console.log(chalk7.green(`Environment '${source}' copied to '${target}'.`));
   const { modify } = await inquirer.prompt([
     {
@@ -2330,37 +3007,9 @@ program.command("cp <source> <target>").description("Copy an environment configu
   ]);
   if (modify) {
     const current = registries[target];
-    const answers = await inquirer.prompt([
-      {
-        type: "input",
-        name: "ANTHROPIC_BASE_URL",
-        message: "ANTHROPIC_BASE_URL:",
-        default: current.ANTHROPIC_BASE_URL
-      },
-      {
-        type: "password",
-        name: "ANTHROPIC_API_KEY",
-        message: "ANTHROPIC_API_KEY (leave empty to keep current):"
-      },
-      {
-        type: "input",
-        name: "ANTHROPIC_MODEL",
-        message: "ANTHROPIC_MODEL:",
-        default: current.ANTHROPIC_MODEL
-      },
-      {
-        type: "input",
-        name: "ANTHROPIC_SMALL_FAST_MODEL",
-        message: "ANTHROPIC_SMALL_FAST_MODEL:",
-        default: current.ANTHROPIC_SMALL_FAST_MODEL
-      }
-    ]);
-    if (answers.ANTHROPIC_BASE_URL) current.ANTHROPIC_BASE_URL = answers.ANTHROPIC_BASE_URL;
-    if (answers.ANTHROPIC_API_KEY) current.ANTHROPIC_API_KEY = encrypt2(answers.ANTHROPIC_API_KEY);
-    if (answers.ANTHROPIC_MODEL) current.ANTHROPIC_MODEL = answers.ANTHROPIC_MODEL;
-    if (answers.ANTHROPIC_SMALL_FAST_MODEL) current.ANTHROPIC_SMALL_FAST_MODEL = answers.ANTHROPIC_SMALL_FAST_MODEL;
-    registries[target] = current;
-    config2.set("registries", registries);
+    const answers = await promptForEnvironmentConfig(current, true);
+    registries[target] = applyPromptAnswers(current, answers, true);
+    setRegistries(registries);
     console.log(chalk7.green(`Environment '${target}' updated.`));
   }
 });
@@ -2369,25 +3018,22 @@ program.command("current").description("Show current environment name").action((
   console.log(chalk7.green(current));
 });
 program.command("env").description("Output environment variables for shell eval").option("--json", "Output as JSON").action((options) => {
-  const registries = config2.get("registries");
+  const registries = getRegistries();
   const current = config2.get("current");
   const env = registries[current];
   if (!env) return;
   const outputEnv = { ...env };
-  if (outputEnv.ANTHROPIC_API_KEY) {
-    outputEnv.ANTHROPIC_API_KEY = decrypt2(outputEnv.ANTHROPIC_API_KEY);
+  if (outputEnv.ANTHROPIC_AUTH_TOKEN) {
+    outputEnv.ANTHROPIC_AUTH_TOKEN = decrypt(outputEnv.ANTHROPIC_AUTH_TOKEN);
   }
   if (options.json) {
     console.log(JSON.stringify(outputEnv, null, 2));
   } else {
-    if (outputEnv.ANTHROPIC_BASE_URL) console.log(`export ANTHROPIC_BASE_URL="${outputEnv.ANTHROPIC_BASE_URL}"`);
-    if (outputEnv.ANTHROPIC_API_KEY) console.log(`export ANTHROPIC_API_KEY="${outputEnv.ANTHROPIC_API_KEY}"`);
-    if (outputEnv.ANTHROPIC_MODEL) console.log(`export ANTHROPIC_MODEL="${outputEnv.ANTHROPIC_MODEL}"`);
-    if (outputEnv.ANTHROPIC_SMALL_FAST_MODEL) console.log(`export ANTHROPIC_SMALL_FAST_MODEL="${outputEnv.ANTHROPIC_SMALL_FAST_MODEL}"`);
+    buildShellEnvCommands(env).forEach((cmd) => console.log(cmd));
   }
 });
 program.command("run <command...>").description("Run a command with the current environment variables").action((command) => {
-  const registries = config2.get("registries");
+  const registries = getRegistries();
   const current = config2.get("current");
   const envConfig = registries[current];
   if (!envConfig) {
@@ -2395,10 +3041,8 @@ program.command("run <command...>").description("Run a command with the current
     process.exit(1);
   }
   const env = { ...process.env };
-  if (envConfig.ANTHROPIC_BASE_URL) env.ANTHROPIC_BASE_URL = envConfig.ANTHROPIC_BASE_URL;
-  if (envConfig.ANTHROPIC_API_KEY) env.ANTHROPIC_API_KEY = decrypt2(envConfig.ANTHROPIC_API_KEY || "");
-  if (envConfig.ANTHROPIC_MODEL) env.ANTHROPIC_MODEL = envConfig.ANTHROPIC_MODEL;
-  if (envConfig.ANTHROPIC_SMALL_FAST_MODEL) env.ANTHROPIC_SMALL_FAST_MODEL = envConfig.ANTHROPIC_SMALL_FAST_MODEL;
+  clearManagedClaudeEnv(env);
+  Object.assign(env, buildResolvedEnvVars(envConfig));
   const [cmd, ...args] = command;
   const child = spawn3(cmd, args, {
     env,
@@ -2436,14 +3080,14 @@ setupCmd.command("default-mode").description("\u8BBE\u7F6E\u9ED8\u8BA4\u6743\u96
   for (const mode of PERMISSION_MODES) {
     if (options[mode]) {
       config2.set("defaultMode", mode);
-      console.log(chalk7.green(`\u5DF2\u8BBE\u7F6E\u9ED8\u8BA4\u6743\u9650\u6A21\u5F0F: ${PERMISSION_PRESETS4[mode].name}`));
+      console.log(chalk7.green(`\u5DF2\u8BBE\u7F6E\u9ED8\u8BA4\u6743\u9650\u6A21\u5F0F: ${PERMISSION_PRESETS[mode].name}`));
       console.log(chalk7.gray(`\u4E0B\u6B21\u542F\u52A8 ccem \u65F6\u5C06\u9ED8\u8BA4\u4F7F\u7528\u6B64\u6A21\u5F0F`));
       return;
     }
   }
   const currentDefault = config2.get("defaultMode");
-  if (currentDefault && PERMISSION_PRESETS4[currentDefault]) {
-    console.log(chalk7.green(`\u5F53\u524D\u9ED8\u8BA4\u6A21\u5F0F: ${PERMISSION_PRESETS4[currentDefault].name}`));
+  if (currentDefault && PERMISSION_PRESETS[currentDefault]) {
+    console.log(chalk7.green(`\u5F53\u524D\u9ED8\u8BA4\u6A21\u5F0F: ${PERMISSION_PRESETS[currentDefault].name}`));
   } else {
     console.log(chalk7.yellow("\u672A\u8BBE\u7F6E\u9ED8\u8BA4\u6743\u9650\u6A21\u5F0F"));
   }
@@ -2451,36 +3095,37 @@ setupCmd.command("default-mode").description("\u8BBE\u7F6E\u9ED8\u8BA4\u6743\u96
   console.log(chalk7.gray("\u6E05\u9664\u9ED8\u8BA4\u6A21\u5F0F: ccem setup default-mode --reset"));
   console.log(chalk7.gray("\u53EF\u7528\u6A21\u5F0F: " + PERMISSION_MODES.join(", ")));
 });
-setupCmd.command("init").description("\u521D\u59CB\u5316 Claude Code \u5168\u5C40\u914D\u7F6E\uFF08\u8DF3\u8FC7 onboarding\u3001\u7981\u7528\u9065\u6D4B\u3001\u5B89\u88C5 MCP \u5DE5\u5177\uFF09").action(async () => {
-  await runSetupInit();
+setupCmd.command("init").description("\u521D\u59CB\u5316 Claude Code \u5168\u5C40\u914D\u7F6E\uFF08\u8DF3\u8FC7 onboarding\u3001\u7981\u7528\u9065\u6D4B\uFF09").option("--chrome", "\u540C\u65F6\u5B89\u88C5 chrome-devtools MCP \u5DE5\u5177").action(async function() {
+  const options = this.opts();
+  await runSetupInit({ chrome: !!options.chrome });
 });
 setupCmd.command("migrate").description("\u8FC1\u79FB\u65E7\u7248\u914D\u7F6E\u5230 ~/.ccem/").option("--clean", "\u8FC1\u79FB\u540E\u5220\u9664\u65E7\u914D\u7F6E\u6587\u4EF6").option("--force", "\u5F3A\u5236\u91CD\u65B0\u8FC1\u79FB\uFF08\u8986\u76D6\u73B0\u6709\u914D\u7F6E\uFF09").action(async function() {
   const options = this.opts();
   const newConfigPath = getCcemConfigPath();
   const legacyConfigPath = getLegacyConfigPath();
   console.log(chalk7.cyan("\n\u{1F504} \u914D\u7F6E\u8FC1\u79FB\n"));
-  if (!fs7.existsSync(legacyConfigPath)) {
+  if (!fs8.existsSync(legacyConfigPath)) {
     console.log(chalk7.yellow("\u672A\u627E\u5230\u65E7\u7248\u914D\u7F6E\u6587\u4EF6"));
     console.log(chalk7.gray(`  \u65E7\u8DEF\u5F84: ${legacyConfigPath}`));
     return;
   }
-  if (fs7.existsSync(newConfigPath) && !options.force) {
+  if (fs8.existsSync(newConfigPath) && !options.force) {
     console.log(chalk7.green("\u2713 \u914D\u7F6E\u5DF2\u5728\u65B0\u8DEF\u5F84"));
     console.log(chalk7.gray(`  \u8DEF\u5F84: ${newConfigPath}`));
     console.log(chalk7.gray("\n\u4F7F\u7528 --force \u5F3A\u5236\u91CD\u65B0\u8FC1\u79FB"));
     return;
   }
   try {
-    ensureCcemDir3();
-    fs7.copyFileSync(legacyConfigPath, newConfigPath);
+    ensureCcemDir();
+    fs8.copyFileSync(legacyConfigPath, newConfigPath);
     console.log(chalk7.green("\u2713 \u914D\u7F6E\u5DF2\u8FC1\u79FB"));
     console.log(chalk7.gray(`  \u4ECE: ${legacyConfigPath}`));
     console.log(chalk7.gray(`  \u5230: ${newConfigPath}`));
     if (options.clean) {
-      fs7.unlinkSync(legacyConfigPath);
-      const legacyDir = path5.dirname(legacyConfigPath);
+      fs8.unlinkSync(legacyConfigPath);
+      const legacyDir = path6.dirname(legacyConfigPath);
       try {
-        fs7.rmdirSync(legacyDir);
+        fs8.rmdirSync(legacyDir);
       } catch {
       }
       console.log(chalk7.green("\u2713 \u5DF2\u5220\u9664\u65E7\u914D\u7F6E\u6587\u4EF6"));
@@ -2491,13 +3136,13 @@ setupCmd.command("migrate").description("\u8FC1\u79FB\u65E7\u7248\u914D\u7F6E\u5
 });
 setupCmd.command("cron").description("\u5B89\u88C5 ccem-cron skill \u5230 Claude Code\uFF08~/.claude/skills/\uFF09").option("--force", "\u5F3A\u5236\u8986\u76D6\u5DF2\u6709\u6587\u4EF6").action(async function() {
   const options = this.opts();
-  const skillDir = path5.join(process.env.HOME || "~", ".claude", "skills");
-  const targetPath = path5.join(skillDir, "ccem-cron.md");
-  if (!fs7.existsSync(skillDir)) {
-    fs7.mkdirSync(skillDir, { recursive: true });
+  const skillDir = path6.join(process.env.HOME || "~", ".claude", "skills");
+  const targetPath = path6.join(skillDir, "ccem-cron.md");
+  if (!fs8.existsSync(skillDir)) {
+    fs8.mkdirSync(skillDir, { recursive: true });
     console.log(chalk7.gray(`\u521B\u5EFA\u76EE\u5F55: ${skillDir}`));
   }
-  if (fs7.existsSync(targetPath) && !options.force) {
+  if (fs8.existsSync(targetPath) && !options.force) {
     const { overwrite } = await inquirer.prompt([
       {
         type: "confirm",
@@ -2511,7 +3156,7 @@ setupCmd.command("cron").description("\u5B89\u88C5 ccem-cron skill \u5230 Claude
       return;
     }
   }
-  fs7.writeFileSync(targetPath, CCEM_CRON_SKILL_CONTENT, "utf-8");
+  fs8.writeFileSync(targetPath, CCEM_CRON_SKILL_CONTENT, "utf-8");
   console.log(chalk7.green(`\u2713 \u5DF2\u5B89\u88C5 ccem-cron skill`));
   console.log(chalk7.gray(`  \u8DEF\u5F84: ${targetPath}`));
   console.log(chalk7.cyan(`
@@ -2567,20 +3212,33 @@ skillCmd.command("ls").description("\u5217\u51FA\u5DF2\u5B89\u88C5\u7684 skills"
 skillCmd.command("rm <name>").description("\u5220\u9664\u5DF2\u5B89\u88C5\u7684 skill").action((name) => {
   removeSkill(name);
 });
-program.command("load <url>").description("\u4ECE\u8FDC\u7A0B\u670D\u52A1\u5668\u52A0\u8F7D\u73AF\u5883\u914D\u7F6E").requiredOption("--secret <secret>", "\u89E3\u5BC6\u5BC6\u94A5").action(async (url, options) => {
-  await loadFromRemote(url, options.secret);
+program.command("load <url>").description("\u4ECE\u8FDC\u7A0B\u670D\u52A1\u5668\u52A0\u8F7D\u73AF\u5883\u914D\u7F6E").requiredOption("--secret <secret>", "\u89E3\u5BC6\u5BC6\u94A5").option("--json", "\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA\u7ED3\u679C\uFF08\u4F9B\u7A0B\u5E8F\u8C03\u7528\uFF09").action(async (url, options) => {
+  const results = await loadFromRemote(url, options.secret);
+  if (options.json) {
+    console.log(JSON.stringify({
+      count: results.length,
+      environments: results.map((r) => ({
+        name: r.name,
+        original_name: r.originalName,
+        // 使用 snake_case 匹配 Rust 结构体
+        renamed: r.renamed
+      }))
+    }));
+  }
 });
-program.command("launch").description(false).option("--env <name>", "\u73AF\u5883\u540D\u79F0").option("--perm <mode>", "\u6743\u9650\u6A21\u5F0F").option("--session-id <id>", "\u4F1A\u8BDD ID").option("--resume-session <id>", "\u6062\u590D\u4F1A\u8BDD ID").option("--working-dir <path>", "\u5DE5\u4F5C\u76EE\u5F55").action(async function() {
+program.command("launch").description(false).option("--env <name>", "\u73AF\u5883\u540D\u79F0").option("--perm <mode>", "\u6743\u9650\u6A21\u5F0F").option("--session-id <id>", "\u4F1A\u8BDD ID").option("--resume-session <id>", "\u6062\u590D\u4F1A\u8BDD ID").option("--working-dir <path>", "\u5DE5\u4F5C\u76EE\u5F55").option("--proxy-base-url <url>", "Desktop internal override for ANTHROPIC_BASE_URL").option("--anthropic-base-url <url>", "Deprecated alias for --proxy-base-url").action(async function() {
   const opts = this.opts();
   const envName = opts.env || config2.get("current");
-  const registries = config2.get("registries");
+  const registries = getRegistries();
   const envConfig = registries[envName];
   if (!envConfig) {
     console.error(chalk7.red(`Environment '${envName}' not found.`));
     process.exit(1);
   }
+  const proxyBaseUrl = opts.proxyBaseUrl || opts.anthropicBaseUrl;
+  const launchEnvConfig = proxyBaseUrl ? { ...envConfig, ANTHROPIC_BASE_URL: proxyBaseUrl } : envConfig;
   await launchClaude({
-    envConfig,
+    envConfig: launchEnvConfig,
     permMode: opts.perm,
     workingDir: opts.workingDir,
     sessionId: opts.sessionId,
@@ -2616,7 +3274,7 @@ program.action(async (options) => {
     showCurrentEnv(usageStats, usageLoading);
     console.log("");
     const defaultMode = config2.get("defaultMode");
-    const registries = config2.get("registries");
+    const registries = getRegistries();
     const current = config2.get("current");
     const envConfig = registries[current];
     const { action } = await inquirer.prompt([
@@ -2663,37 +3321,9 @@ program.action(async (options) => {
         const envToEdit = registries[result.name];
         console.log(chalk7.yellow(`
 Editing environment '${result.name}'`));
-        const answers = await inquirer.prompt([
-          {
-            type: "input",
-            name: "ANTHROPIC_BASE_URL",
-            message: "ANTHROPIC_BASE_URL:",
-            default: envToEdit.ANTHROPIC_BASE_URL
-          },
-          {
-            type: "password",
-            name: "ANTHROPIC_API_KEY",
-            message: "ANTHROPIC_API_KEY (leave empty to keep current):"
-          },
-          {
-            type: "input",
-            name: "ANTHROPIC_MODEL",
-            message: "ANTHROPIC_MODEL:",
-            default: envToEdit.ANTHROPIC_MODEL
-          },
-          {
-            type: "input",
-            name: "ANTHROPIC_SMALL_FAST_MODEL",
-            message: "ANTHROPIC_SMALL_FAST_MODEL:",
-            default: envToEdit.ANTHROPIC_SMALL_FAST_MODEL
-          }
-        ]);
-        if (answers.ANTHROPIC_BASE_URL) envToEdit.ANTHROPIC_BASE_URL = answers.ANTHROPIC_BASE_URL;
-        if (answers.ANTHROPIC_API_KEY) envToEdit.ANTHROPIC_API_KEY = encrypt2(answers.ANTHROPIC_API_KEY);
-        if (answers.ANTHROPIC_MODEL) envToEdit.ANTHROPIC_MODEL = answers.ANTHROPIC_MODEL;
-        if (answers.ANTHROPIC_SMALL_FAST_MODEL) envToEdit.ANTHROPIC_SMALL_FAST_MODEL = answers.ANTHROPIC_SMALL_FAST_MODEL;
-        registries[result.name] = envToEdit;
-        config2.set("registries", registries);
+        const answers = await promptForEnvironmentConfig(envToEdit, true);
+        registries[result.name] = applyPromptAnswers(envToEdit, answers, true);
+        setRegistries(registries);
         msg.success(`Environment '${result.name}' updated.`);
         await new Promise((resolve2) => setTimeout(resolve2, 800));
       } else if (result.action === "rename") {
@@ -2715,7 +3345,7 @@ Editing environment '${result.name}'`));
           ]);
           registries[newName] = registries[result.name];
           delete registries[result.name];
-          config2.set("registries", registries);
+          setRegistries(registries);
           if (current === result.name) {
             config2.set("current", newName);
           }
@@ -2736,7 +3366,7 @@ Editing environment '${result.name}'`));
           }
         ]);
         registries[targetName] = { ...registries[result.name] };
-        config2.set("registries", registries);
+        setRegistries(registries);
         msg.success(`Environment '${result.name}' copied to '${targetName}'.`);
         const { modify } = await inquirer.prompt([
           {
@@ -2748,37 +3378,9 @@ Editing environment '${result.name}'`));
         ]);
         if (modify) {
           const envToEdit = registries[targetName];
-          const editAnswers = await inquirer.prompt([
-            {
-              type: "input",
-              name: "ANTHROPIC_BASE_URL",
-              message: "ANTHROPIC_BASE_URL:",
-              default: envToEdit.ANTHROPIC_BASE_URL
-            },
-            {
-              type: "password",
-              name: "ANTHROPIC_API_KEY",
-              message: "ANTHROPIC_API_KEY (leave empty to keep current):"
-            },
-            {
-              type: "input",
-              name: "ANTHROPIC_MODEL",
-              message: "ANTHROPIC_MODEL:",
-              default: envToEdit.ANTHROPIC_MODEL
-            },
-            {
-              type: "input",
-              name: "ANTHROPIC_SMALL_FAST_MODEL",
-              message: "ANTHROPIC_SMALL_FAST_MODEL:",
-              default: envToEdit.ANTHROPIC_SMALL_FAST_MODEL
-            }
-          ]);
-          if (editAnswers.ANTHROPIC_BASE_URL) envToEdit.ANTHROPIC_BASE_URL = editAnswers.ANTHROPIC_BASE_URL;
-          if (editAnswers.ANTHROPIC_API_KEY) envToEdit.ANTHROPIC_API_KEY = encrypt2(editAnswers.ANTHROPIC_API_KEY);
-          if (editAnswers.ANTHROPIC_MODEL) envToEdit.ANTHROPIC_MODEL = editAnswers.ANTHROPIC_MODEL;
-          if (editAnswers.ANTHROPIC_SMALL_FAST_MODEL) envToEdit.ANTHROPIC_SMALL_FAST_MODEL = editAnswers.ANTHROPIC_SMALL_FAST_MODEL;
-          registries[targetName] = envToEdit;
-          config2.set("registries", registries);
+          const editAnswers = await promptForEnvironmentConfig(envToEdit, true);
+          registries[targetName] = applyPromptAnswers(envToEdit, editAnswers, true);
+          setRegistries(registries);
           msg.success(`Environment '${targetName}' updated.`);
         }
         await new Promise((resolve2) => setTimeout(resolve2, 800));
@@ -2797,7 +3399,7 @@ Editing environment '${result.name}'`));
           ]);
           if (confirm) {
             delete registries[result.name];
-            config2.set("registries", registries);
+            setRegistries(registries);
             if (current === result.name) {
               config2.set("current", "official");
               msg.warning(`Deleted current environment. Switched back to 'official'.`);
@@ -2839,7 +3441,7 @@ Editing environment '${result.name}'`));
         await new Promise((resolve2) => setTimeout(resolve2, 800));
       } else if (selectedMode !== "back") {
         config2.set("defaultMode", selectedMode);
-        msg.success(`Default mode set: ${PERMISSION_PRESETS4[selectedMode].name}`);
+        msg.success(`Default mode set: ${PERMISSION_PRESETS[selectedMode].name}`);
         await new Promise((resolve2) => setTimeout(resolve2, 800));
       }
     } else {