ccem 2.0.0-beta.16 → 2.0.0-beta.18

package/dist/index.js

@@ -7,8 +7,8 @@ import inquirer from "inquirer";
 import chalk7 from "chalk";
 import Table3 from "cli-table3";
 import { spawn as spawn3 } from "child_process";
-import * as fs8 from "fs";
-import * as path6 from "path";
+import * as fs9 from "fs";
+import * as path7 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // ../../packages/core/dist/chunk-DRN6L2YP.js
@@ -921,10 +921,10 @@ var renderLogoWithEnvPanel = (envName, env, defaultMode) => {
       const parsed = new URL(url);
       const protocol = parsed.protocol + "//";
       const host = parsed.host;
-      const path7 = parsed.pathname + parsed.search;
+      const path8 = parsed.pathname + parsed.search;
       const hostStart = host.slice(0, 8);
       const hostEnd = host.slice(-4);
-      const pathPart = path7.length > 10 ? path7.slice(0, 7) + "..." : path7;
+      const pathPart = path8.length > 10 ? path8.slice(0, 7) + "..." : path8;
       return `${protocol}${hostStart}...${hostEnd}${pathPart}`;
     } catch {
       return truncate(url, max);
@@ -1362,7 +1362,7 @@ var selectEnvWithKeys = (registries, current) => {
 };
 
 // src/permissions.ts
-import fs5 from "fs";
+import fs6 from "fs";
 import chalk3 from "chalk";
 import Table2 from "cli-table3";
 
@@ -1415,9 +1415,347 @@ var ensureGlobalClaudeDir = () => {
 
 // src/launcher.ts
 import { spawn } from "child_process";
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 import chalk2 from "chalk";
+
+// src/sessionProvenance.ts
+import { execFileSync } from "child_process";
+import fs4 from "fs";
+import { createRequire } from "module";
+import os2 from "os";
+import path4 from "path";
+var DEFAULT_CONFIG_SOURCE = "ccem";
+var STATE_DB_FILE_NAME = "state.sqlite";
+var BIND_POLL_INTERVAL_MS = 500;
+var BIND_POLL_TIMEOUT_MS = 2e4;
+var SQLITE_EXPERIMENTAL_WARNING = "SQLite is an experimental feature";
+var require2 = createRequire(import.meta.url);
+var databaseSyncCtor = null;
+var databaseSyncResolved = false;
+var sqlite3CliAvailable = null;
+function startCliClaudeProvenanceTracking(options) {
+  const envName = normalizeText(options.envName) ?? "unknown";
+  const workingDir = normalizeText(options.workingDir);
+  if (!workingDir) {
+    return null;
+  }
+  const ccemSessionId = `cli-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  try {
+    registerLaunch({
+      ccemSessionId,
+      client: "claude",
+      envName,
+      configSource: DEFAULT_CONFIG_SOURCE,
+      workingDir,
+      permMode: normalizeText(options.permMode),
+      launchMode: "cli_external",
+      startedVia: "cli",
+      sourceSessionId: normalizeText(options.resumeSessionId)
+    });
+  } catch (error) {
+    reportTrackingError("register launch", error);
+    return null;
+  }
+  let timer = null;
+  const stop = () => {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  };
+  const resumeSessionId = normalizeText(options.resumeSessionId);
+  if (resumeSessionId) {
+    return { ccemSessionId, stop };
+  }
+  const startedAtMs = Date.now();
+  timer = setInterval(() => {
+    if (Date.now() - startedAtMs > BIND_POLL_TIMEOUT_MS) {
+      stop();
+      return;
+    }
+    try {
+      const jsonlPath = discoverClaudeJsonlPath(workingDir, startedAtMs);
+      if (!jsonlPath) {
+        return;
+      }
+      const sourceSessionId = readClaudeSessionId(jsonlPath) ?? normalizeText(path4.parse(jsonlPath).name);
+      if (!sourceSessionId) {
+        return;
+      }
+      bindSourceSessionId("claude", ccemSessionId, sourceSessionId);
+      stop();
+    } catch (error) {
+      reportTrackingError("bind source session id", error);
+      stop();
+    }
+  }, BIND_POLL_INTERVAL_MS);
+  return { ccemSessionId, stop };
+}
+function registerLaunch(options) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const DatabaseSync = getDatabaseSyncCtor();
+  if (DatabaseSync) {
+    const db = openNodeSqliteDb(DatabaseSync);
+    try {
+      const statement = db.prepare(`
+        INSERT INTO session_provenance (
+          ccem_session_id,
+          client,
+          env_name,
+          config_source,
+          working_dir,
+          perm_mode,
+          launch_mode,
+          started_via,
+          source_session_id,
+          created_at,
+          updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(ccem_session_id) DO UPDATE SET
+          client = excluded.client,
+          env_name = excluded.env_name,
+          config_source = COALESCE(excluded.config_source, session_provenance.config_source),
+          working_dir = excluded.working_dir,
+          perm_mode = COALESCE(excluded.perm_mode, session_provenance.perm_mode),
+          launch_mode = excluded.launch_mode,
+          started_via = excluded.started_via,
+          source_session_id = COALESCE(excluded.source_session_id, session_provenance.source_session_id),
+          updated_at = excluded.updated_at
+      `);
+      statement.run(
+        options.ccemSessionId,
+        options.client,
+        options.envName,
+        normalizeText(options.configSource),
+        options.workingDir,
+        normalizeText(options.permMode),
+        options.launchMode,
+        options.startedVia,
+        normalizeText(options.sourceSessionId),
+        now,
+        now
+      );
+      return;
+    } finally {
+      db.close();
+    }
+  }
+  execSqlite3Cli(`
+    INSERT INTO session_provenance (
+      ccem_session_id,
+      client,
+      env_name,
+      config_source,
+      working_dir,
+      perm_mode,
+      launch_mode,
+      started_via,
+      source_session_id,
+      created_at,
+      updated_at
+    ) VALUES (
+      ${sqliteLiteral(options.ccemSessionId)},
+      ${sqliteLiteral(options.client)},
+      ${sqliteLiteral(options.envName)},
+      ${sqliteLiteral(normalizeText(options.configSource))},
+      ${sqliteLiteral(options.workingDir)},
+      ${sqliteLiteral(normalizeText(options.permMode))},
+      ${sqliteLiteral(options.launchMode)},
+      ${sqliteLiteral(options.startedVia)},
+      ${sqliteLiteral(normalizeText(options.sourceSessionId))},
+      ${sqliteLiteral(now)},
+      ${sqliteLiteral(now)}
+    )
+    ON CONFLICT(ccem_session_id) DO UPDATE SET
+      client = excluded.client,
+      env_name = excluded.env_name,
+      config_source = COALESCE(excluded.config_source, session_provenance.config_source),
+      working_dir = excluded.working_dir,
+      perm_mode = COALESCE(excluded.perm_mode, session_provenance.perm_mode),
+      launch_mode = excluded.launch_mode,
+      started_via = excluded.started_via,
+      source_session_id = COALESCE(excluded.source_session_id, session_provenance.source_session_id),
+      updated_at = excluded.updated_at;
+  `);
+}
+function bindSourceSessionId(client, ccemSessionId, sourceSessionId) {
+  const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const DatabaseSync = getDatabaseSyncCtor();
+  if (DatabaseSync) {
+    const db = openNodeSqliteDb(DatabaseSync);
+    try {
+      const statement = db.prepare(`
+        UPDATE session_provenance
+        SET source_session_id = ?, updated_at = ?
+        WHERE ccem_session_id = ? AND client = ?
+      `);
+      statement.run(sourceSessionId, updatedAt, ccemSessionId, client);
+      return;
+    } finally {
+      db.close();
+    }
+  }
+  execSqlite3Cli(`
+    UPDATE session_provenance
+    SET source_session_id = ${sqliteLiteral(sourceSessionId)},
+        updated_at = ${sqliteLiteral(updatedAt)}
+    WHERE ccem_session_id = ${sqliteLiteral(ccemSessionId)}
+      AND client = ${sqliteLiteral(client)};
+  `);
+}
+function openNodeSqliteDb(DatabaseSync) {
+  const dbPath = getStateDbPath();
+  fs4.mkdirSync(path4.dirname(dbPath), { recursive: true });
+  const db = new DatabaseSync(dbPath);
+  db.exec(schemaSql());
+  return db;
+}
+function getDatabaseSyncCtor() {
+  if (databaseSyncResolved) {
+    return databaseSyncCtor;
+  }
+  const originalEmitWarning = process.emitWarning;
+  process.emitWarning = ((warning, ...args) => {
+    const message = typeof warning === "string" ? warning : warning instanceof Error ? warning.message : String(warning);
+    if (message.includes(SQLITE_EXPERIMENTAL_WARNING)) {
+      return;
+    }
+    return originalEmitWarning(warning, ...args);
+  });
+  try {
+    const loaded = require2("node:sqlite");
+    databaseSyncCtor = loaded.DatabaseSync;
+  } catch {
+    databaseSyncCtor = null;
+  } finally {
+    process.emitWarning = originalEmitWarning;
+    databaseSyncResolved = true;
+  }
+  return databaseSyncCtor;
+}
+function execSqlite3Cli(statementSql) {
+  if (sqlite3CliAvailable == null) {
+    try {
+      execFileSync("sqlite3", ["-version"], { stdio: "ignore" });
+      sqlite3CliAvailable = true;
+    } catch {
+      sqlite3CliAvailable = false;
+    }
+  }
+  if (!sqlite3CliAvailable) {
+    throw new Error("sqlite3 CLI is unavailable and node:sqlite is not supported by this Node runtime");
+  }
+  const dbPath = getStateDbPath();
+  fs4.mkdirSync(path4.dirname(dbPath), { recursive: true });
+  execFileSync("sqlite3", [dbPath], {
+    input: `${schemaSql()}
+${statementSql}
+`,
+    stdio: ["pipe", "ignore", "pipe"]
+  });
+}
+function getStateDbPath() {
+  const override = normalizeText(process.env.CCEM_STATE_DB_PATH);
+  if (override) {
+    return override;
+  }
+  return path4.join(os2.homedir(), ".ccem", STATE_DB_FILE_NAME);
+}
+function schemaSql() {
+  return `
+    PRAGMA journal_mode = WAL;
+    PRAGMA synchronous = NORMAL;
+    CREATE TABLE IF NOT EXISTS session_provenance (
+      ccem_session_id TEXT PRIMARY KEY,
+      client TEXT NOT NULL,
+      env_name TEXT NOT NULL,
+      config_source TEXT,
+      working_dir TEXT NOT NULL,
+      perm_mode TEXT,
+      launch_mode TEXT NOT NULL,
+      started_via TEXT NOT NULL,
+      source_session_id TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_session_provenance_client_source
+      ON session_provenance (client, source_session_id);
+    CREATE INDEX IF NOT EXISTS idx_session_provenance_client_updated
+      ON session_provenance (client, updated_at DESC);
+  `;
+}
+function discoverClaudeJsonlPath(projectDir, startedAtMs) {
+  const projectsDir = path4.join(os2.homedir(), ".claude", "projects");
+  const earliestModifiedAt = startedAtMs - 15e3;
+  for (const key of projectDirKeys(projectDir)) {
+    const baseDir = path4.join(projectsDir, key);
+    if (!fs4.existsSync(baseDir)) {
+      continue;
+    }
+    const candidates = fs4.readdirSync(baseDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => {
+      const fullPath = path4.join(baseDir, entry.name);
+      return { path: fullPath, modifiedAt: fs4.statSync(fullPath).mtimeMs };
+    }).filter((candidate) => candidate.modifiedAt >= earliestModifiedAt).sort((left, right) => right.modifiedAt - left.modifiedAt);
+    if (candidates.length > 0) {
+      return candidates[0].path;
+    }
+  }
+  return null;
+}
+function projectDirKeys(projectDir) {
+  const candidates = [projectDir];
+  try {
+    candidates.push(fs4.realpathSync(projectDir));
+  } catch {
+  }
+  if (process.platform === "darwin") {
+    if (projectDir.startsWith("/private/")) {
+      candidates.push(projectDir.slice("/private".length));
+    } else if (projectDir.startsWith("/tmp")) {
+      candidates.push(path4.posix.join("/private", projectDir));
+    } else if (projectDir.startsWith("/var/")) {
+      candidates.push(path4.posix.join("/private", projectDir));
+    }
+  }
+  return [...new Set(candidates.map(projectDirKey))];
+}
+function projectDirKey(projectDir) {
+  return projectDir.replace(/[\/\\: ]/g, "-");
+}
+function readClaudeSessionId(jsonlPath) {
+  const lines = fs4.readFileSync(jsonlPath, "utf8").split("\n");
+  for (const line of lines) {
+    if (!line.trim()) {
+      continue;
+    }
+    try {
+      const value = JSON.parse(line);
+      const sessionId = normalizeText(value.sessionId);
+      if (sessionId) {
+        return sessionId;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function normalizeText(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function sqliteLiteral(value) {
+  if (!value) {
+    return "NULL";
+  }
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function reportTrackingError(stage, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`[ccem] Failed to ${stage}: ${message}`);
+}
+
+// src/launcher.ts
 var MANAGED_CLAUDE_ENV_KEYS = [
   "ANTHROPIC_BASE_URL",
   "ANTHROPIC_AUTH_TOKEN",
@@ -1455,14 +1793,14 @@ function buildPermArgs(modeName) {
   return args;
 }
 function ensureSessionsDir() {
-  const dir = path4.join(ensureCcemDir(), "sessions");
-  if (!fs4.existsSync(dir)) {
-    fs4.mkdirSync(dir, { recursive: true });
+  const dir = path5.join(ensureCcemDir(), "sessions");
+  if (!fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true });
   }
   return dir;
 }
 async function launchClaude(options) {
-  const { envConfig, permMode, workingDir, sessionId, resumeSessionId, silent } = options;
+  const { envName, envConfig, permMode, workingDir, sessionId, resumeSessionId, silent } = options;
   const env = { ...process.env };
   for (const key of MANAGED_CLAUDE_ENV_KEYS) {
     delete env[key];
@@ -1489,22 +1827,36 @@ async function launchClaude(options) {
   if (workingDir) {
     process.chdir(workingDir);
   }
+  const effectiveWorkingDir = process.cwd();
   if (!silent && !permMode) {
     console.log(renderStarting());
   }
   const sessionsDir = ensureSessionsDir();
   return new Promise((resolve2) => {
+    let provenanceTracking = null;
     const child = spawn("claude", args, {
       stdio: "inherit",
       shell: false,
       // 直接执行二进制，避免 shell 注入风险
       env
     });
+    child.once("spawn", () => {
+      if (sessionId) {
+        return;
+      }
+      provenanceTracking = startCliClaudeProvenanceTracking({
+        envName: envName ?? "unknown",
+        workingDir: effectiveWorkingDir,
+        permMode,
+        resumeSessionId
+      });
+    });
     child.on("exit", (code) => {
+      provenanceTracking?.stop();
       if (sessionId) {
         try {
-          fs4.writeFileSync(
-            path4.join(sessionsDir, `${sessionId}.exit`),
+          fs5.writeFileSync(
+            path5.join(sessionsDir, `${sessionId}.exit`),
             String(code ?? 0)
           );
         } catch {
@@ -1513,6 +1865,7 @@ async function launchClaude(options) {
       process.exit(code ?? 0);
     });
     child.on("error", (err) => {
+      provenanceTracking?.stop();
       if (err.code === "ENOENT") {
         console.error("");
         console.error(chalk2.red.bold("\u2718 \u672A\u627E\u5230 Claude Code"));
@@ -1537,14 +1890,14 @@ async function launchClaude(options) {
 
 // src/permissions.ts
 var readSettings = (settingsPath) => {
-  if (fs5.existsSync(settingsPath)) {
+  if (fs6.existsSync(settingsPath)) {
     try {
-      const content = fs5.readFileSync(settingsPath, "utf-8");
+      const content = fs6.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();
-      fs5.copyFileSync(settingsPath, backupPath);
+      fs6.copyFileSync(settingsPath, backupPath);
       console.log(chalk3.gray(`\u5907\u4EFD\u5DF2\u4FDD\u5B58\u5230: ${backupPath}`));
       return {};
     }
@@ -1553,7 +1906,7 @@ var readSettings = (settingsPath) => {
 };
 var writeSettings = (settingsPath, config3) => {
   ensureClaudeDir();
-  fs5.writeFileSync(settingsPath, JSON.stringify(config3, null, 2) + "\n");
+  fs6.writeFileSync(settingsPath, JSON.stringify(config3, null, 2) + "\n");
 };
 var mergePermissions = (existing, preset) => {
   const existingAllow = existing.permissions?.allow || [];
@@ -1585,14 +1938,14 @@ var applyPermissionMode = (modeName) => {
 };
 var resetPermissions = () => {
   const settingsPath = getSettingsPath(true);
-  if (!fs5.existsSync(settingsPath)) {
+  if (!fs6.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) {
-    fs5.unlinkSync(settingsPath);
+    fs6.unlinkSync(settingsPath);
     console.log(chalk3.green("\u5DF2\u5220\u9664\u914D\u7F6E\u6587\u4EF6\uFF08\u6587\u4EF6\u4E3A\u7A7A\uFF09"));
   } else {
     writeSettings(settingsPath, config3);
@@ -1602,7 +1955,7 @@ var resetPermissions = () => {
 };
 var showCurrentMode = () => {
   const settingsPath = getSettingsPath(true);
-  if (!fs5.existsSync(settingsPath)) {
+  if (!fs6.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;
@@ -1652,24 +2005,24 @@ var listAvailableModes = () => {
   console.log(chalk3.gray("\n\u4E34\u65F6\u6A21\u5F0F: ccem <mode>"));
   console.log(chalk3.gray("\u6C38\u4E45\u6A21\u5F0F: ccem setup perms --<mode>"));
 };
-var runWithTempPermissions = async (modeName, envConfig) => {
+var runWithTempPermissions = async (modeName, envConfig, envName) => {
   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(", ")));
     process.exit(1);
   }
-  await launchClaude({ envConfig, permMode: modeName });
+  await launchClaude({ envConfig, envName, permMode: modeName });
 };
 
 // src/setup.ts
-import fs6 from "fs";
+import fs7 from "fs";
 import chalk4 from "chalk";
 import { spawn as spawn2 } from "child_process";
 var readJsonFile = (filePath) => {
-  if (fs6.existsSync(filePath)) {
+  if (fs7.existsSync(filePath)) {
     try {
-      const content = fs6.readFileSync(filePath, "utf-8");
+      const content = fs7.readFileSync(filePath, "utf-8");
       return JSON.parse(content);
     } catch {
       console.warn(chalk4.yellow(`\u8B66\u544A: \u65E0\u6CD5\u89E3\u6790 ${filePath}`));
@@ -1679,7 +2032,7 @@ var readJsonFile = (filePath) => {
   return {};
 };
 var writeJsonFile = (filePath, data) => {
-  fs6.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+  fs7.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
 };
 var setupOnboarding = () => {
   const configPath = getGlobalClaudeConfigPath();
@@ -1806,8 +2159,8 @@ var runSetupInit = async (options = {}) => {
 
 // src/skills.ts
 import { execSync } from "child_process";
-import * as fs7 from "fs";
-import * as path5 from "path";
+import * as fs8 from "fs";
+import * as path6 from "path";
 import chalk5 from "chalk";
 var SKILL_GROUPS = {
   official: { label: "\u5B98\u65B9", icon: "\u{1F3E2}" },
@@ -1976,12 +2329,12 @@ function parseGitHubUrl(url) {
   };
 }
 function getSkillsDir() {
-  return path5.join(process.cwd(), ".claude", "skills");
+  return path6.join(process.cwd(), ".claude", "skills");
 }
 function ensureSkillsDir() {
   const skillsDir = getSkillsDir();
-  if (!fs7.existsSync(skillsDir)) {
-    fs7.mkdirSync(skillsDir, { recursive: true });
+  if (!fs8.existsSync(skillsDir)) {
+    fs8.mkdirSync(skillsDir, { recursive: true });
   } else {
     cleanupTempDirs(skillsDir);
   }
@@ -1989,11 +2342,11 @@ function ensureSkillsDir() {
 }
 function cleanupTempDirs(skillsDir) {
   try {
-    const entries = fs7.readdirSync(skillsDir, { withFileTypes: true });
+    const entries = fs8.readdirSync(skillsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory() && entry.name.startsWith(".tmp-")) {
-        const tmpPath = path5.join(skillsDir, entry.name);
-        fs7.rmSync(tmpPath, { recursive: true });
+        const tmpPath = path6.join(skillsDir, entry.name);
+        fs8.rmSync(tmpPath, { recursive: true });
       }
     }
   } catch {
@@ -2001,24 +2354,24 @@ function cleanupTempDirs(skillsDir) {
 }
 function downloadSkillWithGit(owner, repo, branch, repoPath, targetName) {
   const skillsDir = ensureSkillsDir();
-  const targetDir = path5.join(skillsDir, targetName);
-  if (fs7.existsSync(targetDir)) {
+  const targetDir = path6.join(skillsDir, targetName);
+  if (fs8.existsSync(targetDir)) {
     console.log(chalk5.yellow(`Skill "${targetName}" already exists. Updating...`));
-    fs7.rmSync(targetDir, { recursive: true });
+    fs8.rmSync(targetDir, { recursive: true });
   }
   const repoUrl = `https://github.com/${owner}/${repo}.git`;
-  const tempDir = path5.join(skillsDir, `.tmp-${Date.now()}`);
+  const tempDir = path6.join(skillsDir, `.tmp-${Date.now()}`);
   try {
-    fs7.mkdirSync(tempDir, { recursive: true });
+    fs8.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 = path5.join(tempDir, ".git", "info", "sparse-checkout");
-    fs7.writeFileSync(sparseFile, repoPath ? `${repoPath}/
+    const sparseFile = path6.join(tempDir, ".git", "info", "sparse-checkout");
+    fs8.writeFileSync(sparseFile, repoPath ? `${repoPath}/
 ` : "*\n");
     execSync(`git pull --depth=1 origin ${branch}`, { cwd: tempDir, stdio: "pipe" });
-    const sourceDir = repoPath ? path5.join(tempDir, repoPath) : tempDir;
-    if (!fs7.existsSync(sourceDir)) {
+    const sourceDir = repoPath ? path6.join(tempDir, repoPath) : tempDir;
+    if (!fs8.existsSync(sourceDir)) {
       throw new Error(`Path "${repoPath}" not found in repository`);
     }
     copyDir(sourceDir, targetDir);
@@ -2029,22 +2382,22 @@ function downloadSkillWithGit(owner, repo, branch, repoPath, targetName) {
     console.error(chalk5.red(`Failed to download skill: ${errMsg}`));
     return false;
   } finally {
-    if (fs7.existsSync(tempDir)) {
-      fs7.rmSync(tempDir, { recursive: true });
+    if (fs8.existsSync(tempDir)) {
+      fs8.rmSync(tempDir, { recursive: true });
     }
   }
 }
 function copyDir(src, dest) {
-  fs7.mkdirSync(dest, { recursive: true });
-  const entries = fs7.readdirSync(src, { withFileTypes: true });
+  fs8.mkdirSync(dest, { recursive: true });
+  const entries = fs8.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === ".git") continue;
-    const srcPath = path5.join(src, entry.name);
-    const destPath = path5.join(dest, entry.name);
+    const srcPath = path6.join(src, entry.name);
+    const destPath = path6.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDir(srcPath, destPath);
     } else {
-      fs7.copyFileSync(srcPath, destPath);
+      fs8.copyFileSync(srcPath, destPath);
     }
   }
 }
@@ -2090,7 +2443,7 @@ function addSkillFromGitHub(urlOrPreset) {
   }
   let skillName;
   if (parsed.path) {
-    skillName = path5.basename(parsed.path);
+    skillName = path6.basename(parsed.path);
   } else {
     skillName = parsed.repo;
   }
@@ -2104,23 +2457,23 @@ function addSkillFromGitHub(urlOrPreset) {
 }
 function listInstalledSkills() {
   const skillsDir = getSkillsDir();
-  if (!fs7.existsSync(skillsDir)) {
+  if (!fs8.existsSync(skillsDir)) {
     return [];
   }
-  const entries = fs7.readdirSync(skillsDir, { withFileTypes: true });
+  const entries = fs8.readdirSync(skillsDir, { withFileTypes: true });
   return entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => ({
     name: entry.name,
-    path: path5.join(skillsDir, entry.name)
+    path: path6.join(skillsDir, entry.name)
   }));
 }
 function removeSkill(name) {
   const skillsDir = getSkillsDir();
-  const targetDir = path5.join(skillsDir, name);
-  if (!fs7.existsSync(targetDir)) {
+  const targetDir = path6.join(skillsDir, name);
+  if (!fs8.existsSync(targetDir)) {
     console.error(chalk5.red(`Skill "${name}" not found`));
     return false;
   }
-  fs7.rmSync(targetDir, { recursive: true });
+  fs8.rmSync(targetDir, { recursive: true });
   console.log(chalk5.green(`Removed skill "${name}"`));
   return true;
 }
@@ -2534,9 +2887,9 @@ Replace \\\`TARGET_ID\\\` or \\\`TARGET_NAME\\\` with the user's selection.
 
 // src/index.ts
 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 __dirname2 = path7.dirname(__filename2);
+var pkgPath = path7.resolve(__dirname2, "..", "package.json");
+var pkg = JSON.parse(fs9.readFileSync(pkgPath, "utf-8"));
 var program = new Command();
 var DEFAULT_OFFICIAL_ENV = {
   ANTHROPIC_BASE_URL: "https://api.anthropic.com",
@@ -2600,11 +2953,11 @@ var recoverRegistriesFromLegacy = (registries) => {
     return registries;
   }
   const legacyConfigPath = getLegacyConfigPath();
-  if (!fs8.existsSync(legacyConfigPath)) {
+  if (!fs9.existsSync(legacyConfigPath)) {
     return registries;
   }
   try {
-    const legacyRaw = JSON.parse(fs8.readFileSync(legacyConfigPath, "utf-8"));
+    const legacyRaw = JSON.parse(fs9.readFileSync(legacyConfigPath, "utf-8"));
     const legacyRegistries = legacyRaw.registries ?? {};
     let changed = false;
     const recovered = { ...registries };
@@ -2750,7 +3103,7 @@ PERMISSION_MODES.forEach((mode) => {
     const registries = getRegistries();
     const current = config2.get("current");
     const envConfig = registries[current];
-    await runWithTempPermissions(mode, envConfig);
+    await runWithTempPermissions(mode, envConfig, current);
   });
 });
 var showCurrentEnv = (usageStats2, usageLoading2) => {
@@ -2798,14 +3151,14 @@ 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 getSessionsFilePath = () => path7.join(getCcemConfigDir(), "sessions.json");
+var getRuntimeStateFilePath = () => path7.join(getCcemConfigDir(), "runtime-state.json");
 var parseJsonFile = (filePath) => {
-  if (!fs8.existsSync(filePath)) {
+  if (!fs9.existsSync(filePath)) {
     return null;
   }
   try {
-    return JSON.parse(fs8.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs9.readFileSync(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -3127,12 +3480,12 @@ 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 (!fs8.existsSync(legacyConfigPath)) {
+  if (!fs9.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 (fs8.existsSync(newConfigPath) && !options.force) {
+  if (fs9.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"));
@@ -3140,15 +3493,15 @@ setupCmd.command("migrate").description("\u8FC1\u79FB\u65E7\u7248\u914D\u7F6E\u5
   }
   try {
     ensureCcemDir();
-    fs8.copyFileSync(legacyConfigPath, newConfigPath);
+    fs9.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) {
-      fs8.unlinkSync(legacyConfigPath);
-      const legacyDir = path6.dirname(legacyConfigPath);
+      fs9.unlinkSync(legacyConfigPath);
+      const legacyDir = path7.dirname(legacyConfigPath);
       try {
-        fs8.rmdirSync(legacyDir);
+        fs9.rmdirSync(legacyDir);
       } catch {
       }
       console.log(chalk7.green("\u2713 \u5DF2\u5220\u9664\u65E7\u914D\u7F6E\u6587\u4EF6"));
@@ -3159,13 +3512,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 = path6.join(process.env.HOME || "~", ".claude", "skills");
-  const targetPath = path6.join(skillDir, "ccem-cron.md");
-  if (!fs8.existsSync(skillDir)) {
-    fs8.mkdirSync(skillDir, { recursive: true });
+  const skillDir = path7.join(process.env.HOME || "~", ".claude", "skills");
+  const targetPath = path7.join(skillDir, "ccem-cron.md");
+  if (!fs9.existsSync(skillDir)) {
+    fs9.mkdirSync(skillDir, { recursive: true });
     console.log(chalk7.gray(`\u521B\u5EFA\u76EE\u5F55: ${skillDir}`));
   }
-  if (fs8.existsSync(targetPath) && !options.force) {
+  if (fs9.existsSync(targetPath) && !options.force) {
     const { overwrite } = await inquirer.prompt([
       {
         type: "confirm",
@@ -3179,7 +3532,7 @@ setupCmd.command("cron").description("\u5B89\u88C5 ccem-cron skill \u5230 Claude
       return;
     }
   }
-  fs8.writeFileSync(targetPath, CCEM_CRON_SKILL_CONTENT, "utf-8");
+  fs9.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(`
@@ -3261,6 +3614,7 @@ program.command("launch").description(false).option("--env <name>", "\u73AF\u588
   const proxyBaseUrl = opts.proxyBaseUrl || opts.anthropicBaseUrl;
   const launchEnvConfig = proxyBaseUrl ? { ...envConfig, ANTHROPIC_BASE_URL: proxyBaseUrl } : envConfig;
   await launchClaude({
+    envName,
     envConfig: launchEnvConfig,
     permMode: opts.perm,
     workingDir: opts.workingDir,
@@ -3319,7 +3673,11 @@ program.action(async (options) => {
         msg.error("No environment configuration found.");
         process.exit(1);
       }
-      await launchClaude({ envConfig, permMode: defaultMode || void 0 });
+      await launchClaude({
+        envName: current,
+        envConfig,
+        permMode: defaultMode || void 0
+      });
       return;
     } else if (action === "usage") {
       console.clear();
@@ -3444,7 +3802,7 @@ Editing environment '${result.name}'`));
         }
       ]);
       if (permMode !== "back") {
-        await runWithTempPermissions(permMode, envConfig);
+        await runWithTempPermissions(permMode, envConfig, current);
         return;
       }
     } else if (action === "setDefault") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccem",
-  "version": "2.0.0-beta.16",
+  "version": "2.0.0-beta.18",
   "type": "module",
   "description": "Claude Code Environment Manager",
   "author": {