i18-fe-automator-beta 2.1.8 → 2.1.9

package/dist/commonjs/index.js

@@ -17,6 +17,8 @@ var xlsx = require('node-xlsx');
 var crypto = require('crypto');
 var querystring = require('querystring');
 var uuid = require('uuid');
+var os = require('os');
+var AdmZip = require('adm-zip');
 var eslint = require('eslint');
 var espree = require('espree');
 var node_module = require('node:module');
@@ -26,7 +28,6 @@ require('shelljs');
 var process$1 = require('child_process');
 var _ = require('lodash');
 var request$1 = require('request-promise');
-require('os');
 require('console');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
@@ -1803,7 +1804,7 @@ async function addSassPermission(cliOpts = {}) {
 
 // 禅道基础地址/缓存键(联调不符只改这里)
 const ZENTAO_BASE = "https://zentao.hongxinshop.com/zentao";
-const CACHE_KEY = "zentao"; // .cache/zentao: { account, password, zentaosid, products: [{id, name}] }
+const CACHE_KEY$1 = "zentao"; // .cache/zentao: { account, password, zentaosid, products: [{id, name}] }
 
 // 需求列表展示与pull并发的上限
 const PLAN_STORY_TABLE_LIMIT = 50;
@@ -1832,12 +1833,12 @@ function ensureCacheDir() {
 // 读取禅道凭据/会话缓存(不存在/损坏返回 {})
 function readZentaoCache() {
   const cacheFilePath =
-    getRunCliPath({ root: true }) + "/.cache/" + CACHE_KEY;
+    getRunCliPath({ root: true }) + "/.cache/" + CACHE_KEY$1;
   if (!isExistPath(cacheFilePath)) {
     return {};
   }
   try {
-    return JSON.parse(readCache(CACHE_KEY).toString("utf8")) || {};
+    return JSON.parse(readCache(CACHE_KEY$1).toString("utf8")) || {};
   } catch (error) {
     return {};
   }
@@ -1847,7 +1848,7 @@ function readZentaoCache() {
 function writeZentaoCache(obj) {
   ensureCacheDir();
   writeCache(
-    CACHE_KEY,
+    CACHE_KEY$1,
     JSON.stringify({ ...readZentaoCache(), ...obj })
   );
 }
@@ -2116,7 +2117,7 @@ function askZentaoCredentials(cliOpts) {
       password: cliOpts.password,
     },
     useCache: Boolean(cliOpts.cache),
-    cacheKey: CACHE_KEY,
+    cacheKey: CACHE_KEY$1,
   }).then((secret) => {
     // resolveSecretQuestions 会整文件覆盖回写缓存(只剩凭据字段, 发生在登录之前),
     // 合并写补回 zentaosid 等字段, 防止登录失败时已缓存的有效会话被抹掉
@@ -4181,6 +4182,1209 @@ function registerStoryCommand(program, { markHandled, addHelpExample }) {
   );
 }
 
+// 坚果云 WebDAV 公共模块(其他功能可直接复用)
+// 应用密码需网页端 账户信息->安全选项->添加应用密码 生成, 非登录密码
+const JIANGUOYUN_DAV = "https://dav.jianguoyun.com/dav";
+const CACHE_KEY = "jianguoyun"; // .cache/jianguoyun: { account, appPassword, remoteDir }
+
+// 凭据交互问题(默认值会被缓存覆盖, 输入后回写缓存)
+const JGY_QUESTIONS = [
+  {
+    message: "请输入坚果云账号(邮箱)",
+    name: "account",
+    validate: (v) => (v && v.trim() ? true : "账号不能为空"),
+  },
+  {
+    message: "请输入坚果云应用密码(网页端: 账户信息->安全选项->添加应用密码)",
+    name: "appPassword",
+    type: "password",
+    validate: (v) => (v && v.trim() ? true : "应用密码不能为空"),
+  },
+  {
+    message: "请输入远程目录(坚果云里的文件夹名)",
+    name: "remoteDir",
+    default: "claude-migrate",
+  },
+];
+
+/**
+ * 解析坚果云凭据: CLI参数 > --cache缓存 > 交互(展示缓存默认值), 解析后回写缓存
+ * @param cliValues CLI 参数值 { account, appPassword, remoteDir }
+ * @param useCache  是否静默走缓存(缓存缺失的字段回退交互)
+ */
+function resolveJianguoyunSecret(cliValues = {}, useCache = false) {
+  return resolveSecretQuestions({
+    questions: JGY_QUESTIONS,
+    cliValues,
+    useCache,
+    cacheKey: CACHE_KEY,
+  });
+}
+
+function basicAuth(account, appPassword) {
+  return "Basic " + Buffer.from(`${account}:${appPassword}`).toString("base64");
+}
+
+// 规范化远程目录: 去首尾空白与斜杠
+function normDir(remoteDir) {
+  return String(remoteDir || "").trim().replace(/^\/+|\/+$/g, "");
+}
+
+function remoteUrl(secret, fileName = "") {
+  const parts = [JIANGUOYUN_DAV, normDir(secret.remoteDir)];
+  if (fileName) parts.push(...String(fileName).split("/").map(encodeURIComponent));
+  return parts.filter(Boolean).join("/");
+}
+
+// 从 WebDAV 错误响应体提取可读信息(坚果云错误是 XML, 含 <s:message>)
+async function extractErrorMessage(res) {
+  if (res.status === 401) return "账号或应用密码错误(应用密码需网页端生成, 非登录密码)";
+  let text = "";
+  try {
+    text = await res.text();
+  } catch {
+    /* 忽略 */
+  }
+  const msg = text.match(/<(?:[\w-]+:)?message>([\s\S]*?)<\/(?:[\w-]+:)?message>/i)?.[1]?.trim();
+  return msg || `HTTP ${res.status}`;
+}
+
+// 确保远程目录存在(逐级 MKCOL, 已存在返回 405 忽略)
+async function ensureRemoteDir(secret) {
+  const dir = normDir(secret.remoteDir);
+  if (!dir) return;
+  const auth = basicAuth(secret.account, secret.appPassword);
+  let current = JIANGUOYUN_DAV;
+  for (const seg of dir.split("/")) {
+    current += "/" + encodeURIComponent(seg);
+    const res = await fetch(current, { method: "MKCOL", headers: { Authorization: auth } });
+    // 201=创建成功 405=已存在; 其他视为失败
+    if (res.status !== 201 && res.status !== 405) {
+      throw new Error(`创建远程目录失败: ${await extractErrorMessage(res)}`);
+    }
+  }
+}
+
+/**
+ * 上传文件到坚果云
+ * @param secret  resolveJianguoyunSecret 的结果
+ * @param localFile 本地文件路径
+ * @param fileName  远程文件名(默认取 localFile 的 basename)
+ */
+async function jianguoyunUpload(secret, localFile, fileName) {
+  await ensureRemoteDir(secret);
+  const name = fileName || localFile.split(/[\\/]/).pop();
+  const res = await fetch(remoteUrl(secret, name), {
+    method: "PUT",
+    headers: { Authorization: basicAuth(secret.account, secret.appPassword) },
+    body: fs.readFileSync(localFile),
+  });
+  if (!res.ok) {
+    throw new Error(`上传坚果云失败: ${await extractErrorMessage(res)}`);
+  }
+  return `${normDir(secret.remoteDir)}/${name}`;
+}
+
+// 解析 PROPFIND 响应, 返回目录下文件列表(跳过目录本身)
+function parsePropfind(xml) {
+  const files = [];
+  const respRe = /<(?:[\w-]+:)?response>([\s\S]*?)<\/(?:[\w-]+:)?response>/g;
+  let m;
+  while ((m = respRe.exec(xml))) {
+    const block = m[1];
+    const href =
+      block.match(/<(?:[\w-]+:)?href>([\s\S]*?)<\/(?:[\w-]+:)?href>/)?.[1] || "";
+    if (!href || href.endsWith("/")) continue; // 目录本身
+    const name = decodeURIComponent(href.split("/").filter(Boolean).pop());
+    const size = Number(
+      block.match(/<(?:[\w-]+:)?getcontentlength>([\s\S]*?)</)?.[1] || 0
+    );
+    const mtime =
+      block.match(/<(?:[\w-]+:)?getlastmodified>([\s\S]*?)</)?.[1] || "";
+    files.push({ name, size, mtime });
+  }
+  return files;
+}
+
+/**
+ * 列出坚果云远程目录下的文件(目录不存在返回 [])
+ * @returns [{ name, size, mtime }]
+ */
+async function jianguoyunList(secret) {
+  const dir = normDir(secret.remoteDir);
+  if (!dir) return [];
+  const res = await fetch(remoteUrl(secret), {
+    method: "PROPFIND",
+    headers: {
+      Authorization: basicAuth(secret.account, secret.appPassword),
+      Depth: "1",
+    },
+  });
+  if (res.status === 404) return []; // 目录不存在
+  if (!res.ok) {
+    throw new Error(`读取坚果云目录失败: ${await extractErrorMessage(res)}`);
+  }
+  return parsePropfind(await res.text());
+}
+
+/**
+ * 从坚果云下载文件
+ * @param localPath 下载保存的本地路径
+ */
+async function jianguoyunDownload(secret, fileName, localPath) {
+  const res = await fetch(remoteUrl(secret, fileName), {
+    headers: { Authorization: basicAuth(secret.account, secret.appPassword) },
+  });
+  if (!res.ok) {
+    throw new Error(`下载坚果云文件失败: ${await extractErrorMessage(res)}`);
+  }
+  fs.writeFileSync(localPath, Buffer.from(await res.arrayBuffer()));
+}
+
+// claude 子命令 — Claude Code 数据跨平台迁移(list/export/import)
+// 参照 claude-migrate.sh 重写为 Node 版: zip 归档 + 跨系统路径重映射(POSIX <-> Windows)
+const MIGRATE_VERSION = "1.0.0";
+const ALL_CATEGORIES =
+  "settings,history,plans,projects,plugins,skills,memory";
+const CATEGORY_LIST = ALL_CATEGORIES.split(",");
+
+// 类别 -> 顶层文件(相对 ~/.claude)
+const CATEGORY_FILES = {
+  settings: ["settings.json", "settings.local.json", "keybindings.json"],
+  history: ["history.jsonl"],
+};
+// 类别 -> 整目录拷贝(相对 ~/.claude)
+const CATEGORY_DIRS = {
+  plans: "plans",
+  projects: "projects",
+  skills: "skills",
+};
+// export 交互勾选时默认不勾选的类别(history/projects 体积大且含大量本机路径, 按需勾选)
+const UNCHECKED_BY_DEFAULT = ["history", "projects"];
+// plugins 只迁 2 个清单(插件本体可重装, 不迁)
+const PLUGIN_FILES = ["installed_plugins.json", "known_marketplaces.json"];
+// memory = memory/ 目录 + 全局记忆文件
+const MEMORY_DIR = "memory";
+const MEMORY_FILES = ["CLAUDE.md", "AGENTS.md"];
+
+// ─── 工具函数 ─────────────────────────────────────────────────────────
+
+function log(msg) {
+  console.log(`${chalk.green("=>")} ${msg}`);
+}
+function warn(msg) {
+  console.log(chalk.yellow(`警告: ${msg}`));
+}
+function verbose(msg, enabled) {
+  if (enabled) console.log(`  ${chalk.blue("+")} ${msg}`);
+}
+function die(msg) {
+  console.error(chalk.red(`错误: ${msg}`));
+  process.exit(1);
+}
+
+const pad = (n) => String(n).padStart(2, "0");
+
+// 时间戳 YYYY-MM-DD-HHmmss(年月日时分秒)
+function getTimestamp() {
+  const d = new Date();
+  return (
+    `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}` +
+    `-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`
+  );
+}
+
+// 递归收集目录下所有文件(绝对路径)
+function walkFiles(dir) {
+  const out = [];
+  (function rec(d) {
+    for (const e of fs.readdirSync(d, { withFileTypes: true })) {
+      if (e.isDirectory()) rec(path.join(d, e.name));
+      else out.push(path.join(d, e.name));
+    }
+  })(dir);
+  return out;
+}
+
+function countFiles(dir) {
+  if (!fs.existsSync(dir)) return 0;
+  return walkFiles(dir).length;
+}
+
+// ─── 路径编码与重映射 ──────────────────────────────────────────────────
+
+/**
+ * 跨平台路径编码(Claude Code projects 目录名规则):
+ * / \ : 均替换为 -(统一按正斜杠处理, POSIX 首斜杠替换后自然带前导横杠)
+ * /Users/harry       -> -Users-harry
+ * D:\Users\harry     -> D--Users-harry
+ */
+function encodePath(p) {
+  const norm = String(p).replace(/\\/g, "/").replace(/\/+$/, "");
+  return norm.replace(/[:/]/g, "-");
+}
+
+// projects 子目录名: 把编码后的源 home 前缀替换为目标 home 前缀
+function remapDirname(name, srcHome, dstHome) {
+  const src = encodePath(srcHome);
+  const dst = encodePath(dstHome);
+  if (src === dst || !name.startsWith(src)) return name;
+  return dst + name.slice(src.length);
+}
+
+/**
+ * 文件内容路径重映射, 覆盖 3 种变体(长变体优先, 避免单分隔符替换破坏双转义):
+ * 1. JSON 双反斜杠转义: D:\\Users\\harry
+ * 2. 反斜杠分隔: D:\Users\harry 或 \Users\harry
+ * 3. 正斜杠分隔: /Users/harry 或 D:/Users/harry
+ */
+function remapContent(content, srcHome, dstHome) {
+  if (!srcHome || !dstHome || srcHome === dstHome) return content;
+  const srcPosix = srcHome.replace(/\\/g, "/");
+  const dstPosix = dstHome.replace(/\\/g, "/");
+  const srcWin = srcPosix.replace(/\//g, "\\");
+  const dstWin = dstPosix.replace(/\//g, "\\");
+  const pairs = [
+    [srcWin.replace(/\\/g, "\\\\"), dstWin.replace(/\\/g, "\\\\")],
+    [srcWin, dstWin],
+    [srcPosix, dstPosix],
+  ];
+  for (const [from, to] of pairs) {
+    if (from && from !== to) content = content.split(from).join(to);
+  }
+  return content;
+}
+
+function remapFileContents(file, srcHome, dstHome) {
+  if (srcHome === dstHome) return;
+  const content = fs.readFileSync(file, "utf-8");
+  const newContent = remapContent(content, srcHome, dstHome);
+  if (newContent !== content) {
+    fs.writeFileSync(file, newContent, "utf-8");
+  }
+}
+
+// ─── claude 目录解析 ───────────────────────────────────────────────────
+
+function detectClaudeDir() {
+  return (
+    process.env.CLAUDE_DIR || path.join(os.homedir(), ".claude")
+  );
+}
+
+// 读操作(list/export)用: --claude-dir > 环境变量 > 默认检测; 不存在则交互输入
+async function resolveClaudeDirForRead(options) {
+  if (options.claudeDir) {
+    const p = path.resolve(options.claudeDir);
+    if (!fs.existsSync(p)) die(`claude 目录不存在: ${p}`);
+    return p;
+  }
+  const detected = detectClaudeDir();
+  if (fs.existsSync(detected)) return detected;
+  warn(`未检测到 claude 目录: ${detected}`);
+  const { custom } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "custom",
+      message: "请输入 claude 数据目录路径",
+      validate: (v) => {
+        if (!v.trim()) return "路径不能为空";
+        if (!fs.existsSync(v.trim())) return "目录不存在, 请重新输入";
+        return true;
+      },
+    },
+  ]);
+  return path.resolve(custom.trim());
+}
+
+// import 用: --claude-dir 传了直接用; 否则展示检测路径让用户确认或自定义
+async function resolveClaudeDirForImport(options) {
+  if (options.claudeDir) return path.resolve(options.claudeDir);
+  const detected = detectClaudeDir();
+  const exists = fs.existsSync(detected);
+  const { choice } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "choice",
+      message: "请确认目标 claude 数据目录",
+      choices: [
+        {
+          name: `使用检测到的路径: ${detected}${exists ? "" : chalk.yellow(" (目录不存在, 导入时会创建)")}`,
+          value: detected,
+        },
+        { name: "手动输入自定义路径", value: null },
+      ],
+    },
+  ]);
+  if (choice) return choice;
+  const { custom } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "custom",
+      message: "请输入 claude 数据目录路径",
+      validate: (v) => (v.trim() ? true : "路径不能为空"),
+    },
+  ]);
+  return path.resolve(custom.trim());
+}
+
+// ─── 类别收集(export 暂存) ─────────────────────────────────────────────
+
+function collectCategory(claudeDir, dataDir, cat, isVerbose) {
+  if (CATEGORY_FILES[cat]) {
+    for (const f of CATEGORY_FILES[cat]) {
+      const src = path.join(claudeDir, f);
+      if (fs.existsSync(src)) {
+        fs.mkdirSync(dataDir, { recursive: true });
+        fs.copyFileSync(src, path.join(dataDir, f));
+        verbose(f, isVerbose);
+      }
+    }
+  } else if (CATEGORY_DIRS[cat]) {
+    const dir = CATEGORY_DIRS[cat];
+    const src = path.join(claudeDir, dir);
+    if (fs.existsSync(src)) {
+      const dst = path.join(dataDir, cat);
+      fs.mkdirSync(dst, { recursive: true });
+      fs.cpSync(src, dst, { recursive: true });
+      verbose(`${cat}/ (${countFiles(src)} 个文件)`, isVerbose);
+    }
+  } else if (cat === "plugins") {
+    const src = path.join(claudeDir, "plugins");
+    if (fs.existsSync(src)) {
+      fs.mkdirSync(path.join(dataDir, "plugins"), { recursive: true });
+      for (const f of PLUGIN_FILES) {
+        if (fs.existsSync(path.join(src, f))) {
+          fs.copyFileSync(path.join(src, f), path.join(dataDir, "plugins", f));
+          verbose(`plugins/${f}`, isVerbose);
+        }
+      }
+    }
+  } else if (cat === "memory") {
+    const memSrc = path.join(claudeDir, MEMORY_DIR);
+    if (fs.existsSync(memSrc)) {
+      fs.mkdirSync(path.join(dataDir, MEMORY_DIR), { recursive: true });
+      fs.cpSync(memSrc, path.join(dataDir, MEMORY_DIR), { recursive: true });
+      verbose(`memory/ (${countFiles(memSrc)} 个文件)`, isVerbose);
+    }
+    for (const f of MEMORY_FILES) {
+      const src = path.join(claudeDir, f);
+      if (fs.existsSync(src)) {
+        fs.mkdirSync(dataDir, { recursive: true });
+        fs.copyFileSync(src, path.join(dataDir, f));
+        verbose(f, isVerbose);
+      }
+    }
+  }
+}
+
+// ─── 本地类别统计(list) ────────────────────────────────────────────────
+
+function scanCategoryLocal(claudeDir, cat) {
+  const exists = (p) => fs.existsSync(path.join(claudeDir, p));
+  switch (cat) {
+    case "settings": {
+      const n = CATEGORY_FILES.settings.filter(exists).length;
+      return n ? `${n} 个文件` : "未找到";
+    }
+    case "history": {
+      const p = path.join(claudeDir, "history.jsonl");
+      if (!fs.existsSync(p)) return "未找到";
+      const lines = fs
+        .readFileSync(p, "utf-8")
+        .split("\n")
+        .filter((l) => l.trim()).length;
+      return `${lines} 条`;
+    }
+    case "plans": {
+      const p = path.join(claudeDir, CATEGORY_DIRS[cat]);
+      if (!fs.existsSync(p)) return "未找到";
+      return `${countFiles(p)} 个文件`;
+    }
+    case "projects":
+    case "skills": {
+      const p = path.join(claudeDir, CATEGORY_DIRS[cat]);
+      if (!fs.existsSync(p)) return "未找到";
+      const dirs = fs
+        .readdirSync(p, { withFileTypes: true })
+        .filter((e) => e.isDirectory());
+      const label = cat === "skills" ? "个 skill" : "个项目";
+      return `${dirs.length} ${label}, ${countFiles(p)} 个文件`;
+    }
+    case "plugins": {
+      const p = path.join(claudeDir, "plugins");
+      if (!fs.existsSync(p)) return "未找到";
+      const n = PLUGIN_FILES.filter((f) =>
+        fs.existsSync(path.join(p, f))
+      ).length;
+      return n ? `${n} 个文件` : "未找到";
+    }
+    case "memory": {
+      let n = MEMORY_FILES.filter(exists).length;
+      const memDir = path.join(claudeDir, MEMORY_DIR);
+      if (fs.existsSync(memDir)) n += countFiles(memDir);
+      return n ? `${n} 个文件` : "未找到";
+    }
+    default:
+      return "未找到";
+  }
+}
+
+function printCategoryTable(claudeDir, scanFn) {
+  console.log("");
+  for (const cat of CATEGORY_LIST) {
+    const info = scanFn(claudeDir, cat);
+    const isFound = info !== "未找到" && !info.startsWith("0 ");
+    const colored = isFound
+      ? chalk.green(cat.padEnd(10))
+      : chalk.yellow(cat.padEnd(10));
+    console.log(`  ${colored} ${info}`);
+  }
+}
+
+function printDirDetails(dir, title, unit) {
+  if (!fs.existsSync(dir)) return;
+  const dirs = fs
+    .readdirSync(dir, { withFileTypes: true })
+    .filter((e) => e.isDirectory());
+  if (!dirs.length) return;
+  console.log("");
+  console.log(chalk.bold(`${title}:`));
+  for (const d of dirs) {
+    const n = countFiles(path.join(dir, d.name));
+    console.log(`  ${d.name} (${n} ${unit})`);
+  }
+}
+
+function cmdListLocal(options) {
+  return resolveClaudeDirForRead(options).then((claudeDir) => {
+    console.log(chalk.bold(`本地 Claude 数据:`), claudeDir);
+    printCategoryTable(claudeDir, scanCategoryLocal);
+    printDirDetails(path.join(claudeDir, "projects"), "Projects", "个文件");
+    printDirDetails(path.join(claudeDir, "skills"), "Skills", "个文件");
+  });
+}
+
+// ─── 归档类别统计(list 归档) ───────────────────────────────────────────
+
+// adm-zip 兼容: 旧版 isDirectory() 是方法, 新版是 boolean 属性
+function entryIsDirectory(e) {
+  return typeof e.isDirectory === "function"
+    ? e.isDirectory()
+    : e.isDirectory === true;
+}
+
+// 解析归档: 返回 { zip, root, manifest, relMap }(relMap: 相对 root 的路径 -> entry)
+function readArchive(archive) {
+  if (!fs.existsSync(archive)) die(`归档不存在: ${archive}`);
+  let zip;
+  try {
+    zip = new AdmZip(archive);
+  } catch (error) {
+    die(`读取归档失败: ${error.message}`);
+  }
+  const entries = zip.getEntries();
+  const manifestEntry = entries.find(
+    (e) => !entryIsDirectory(e) && e.entryName.split("/").pop() === "manifest.json"
+  );
+  if (!manifestEntry) die("归档中未找到 manifest.json");
+  const root = manifestEntry.entryName.includes("/")
+    ? manifestEntry.entryName.slice(
+        0,
+        manifestEntry.entryName.lastIndexOf("/")
+      )
+    : "";
+  let manifest;
+  try {
+    manifest = JSON.parse(zip.readAsText(manifestEntry.entryName));
+  } catch (error) {
+    die("manifest.json 解析失败");
+  }
+  const relMap = new Map();
+  for (const e of entries) {
+    if (entryIsDirectory(e)) continue;
+    const rel = root ? e.entryName.slice(root.length + 1) : e.entryName;
+    relMap.set(rel, e);
+  }
+  return { zip, root, manifest, relMap };
+}
+
+function scanCategoryArchive(relMap, zip, cat) {
+  const has = (rel) => relMap.has(rel);
+  switch (cat) {
+    case "settings": {
+      const n = CATEGORY_FILES.settings.filter((f) => has(`data/${f}`)).length;
+      return n ? `${n} 个文件` : "未找到";
+    }
+    case "history": {
+      const e = relMap.get("data/history.jsonl");
+      if (!e) return "未找到";
+      const lines = zip
+        .readAsText(e.entryName)
+        .split("\n")
+        .filter((l) => l.trim()).length;
+      return `${lines} 条`;
+    }
+    case "plans":
+    case "skills": {
+      const prefix = `data/${cat}/`;
+      const n = [...relMap.keys()].filter((rel) =>
+        rel.startsWith(prefix)
+      ).length;
+      return n ? `${n} 个文件` : "未找到";
+    }
+    case "projects": {
+      const prefix = "data/projects/";
+      const rels = [...relMap.keys()].filter((rel) =>
+        rel.startsWith(prefix)
+      );
+      if (!rels.length) return "未找到";
+      const dirs = new Set(rels.map((rel) => rel.slice(prefix.length).split("/")[0]));
+      return `${dirs.size} 个项目, ${rels.length} 个文件`;
+    }
+    case "plugins": {
+      const n = PLUGIN_FILES.filter((f) => has(`data/plugins/${f}`)).length;
+      return n ? `${n} 个文件` : "未找到";
+    }
+    case "memory": {
+      let n = MEMORY_FILES.filter((f) => has(`data/${f}`)).length;
+      n += [...relMap.keys()].filter((rel) =>
+        rel.startsWith(`data/${MEMORY_DIR}/`)
+      ).length;
+      return n ? `${n} 个文件` : "未找到";
+    }
+    default:
+      return "未找到";
+  }
+}
+
+function cmdListArchive(archive) {
+  const { zip, manifest, relMap } = readArchive(archive);
+  const platformLabel =
+    manifest.platform ? ` [${manifest.platform}]` : "";
+  console.log(chalk.bold(`归档:`), archive);
+  console.log(chalk.bold(`来源:`), `${manifest.hostname || "unknown"} (${manifest.source_home})${platformLabel}`);
+  console.log(chalk.bold(`日期:`), manifest.date || "unknown");
+  printCategoryTable(relMap, (map, cat) =>
+    scanCategoryArchive(map, zip, cat)
+  );
+  // projects / skills 一级列表
+  for (const [cat, title] of [
+    ["projects", "Projects"],
+    ["skills", "Skills"],
+  ]) {
+    const prefix = `data/${cat}/`;
+    const names = new Set(
+      [...relMap.keys()]
+        .filter((rel) => rel.startsWith(prefix))
+        .map((rel) => rel.slice(prefix.length).split("/")[0])
+    );
+    if (!names.size) continue;
+    console.log("");
+    console.log(chalk.bold(`${title}:`));
+    for (const name of names) {
+      const n = [...relMap.keys()].filter(
+        (rel) => rel.startsWith(prefix + name + "/")
+      ).length;
+      console.log(`  ${name} (${n} 个文件)`);
+    }
+  }
+}
+
+// ─── export ───────────────────────────────────────────────────────────
+
+function parseCategories(str) {
+  const cats = String(str || ALL_CATEGORIES)
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+  for (const c of cats) {
+    if (!CATEGORY_LIST.includes(c)) {
+      die(`未知类别: ${c} (可选: ${ALL_CATEGORIES})`);
+    }
+  }
+  return cats.length ? cats : CATEGORY_LIST;
+}
+
+// 类别中文说明(勾选列表展示用)
+const CATEGORY_LABELS = {
+  settings: "配置(settings.json等)",
+  history: "输入历史(history.jsonl, 体积大)",
+  plans: "计划(plans/)",
+  projects: "项目会话记录(projects/, 体积大)",
+  plugins: "插件清单(installed_plugins等)",
+  skills: "技能(skills/)",
+  memory: "全局记忆(memory/ + CLAUDE.md)",
+};
+
+/**
+ * export 交互勾选导出类别(「全选」与子项父子联动, 复用 CheckboxAllPrompt)
+ * history/projects 默认不勾选(体积大且含大量本机路径), 其余默认勾选
+ */
+async function selectExportCategories(claudeDir) {
+  // prompt 注册幂等, 与 story.js/upload.js 各自使用前注册
+  inquirer.registerPrompt("checkbox-all", CheckboxAllPrompt);
+  const choices = [
+    {
+      name: "全选",
+      value: SELECT_ALL,
+      short: "全选",
+      // 默认未全勾(history/projects), 与子项联动状态保持一致
+      checked: false,
+    },
+    ...CATEGORY_LIST.map((cat) => ({
+      name: `${cat} — ${CATEGORY_LABELS[cat]} [${scanCategoryLocal(claudeDir, cat)}]`,
+      value: cat,
+      short: cat,
+      checked: !UNCHECKED_BY_DEFAULT.includes(cat),
+    })),
+  ];
+  const { picked } = await inquirer.prompt([
+    {
+      message:
+        "请勾选要导出的类别(空格选择, 回车确认; 「全选」与单个类别联动)",
+      name: "picked",
+      type: "checkbox-all",
+      // 到列表边界停止, 不循环回第一条
+      loop: false,
+      choices,
+    },
+  ]);
+  const cats = picked.filter((v) => v !== SELECT_ALL);
+  if (!cats.length) {
+    warn("未勾选任何类别, 已取消导出");
+    process.exit(0);
+  }
+  return cats;
+}
+
+// 校验并归一化位置参数(local|jianguoyun)
+function normalizeLocation(value, optionName) {
+  if (value === undefined) return null;
+  if (value !== "local" && value !== "jianguoyun") {
+    die(`参数 ${optionName} 的值 "${value}" 不合法, 可选值: local | jianguoyun`);
+  }
+  return value;
+}
+
+// 解析坚果云凭据: CLI参数 > --cache缓存 > 交互(展示缓存默认值), 输入后回写缓存
+function getJianguoyunSecret(options) {
+  return resolveJianguoyunSecret(
+    {
+      account: options.account,
+      appPassword: options.appPassword,
+      remoteDir: options.remoteDir,
+    },
+    Boolean(options.cache)
+  );
+}
+
+// export 选保存位置: --dest 直通(一键), 否则交互选 本地/坚果云
+async function selectExportDest(options) {
+  const dest = normalizeLocation(options.dest, "--dest");
+  if (dest) return dest;
+  const { picked } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "picked",
+      message: "请选择归档保存位置",
+      choices: [
+        { name: "本地(当前目录下 zip 文件)", value: "local" },
+        { name: "坚果云(WebDAV, 账号密码缓存后下次免输)", value: "jianguoyun" },
+      ],
+    },
+  ]);
+  return picked;
+}
+
+async function cmdExport(options) {
+  const claudeDir = await resolveClaudeDirForRead(options);
+  // --categories 传了直通用(一键), 否则交互勾选
+  const cats = options.categories
+    ? parseCategories(options.categories)
+    : await selectExportCategories(claudeDir);
+  // 保存位置: 本地 / 坚果云
+  const dest = await selectExportDest(options);
+  const isVerbose = Boolean(options.verbose);
+  const timestamp = getTimestamp();
+  const dateShort = timestamp.slice(0, 10);
+  const fileName = options.output
+    ? options.output.split(/[\\/]/).pop()
+    : `claude-export-${dateShort}.zip`;
+  const output = dest === "jianguoyun"
+    ? path.join(os.tmpdir(), `claude-export-${timestamp}.zip`) // 坚果云: 先写临时再上传后删除
+    : (options.output || fileName);
+
+  const tmpBase = fs.mkdtempSync(path.join(os.tmpdir(), "claude-migrate-"));
+  const stageRoot = path.join(tmpBase, `claude-migrate-${timestamp}`);
+  const dataDir = path.join(stageRoot, "data");
+  fs.mkdirSync(dataDir, { recursive: true });
+
+  log(`导出 Claude 数据: ${claudeDir}`);
+  for (const cat of cats) {
+    collectCategory(claudeDir, dataDir, cat, isVerbose);
+  }
+
+  const manifest = {
+    version: MIGRATE_VERSION,
+    source_home: os.homedir(),
+    hostname: os.hostname(),
+    platform: process.platform,
+    date: timestamp,
+    categories: cats,
+  };
+  fs.writeFileSync(
+    path.join(stageRoot, "manifest.json"),
+    JSON.stringify(manifest, null, 2) + "\n",
+    "utf-8"
+  );
+
+  const fileCount = countFiles(dataDir);
+  log(`已暂存 ${fileCount} 个文件`);
+  if (!fileCount) {
+    warn("没有可导出的数据");
+    fs.rmSync(tmpBase, { recursive: true, force: true });
+    process.exit(1);
+  }
+
+  const zip = new AdmZip();
+  // tmpBase 下仅 stageRoot 一个子目录, 整体打入 zip 使根目录为 claude-migrate-<ts>/
+  zip.addLocalFolder(tmpBase, "");
+  zip.writeZip(output);
+  fs.rmSync(tmpBase, { recursive: true, force: true });
+  const size = (fs.statSync(output).size / 1024).toFixed(1);
+
+  if (dest === "jianguoyun") {
+    // 上传坚果云后删除本地临时文件
+    const secret = await getJianguoyunSecret(options);
+    log(`上传坚果云中...`);
+    const remotePath = await jianguoyunUpload(secret, output, fileName);
+    fs.rmSync(output, { force: true });
+    log(`已上传至坚果云: ${remotePath} (${size} KB)`);
+  } else {
+    log(`已创建归档: ${output} (${size} KB)`);
+  }
+}
+
+// ─── import ───────────────────────────────────────────────────────────
+
+// import 选归档来源: --source 直通(一键), 否则交互选 本地/坚果云
+async function selectImportSource(options) {
+  const source = normalizeLocation(options.source, "--source");
+  if (source) return source;
+  const { picked } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "picked",
+      message: "请选择归档来源",
+      choices: [
+        { name: "本地(zip 文件路径)", value: "local" },
+        { name: "坚果云(WebDAV, 列出远程归档选择)", value: "jianguoyun" },
+      ],
+    },
+  ]);
+  return picked;
+}
+
+// 交互输入本地归档路径
+async function askLocalArchivePath() {
+  const { archive } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "archive",
+      message: "请输入归档文件路径",
+      validate: (v) => {
+        if (!v.trim()) return "路径不能为空";
+        if (!fs.existsSync(v.trim())) return "文件不存在, 请重新输入";
+        return true;
+      },
+    },
+  ]);
+  return archive.trim();
+}
+
+// 从坚果云列归档选择并下载; 返回下载后的本地路径
+async function downloadFromJianguoyun(options, savePath) {
+  const secret = await getJianguoyunSecret(options);
+  log("读取坚果云远程目录...");
+  const files = (await jianguoyunList(secret)).filter((f) =>
+    /\.zip$/i.test(f.name)
+  );
+  if (!files.length) {
+    die(`坚果云 ${secret.remoteDir} 目录下没有 zip 归档`);
+  }
+  // 按修改时间倒序, 最新在前
+  files.sort((a, b) => new Date(b.mtime) - new Date(a.mtime));
+  const { picked } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "picked",
+      message: "请选择要导入的归档",
+      choices: files.map((f) => ({
+        name: `${f.name} (${(f.size / 1024).toFixed(1)} KB)`,
+        value: f.name,
+      })),
+    },
+  ]);
+  log(`下载中: ${picked}`);
+  await jianguoyunDownload(secret, picked, savePath);
+  return savePath;
+}
+
+async function cmdImport(archive, options) {
+  const strategy = options.strategy || "overwrite";
+  if (!["overwrite", "merge", "skip"].includes(strategy)) {
+    die(`无效策略: ${strategy} (可选: overwrite, merge, skip)`);
+  }
+  const isVerbose = Boolean(options.verbose);
+  const dryRun = Boolean(options.dryRun);
+
+  // 归档解析: 传了路径直接用; 未传(或 --source)交互选 本地/坚果云
+  let downloadedFile = null;
+  try {
+    if (!archive || options.source) {
+      const source = await selectImportSource(options);
+      if (source === "jianguoyun") {
+        downloadedFile = path.join(
+          os.tmpdir(),
+          `claude-download-${getTimestamp()}.zip`
+        );
+        // die() 的 process.exit 不走 finally, 注册退出钩子兜底清理下载临时文件
+        process.once("exit", () => fs.rmSync(downloadedFile, { force: true }));
+        archive = await downloadFromJianguoyun(options, downloadedFile);
+      } else if (!archive) {
+        archive = await askLocalArchivePath();
+      }
+    }
+    if (!fs.existsSync(archive)) die(`归档不存在: ${archive}`);
+
+    await doImport(archive, options, { strategy, isVerbose, dryRun });
+  } finally {
+    // 坚果云下载的临时文件用后即删
+    if (downloadedFile) fs.rmSync(downloadedFile, { force: true });
+  }
+}
+
+// 实际导入(archive 已是存在的本地文件)
+async function doImport(archive, options, { strategy, isVerbose, dryRun }) {
+  const { zip, manifest, root } = readArchive(archive);
+  const srcHome = manifest.source_home || "";
+  const archiveCategories = manifest.categories || CATEGORY_LIST;
+  const cats = options.categories
+    ? parseCategories(options.categories)
+    : archiveCategories.filter((c) => CATEGORY_LIST.includes(c));
+
+  // 解压到临时目录
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "claude-import-"));
+  // die() 的 process.exit 不走 finally, 注册退出钩子兜底清理解压临时目录
+  process.once("exit", () => fs.rmSync(tmpDir, { recursive: true, force: true }));
+  try {
+    zip.extractAllTo(tmpDir, true);
+    const archiveRoot = root
+      ? path.join(tmpDir, ...root.split("/"))
+      : tmpDir;
+    const dataDir = path.join(archiveRoot, "data");
+    if (!fs.existsSync(dataDir)) die("归档中未找到 data 目录");
+
+    // 目标目录确认(检测 + 确认/自定义)
+    const claudeDir = await resolveClaudeDirForImport(options);
+    const dstHome = path.dirname(path.resolve(claudeDir));
+    const needsRemap = srcHome && srcHome !== dstHome;
+
+    console.log("");
+    console.log(chalk.bold("导入信息:"));
+    console.log(`  来源:     ${manifest.hostname || "unknown"} (${srcHome || "unknown"})${manifest.platform ? ` [${manifest.platform}]` : ""}`);
+    console.log(`  目标:     ${claudeDir}`);
+    console.log(`  日期:     ${manifest.date || "unknown"}`);
+    console.log(`  策略:     ${strategy}`);
+    console.log(`  类别:     ${cats.join(",")}`);
+    if (needsRemap) {
+      console.log(`  ${chalk.yellow("路径重映射")}: ${srcHome} → ${dstHome}`);
+    }
+    console.log("");
+
+    // 路径重映射(projects 目录名 + 文件内容)
+    if (needsRemap) {
+      log("重映射路径...");
+      const projDir = path.join(dataDir, "projects");
+      if (fs.existsSync(projDir)) {
+        for (const name of fs.readdirSync(projDir)) {
+          const newName = remapDirname(name, srcHome, dstHome);
+          if (newName !== name) {
+            fs.renameSync(path.join(projDir, name), path.join(projDir, newName));
+            verbose(`目录重命名: ${name} → ${newName}`, isVerbose || dryRun);
+          }
+        }
+        for (const f of walkFiles(projDir)) {
+          if (f.endsWith(".jsonl")) {
+            remapFileContents(f, srcHome, dstHome);
+            verbose(`内容重映射: ${path.relative(dataDir, f)}`, isVerbose);
+          }
+        }
+      }
+      const historyFile = path.join(dataDir, "history.jsonl");
+      if (fs.existsSync(historyFile)) {
+        remapFileContents(historyFile, srcHome, dstHome);
+        verbose("内容重映射: history.jsonl", isVerbose);
+      }
+      for (const f of PLUGIN_FILES) {
+        const p = path.join(dataDir, "plugins", f);
+        if (fs.existsSync(p)) {
+          remapFileContents(p, srcHome, dstHome);
+          verbose(`内容重映射: plugins/${f}`, isVerbose);
+        }
+      }
+    }
+
+    // 预览模式
+    if (dryRun) {
+      log("预览(dry-run) — 将导入以下内容:");
+      for (const cat of cats) {
+        console.log(`  ${chalk.bold(cat)}:`);
+        dryRunCategory(cat, dataDir);
+      }
+      log("预览结束(未做任何修改)");
+      return;
+    }
+
+    // 备份现有数据
+    if (options.backup !== false && fs.existsSync(claudeDir)) {
+      const backupDir = `${claudeDir}-backup-${getTimestamp()}`;
+      log(`备份 ${claudeDir} → ${backupDir}`);
+      fs.cpSync(claudeDir, backupDir, { recursive: true });
+    }
+
+    // 应用导入
+    fs.mkdirSync(claudeDir, { recursive: true });
+    for (const cat of cats) {
+      importCategory(cat, dataDir, claudeDir, strategy, isVerbose);
+    }
+    log("导入完成!");
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+function dryRunCategory(cat, dataDir) {
+  const listFile = (f) =>
+    fs.existsSync(path.join(dataDir, f)) && console.log(`    ${f}`);
+  const listDir = (d) => {
+    const p = path.join(dataDir, d);
+    if (!fs.existsSync(p)) return;
+    const entries = fs.readdirSync(p);
+    for (const name of entries.slice(0, 20)) {
+      console.log(`    ${d}/${name}${fs.statSync(path.join(p, name)).isDirectory() ? "/" : ""}`);
+    }
+    if (entries.length > 20) console.log(`    ... 共 ${entries.length} 项`);
+  };
+  if (CATEGORY_FILES[cat]) {
+    CATEGORY_FILES[cat].forEach(listFile);
+  } else if (cat === "plugins") {
+    PLUGIN_FILES.forEach((f) => listFile(`plugins/${f}`));
+  } else if (cat === "memory") {
+    MEMORY_FILES.forEach(listFile);
+    listDir(MEMORY_DIR);
+  } else {
+    listDir(cat);
+  }
+}
+
+function importCategory(cat, dataDir, claudeDir, strategy, isVerbose) {
+  if (CATEGORY_FILES[cat]) {
+    importFiles(dataDir, claudeDir, CATEGORY_FILES[cat], strategy, isVerbose);
+  } else if (CATEGORY_DIRS[cat]) {
+    importDir(
+      path.join(dataDir, cat),
+      path.join(claudeDir, cat),
+      strategy,
+      isVerbose
+    );
+  } else if (cat === "plugins") {
+    fs.mkdirSync(path.join(claudeDir, "plugins"), { recursive: true });
+    importFiles(
+      path.join(dataDir, "plugins"),
+      path.join(claudeDir, "plugins"),
+      PLUGIN_FILES,
+      strategy,
+      isVerbose
+    );
+  } else if (cat === "memory") {
+    importFiles(dataDir, claudeDir, MEMORY_FILES, strategy, isVerbose);
+    importDir(
+      path.join(dataDir, MEMORY_DIR),
+      path.join(claudeDir, MEMORY_DIR),
+      strategy,
+      isVerbose
+    );
+  }
+  verbose(`已导入: ${cat}`, isVerbose);
+}
+
+// 单文件按策略导入(json 浅合并 / jsonl 去重合并)
+function importFiles(srcDir, dstDir, files, strategy, isVerbose) {
+  for (const f of files) {
+    const src = path.join(srcDir, f);
+    const dst = path.join(dstDir, f);
+    if (!fs.existsSync(src)) continue;
+    if (fs.existsSync(dst)) {
+      if (strategy === "skip") {
+        verbose(`跳过(已存在): ${f}`, isVerbose);
+        continue;
+      }
+      if (strategy === "merge" && f.endsWith(".json")) {
+        mergeJson(src, dst);
+        verbose(`已合并: ${f}`, isVerbose);
+        continue;
+      }
+      if (strategy === "merge" && f.endsWith(".jsonl")) {
+        importJsonl(src, dst);
+        verbose(`已合并 JSONL: ${f}`, isVerbose);
+        continue;
+      }
+    }
+    fs.mkdirSync(dstDir, { recursive: true });
+    fs.copyFileSync(src, dst);
+    verbose(`已拷贝: ${f}`, isVerbose);
+  }
+}
+
+// 目录按策略导入: overwrite 整目录覆盖; skip/merge 逐文件处理
+function importDir(src, dst, strategy, isVerbose) {
+  if (!fs.existsSync(src)) return;
+  fs.mkdirSync(dst, { recursive: true });
+  if (strategy === "overwrite") {
+    fs.cpSync(src, dst, { recursive: true });
+    return;
+  }
+  for (const file of walkFiles(src)) {
+    const rel = path.relative(src, file);
+    const dstFile = path.join(dst, rel);
+    if (!fs.existsSync(dstFile)) {
+      fs.mkdirSync(path.dirname(dstFile), { recursive: true });
+      fs.copyFileSync(file, dstFile);
+      verbose(`新增: ${rel}`, isVerbose);
+    } else if (strategy === "skip") {
+      verbose(`跳过(已存在): ${rel}`, isVerbose);
+    } else if (file.endsWith(".jsonl")) {
+      importJsonl(file, dstFile);
+      verbose(`已合并 JSONL: ${rel}`, isVerbose);
+    } else if (file.endsWith(".json")) {
+      mergeJson(file, dstFile);
+      verbose(`已合并 JSON: ${rel}`, isVerbose);
+    } else {
+      fs.copyFileSync(file, dstFile);
+      verbose(`覆盖(非JSON): ${rel}`, isVerbose);
+    }
+  }
+}
+
+// JSONL 按策略导入; merge 时按 timestamp+sessionId 去重(目标优先)
+function importJsonl(src, dst, strategy, isVerbose) {
+  if (!fs.existsSync(dst)) {
+    fs.mkdirSync(path.dirname(dst), { recursive: true });
+    fs.copyFileSync(src, dst);
+    return;
+  }
+  const lines = [];
+  const seen = new Set();
+  // 先读目标(本机数据优先), 再读来源
+  for (const p of [dst, src]) {
+    const text = fs.readFileSync(p, "utf-8");
+    for (let line of text.split("\n")) {
+      line = line.replace(/\r$/, "");
+      if (!line.trim()) continue;
+      let key = null;
+      try {
+        const obj = JSON.parse(line);
+        key = `${obj.timestamp || ""}|${obj.sessionId || ""}`;
+      } catch {
+        key = null;
+      }
+      if (key) {
+        if (seen.has(key)) continue;
+        seen.add(key);
+      }
+      lines.push(line);
+    }
+  }
+  fs.writeFileSync(dst, lines.join("\n") + "\n", "utf-8");
+}
+
+// JSON 浅合并: 目标(本机)已有的 key 优先, 来源只补缺失
+function mergeJson(src, dst) {
+  try {
+    const srcObj = JSON.parse(fs.readFileSync(src, "utf-8"));
+    const dstObj = JSON.parse(fs.readFileSync(dst, "utf-8"));
+    if (
+      srcObj &&
+      dstObj &&
+      typeof srcObj === "object" &&
+      typeof dstObj === "object" &&
+      !Array.isArray(srcObj) &&
+      !Array.isArray(dstObj)
+    ) {
+      for (const k of Object.keys(srcObj)) {
+        if (!(k in dstObj)) dstObj[k] = srcObj[k];
+      }
+      fs.writeFileSync(dst, JSON.stringify(dstObj, null, 2) + "\n", "utf-8");
+    }
+    // 非对象 JSON: 保持目标不动
+  } catch {
+    // 解析失败: 保持目标不动
+  }
+}
+
+// ─── 命令入口 ─────────────────────────────────────────────────────────
+
+async function runClaudeCommand(action, archive, options) {
+  switch (action) {
+    case "list":
+      return archive
+        ? cmdListArchive(archive)
+        : cmdListLocal(options);
+    case "export":
+      return cmdExport(options);
+    case "import":
+      return cmdImport(archive, options);
+    default:
+      die(`未知操作: ${action} (可选: list, export, import)`);
+  }
+}
+
+function registerClaudeCommand(program, { markHandled, addHelpExample }) {
+  program
+    .command("claude <action> [archive]")
+    .description(
+      "Claude Code 数据迁移: list 查看本地/归档数据 | export 导出zip(本地/坚果云) | import 导入(本地/坚果云, 跨系统路径重映射)"
+    )
+    .option("--categories <cats>", `逗号分隔类别(默认全部): ${ALL_CATEGORIES}`)
+    .option("--output <file>", "export 输出路径(默认 ./claude-export-YYYY-MM-DD.zip)")
+    .option("--dest <dest>", "export 保存位置: local(默认交互选) | jianguoyun")
+    .option("--source <source>", "import 归档来源: local(默认交互选) | jianguoyun")
+    .option("--strategy <mode>", "import 策略: overwrite(默认) | merge | skip")
+    .option("--claude-dir <path>", "指定 claude 数据目录(跳过检测与交互)")
+    .option("--account <mail>", "坚果云账号(邮箱)")
+    .option("--app-password <pwd>", "坚果云应用密码(网页端: 账户信息->安全选项->添加)")
+    .option("--remote-dir <dir>", "坚果云远程目录(默认 claude-migrate)")
+    .option("--cache", "坚果云凭据静默走缓存, 缓存缺失时回退交互")
+    .option("--dry-run", "import 预览, 不写盘")
+    .option("--no-backup", "import 跳过自动备份")
+    .option("--verbose", "显示明细")
+    .action((action, archive, options) => {
+      // 同步置位标记, 防止 index.js 落入默认翻译分支
+      markHandled();
+      runClaudeCommand(action, archive, options).catch((error) => {
+        console.error(chalk.red(error.message || String(error)));
+        process.exit(1);
+      });
+    });
+  addHelpExample("fe-it-beta claude list", "查看本地 Claude 数据概况");
+  addHelpExample("fe-it-beta claude export --verbose", "导出数据(交互选类别与保存位置)");
+  addHelpExample("fe-it-beta claude export --dest jianguoyun --cache", "导出直传坚果云, 凭据走缓存");
+  addHelpExample("fe-it-beta claude import claude-export-2026-09-30.zip --dry-run", "预览导入内容");
+  addHelpExample("fe-it-beta claude import --source jianguoyun --strategy merge --cache", "从坚果云选归档合并导入");
+}
+
 /**
  * @fileoverview 不要单独中文
  * @author ypf
@@ -5646,6 +6850,12 @@ registerStoryCommand(commander.program, {
   addHelpExample: (cmd, desc) => helpExamples.push([cmd, desc]),
 });
 
+let claudeHandled = false;
+registerClaudeCommand(commander.program, {
+  markHandled: () => (claudeHandled = true),
+  addHelpExample: (cmd, desc) => helpExamples.push([cmd, desc]),
+});
+
 commander.program.addHelpText(
   "after",
   "\n" +
@@ -5698,7 +6908,7 @@ const rules = [
     ],
   },
 ];
-if (storyHandled) ; else if (sass) {
+if (claudeHandled) ; else if (storyHandled) ; else if (sass) {
   sassMain(cliOpts).catch((error) => console.error(error));
 } else if (upload) {
   upload$1(cliOpts).catch((error) => console.error(error));