ccem 2.0.0-beta → 2.0.0-beta.2

package/dist/index.js

@@ -7,28 +7,343 @@ 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 * as fs8 from "fs";
+import * as path6 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";
+
+// ../../packages/core/dist/chunk-YO7HO5AS.js
+var ENV_PRESETS = {
+  "GLM": {
+    ANTHROPIC_BASE_URL: "https://open.bigmodel.cn/api/anthropic",
+    ANTHROPIC_MODEL: "glm-4.6",
+    ANTHROPIC_SMALL_FAST_MODEL: "glm-4.5-air"
+  },
+  "KIMI": {
+    ANTHROPIC_BASE_URL: "https://api.moonshot.cn/anthropic",
+    ANTHROPIC_MODEL: "kimi-k2-thinking-turbo",
+    ANTHROPIC_SMALL_FAST_MODEL: "kimi-k2-turbo-preview"
+  },
+  "MiniMax": {
+    ANTHROPIC_BASE_URL: "https://api.minimaxi.com/anthropic",
+    ANTHROPIC_MODEL: "MiniMax-M2",
+    ANTHROPIC_SMALL_FAST_MODEL: "MiniMax-M2"
+  },
+  "DeepSeek": {
+    ANTHROPIC_BASE_URL: "https://api.deepseek.com/anthropic",
+    ANTHROPIC_MODEL: "deepseek-chat",
+    ANTHROPIC_SMALL_FAST_MODEL: "deepseek-chat"
+  }
+};
+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");
+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 +352,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 +381,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 +471,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 +531,7 @@ function getUsageStatsFromCache() {
 }
 async function saveCacheAsync(cache) {
   try {
-    await ensureCcemDir();
+    await ensureCcemDir2();
     await fsPromises.writeFile(getCachePath(), JSON.stringify(cache, null, 2));
   } catch {
   }
@@ -224,7 +539,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 +593,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));
             }
           }
         }
@@ -506,10 +821,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);
@@ -947,64 +1262,62 @@ 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";
 function buildEnvVars(envConfig) {
   const vars = {};
   if (envConfig.ANTHROPIC_BASE_URL) vars.ANTHROPIC_BASE_URL = envConfig.ANTHROPIC_BASE_URL;
@@ -1014,7 +1327,7 @@ function buildEnvVars(envConfig) {
   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,9 +1341,9 @@ 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;
 }
@@ -1043,7 +1356,7 @@ async function launchClaude(options) {
   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`));
@@ -1072,8 +1385,8 @@ async function launchClaude(options) {
     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 +1403,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 +1419,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 +1435,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 +1451,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 +1468,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 +1478,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 +1510,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 +1519,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 +1529,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 +1545,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();
@@ -1354,8 +1667,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 +1837,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 +1850,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 +1862,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 +1890,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 +1951,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 +1965,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 +2139,18 @@ 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"
 });
 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;
@@ -2075,11 +2387,11 @@ 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 __dirname2 = path6.dirname(__filename);
+var pkgPath = path6.resolve(__dirname2, "..", "package.json");
+var pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
 var program = new Command();
-ensureCcemDir3();
+ensureCcemDir();
 var config2 = new Conf2({
   projectName: "claude-code-env-manager",
   cwd: getCcemConfigDir(),
@@ -2132,7 +2444,7 @@ 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 current = config2.get("current");
@@ -2149,7 +2461,7 @@ var showCurrentEnv = (usageStats2, usageLoading2) => {
   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_API_KEY: env.ANTHROPIC_API_KEY ? decrypt(env.ANTHROPIC_API_KEY) : void 0,
     ANTHROPIC_MODEL: env.ANTHROPIC_MODEL,
     ANTHROPIC_SMALL_FAST_MODEL: env.ANTHROPIC_SMALL_FAST_MODEL
   }, defaultMode));
@@ -2174,7 +2486,7 @@ var switchEnvironment = async (name) => {
   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_API_KEY) exportCmds.push(`export ANTHROPIC_API_KEY="${decrypt(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}"`);
   if (process.stdout.isTTY) {
@@ -2259,7 +2571,7 @@ program.command("add <name>").description("Add a new environment configuration")
     }
   ]);
   if (answers.ANTHROPIC_API_KEY) {
-    answers.ANTHROPIC_API_KEY = encrypt2(answers.ANTHROPIC_API_KEY);
+    answers.ANTHROPIC_API_KEY = encrypt(answers.ANTHROPIC_API_KEY);
   }
   registries[name] = answers;
   config2.set("registries", registries);
@@ -2356,7 +2668,7 @@ program.command("cp <source> <target>").description("Copy an environment configu
       }
     ]);
     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_API_KEY) current.ANTHROPIC_API_KEY = encrypt(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;
@@ -2375,7 +2687,7 @@ program.command("env").description("Output environment variables for shell eval"
   if (!env) return;
   const outputEnv = { ...env };
   if (outputEnv.ANTHROPIC_API_KEY) {
-    outputEnv.ANTHROPIC_API_KEY = decrypt2(outputEnv.ANTHROPIC_API_KEY);
+    outputEnv.ANTHROPIC_API_KEY = decrypt(outputEnv.ANTHROPIC_API_KEY);
   }
   if (options.json) {
     console.log(JSON.stringify(outputEnv, null, 2));
@@ -2396,7 +2708,7 @@ program.command("run <command...>").description("Run a command with the current
   }
   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_API_KEY) env.ANTHROPIC_API_KEY = decrypt(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;
   const [cmd, ...args] = command;
@@ -2436,14 +2748,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"));
   }
@@ -2459,28 +2771,28 @@ setupCmd.command("migrate").description("\u8FC1\u79FB\u65E7\u7248\u914D\u7F6E\u5
   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 +2803,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 +2823,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(`
@@ -2689,7 +3001,7 @@ Editing environment '${result.name}'`));
           }
         ]);
         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_API_KEY) envToEdit.ANTHROPIC_API_KEY = encrypt(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;
@@ -2774,7 +3086,7 @@ Editing environment '${result.name}'`));
             }
           ]);
           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_API_KEY) envToEdit.ANTHROPIC_API_KEY = encrypt(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;
@@ -2839,7 +3151,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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccem",
-  "version": "2.0.0-beta",
+  "version": "2.0.0-beta.2",
   "type": "module",
   "description": "Claude Code Environment Manager",
   "author": {
@@ -16,18 +16,7 @@
   "bin": {
     "ccem": "./dist/index.js"
   },
-  "scripts": {
-    "generate-logo": "bash scripts/generate-logo.sh",
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "start": "node dist/index.js",
-    "postinstall": "node ./scripts/migrate.js",
-    "test": "vitest",
-    "test:run": "vitest run",
-    "test:coverage": "vitest run --coverage"
-  },
   "dependencies": {
-    "@ccem/core": "workspace:*",
     "chalk": "^4.1.2",
     "cli-table3": "^0.6.3",
     "commander": "^12.0.0",
@@ -46,6 +35,17 @@
     "asciify-image": "^0.1.10",
     "tsup": "^8.0.2",
     "typescript": "^5.3.3",
-    "vitest": "^4.0.18"
+    "vitest": "^4.0.18",
+    "@ccem/core": "2.0.0-beta.2"
+  },
+  "scripts": {
+    "generate-logo": "bash scripts/generate-logo.sh",
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "start": "node dist/index.js",
+    "postinstall": "node ./scripts/migrate.js",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:coverage": "vitest run --coverage"
   }
-}
+}