zipcalm 0.0.0-stage → 1.0.2

package/server/lib/logger.js

@@ -0,0 +1,68 @@
+// 结构化日志（零依赖，JSON Lines）
+//
+// 设计要点：
+// - 每行一个 JSON 对象，方便将来直接喂给日志分析；不需要引入 pino/winston。
+// - **脱敏是硬要求**（INV-16：凭据不落明文）：字段名命中敏感词的一律替换为 [redacted]，
+//   且请求日志只记 method/url/status/耗时，不记 Cookie/Authorization 内容。
+// - 级别过滤用配置里的 log.level（debug|info|warn|error）。
+
+const LEVEL_WEIGHT = { debug: 10, info: 20, warn: 30, error: 40 };
+
+// 命中即脱敏的字段名（大小写不敏感，包含匹配）
+const SENSITIVE_KEY_PATTERN = /(password|passwd|token|authorization|cookie|secret|credential|apikey|api_key)/i;
+
+/**
+ * 递归脱敏：对象里的敏感字段替换为 [redacted]（数组按元素处理，深度上限 6 层防环）。
+ */
+export function redact(value, depth = 0) {
+  if (depth > 6) return '[deep]';
+  if (Array.isArray(value)) return value.map((item) => redact(item, depth + 1));
+  if (value && typeof value === 'object') {
+    const out = {};
+    for (const [key, val] of Object.entries(value)) {
+      out[key] = SENSITIVE_KEY_PATTERN.test(key) ? '[redacted]' : redact(val, depth + 1);
+    }
+    return out;
+  }
+  return value;
+}
+
+/**
+ * 创建 logger。
+ * @param {{level?: string, stream?: NodeJS.WritableStream, bindings?: object}} options
+ */
+export function createLogger(options = {}) {
+  const level = LEVEL_WEIGHT[options.level] ? options.level : 'info';
+  const stream = options.stream || process.stdout;
+  const bindings = options.bindings || {};
+  const threshold = LEVEL_WEIGHT[level];
+
+  function write(entryLevel, message, context) {
+    if (LEVEL_WEIGHT[entryLevel] < threshold) return;
+    const line = {
+      ts: new Date().toISOString(),
+      level: entryLevel,
+      msg: String(message),
+      ...redact(bindings),
+      ...(context ? redact(context) : {}),
+    };
+    try {
+      stream.write(`${JSON.stringify(line)}\n`);
+    } catch {
+      // 日志写不出去也不能影响业务
+    }
+  }
+
+  const logger = {
+    level,
+    debug: (msg, ctx) => write('debug', msg, ctx),
+    info: (msg, ctx) => write('info', msg, ctx),
+    warn: (msg, ctx) => write('warn', msg, ctx),
+    error: (msg, ctx) => write('error', msg, ctx),
+    /** 绑定固定字段（如 module 名） */
+    child(extra) {
+      return createLogger({ ...options, level, stream, bindings: { ...bindings, ...extra } });
+    },
+  };
+  return logger;
+}

package/server/lib/runtime-guard.js

@@ -0,0 +1,49 @@
+// 运行期环境自检（M4 起的最低版本约束）
+//
+// 为什么要有：`.tar.zst` 依赖 Node ≥ 22.15 内置的 zstd（`node:zlib` 的 `createZstdCompress`）。
+// 版本不够时**必须在启动时就明确拒绝**，而不是等用户点了压缩才在半个任务里炸 ——
+// 也就是说：把"环境不满足"变成启动期的一次性、可读的失败，而不是运行期的随机失败。
+//
+// 设计成纯函数（可注入 version）便于单测模拟低版本。
+
+/** 最低版本要求与理由（版本一升，这里同步改，单一事实源） */
+export const MIN_NODE = { major: 22, minor: 15, reason: 'zstd 内置 API（node:zlib 的 createZstdCompress）自 v22.15.0 起提供，.tar.zst 依赖它' };
+
+/** 解析 "22.23.3" / "v22.23.3" → {major, minor, patch} */
+export function parseNodeVersion(version) {
+  const text = String(version || '').replace(/^v/, '');
+  const [major, minor, patch] = text.split('.').map((part) => Number.parseInt(part, 10));
+  return {
+    major: Number.isInteger(major) ? major : 0,
+    minor: Number.isInteger(minor) ? minor : 0,
+    patch: Number.isInteger(patch) ? patch : 0,
+  };
+}
+
+/**
+ * 版本检查（不抛错，返回结果供启动流程决定怎么报告）
+ * @param {{major: number, minor: number, reason: string}} [min]
+ * @param {string} [version]
+ */
+export function checkNodeVersion(min = MIN_NODE, version = process.versions.node) {
+  const current = parseNodeVersion(version);
+  const ok = current.major > min.major || (current.major === min.major && current.minor >= min.minor);
+  return {
+    ok,
+    required: `${min.major}.${min.minor}.0`,
+    current: String(version || '').replace(/^v/, ''),
+    reason: min.reason,
+    message: ok
+      ? `Node 版本自检通过：v${String(version || '').replace(/^v/, '')} ≥ v${min.major}.${min.minor}.0`
+      : `Node 版本过低：本服务要求 **v${min.major}.${min.minor}.0 及以上**，当前是 v${String(version || '').replace(/^v/, '')}。\n`
+        + `原因：${min.reason}\n`
+        + '建议：升级 Node 到 22.15+（NAS 上可用套件管理器升级，或改用能提供 zstd 的运行环境）后重试。',
+  };
+}
+
+/** 版本不满足就抛错（启动流程捕获后打印并退出） */
+export function assertNodeVersion(min = MIN_NODE, version = process.versions.node) {
+  const versionCheck = checkNodeVersion(min, version);
+  if (!versionCheck.ok) throw new Error(versionCheck.message);
+  return versionCheck;
+}

package/server/lib/throttle.js

@@ -0,0 +1,42 @@
+// 进度节流器（≥100ms 或跨过阈值才回调）
+//
+// 为什么需要：压缩/解压都对每个条目、每个字节块产生事件；如果每次都广播给任务层，
+// SSE 与前端会被刷爆（docs/05 §一：事件驱动 + 节流，不是定时采样）。
+// 契约要求字节级进度按 ≥100ms 节流（插件契约 §3.4 第 3 条）。
+
+/**
+ * 包装一个进度回调，使其按最小间隔节流；但**文件级变化（currentFile 改变 / 计数变化）永远立即放行**，
+ * 这样"当前正在处理哪个文件"不会因为节流而滞后。
+ * @param {(payload: object) => void} sink
+ * @param {{intervalMs?: number}} [options]
+ */
+export function createThrottledReporter(sink, options = {}) {
+  const intervalMs = Number.isInteger(options.intervalMs) ? options.intervalMs : 100;
+  let lastEmitAt = 0;
+  let lastKey = '';
+  let pending = null;
+
+  function emit(payload, force) {
+    lastEmitAt = Date.now();
+    pending = null;
+    lastKey = `${payload.processedFiles}|${payload.currentFile}|${payload.stage || ''}`;
+    sink(payload);
+  }
+
+  return function report(payload) {
+    const key = `${payload.processedFiles}|${payload.currentFile}|${payload.stage || ''}`;
+    const now = Date.now();
+
+    // 阶段/文件级变化 → 立即上报（保证"当前文件名"实时）
+    if (key !== lastKey) {
+      emit(payload, true);
+      return;
+    }
+    // 纯字节级变化 → 按间隔节流
+    if (now - lastEmitAt >= intervalMs) {
+      emit(payload, false);
+      return;
+    }
+    pending = payload;
+  };
+}

package/server/plugins/capabilities/password/index.js

@@ -0,0 +1,300 @@
+// 加密密码能力插件（docs/19 §4.2 能力契约）
+//
+// 职责边界（docs/19 关键约束）：**不碰文件系统、不碰 archiver**——
+// 只做「参数校验 + 参数翻译（prepareCreate）+ 压后自测编排（verify）+ 候选密码序列 + 脱敏」。
+// 真正写盘由 zip 格式插件完成；删除护栏由 orchestrator/deleter 按 verify 结果执行。
+//
+// 算法可追加：methods/ 下加一个模块文件即可，本文件零改动（docs/19 §4.3）。
+//
+// 解压侧能力边界（P4 实测结论）：
+// - unzipper 内置 Decrypt.js 只实现 **ZipCrypto**（纯 CRC 表流式解密，无 AES）；
+// - AES-256（WinZip AES，compressionMethod=99）unzipper 会按 inflate 误解 → 表现为
+//   「inflate 失败/坏数据」，**不是密码错误**。所以解压侧必须先判加密方法：
+//   aes256 → 明确提示「当前不支持 AES-256 解压，请用 7-Zip」；zip20 → 带密码解，
+//   错密码提示「密码错误」。
+
+import { ERROR_CODES, apiError } from '../../../lib/errors.js';
+
+import aes256 from './methods/aes256.js';
+import zip20 from './methods/zip20.js';
+
+/** 算法表（key = method id）。追加算法 = 加一个 methods/*.js + 这里一行注册 */
+const METHODS = new Map([
+  [aes256.id, aes256],
+  [zip20.id, zip20],
+]);
+
+/** zip 加密条目标志位（general purpose bit 0） */
+const FLAG_ENCRYPTED = 0x1;
+/** WinZip AES 的伪压缩方法号（central directory compressionMethod=99） */
+const COMPRESSION_METHOD_AES = 99;
+
+function methodById(id) {
+  return METHODS.get(id) || null;
+}
+
+export default {
+  id: 'password',
+  name: '加密密码',
+
+  // 双向声明（docs/19 §4.2）：与格式插件的 capabilities 取交集才生效
+  appliesTo: ['zip'],
+
+  // 参数字段（算法枚举不在这里——由 methods/ 动态提供）
+  params: {
+    password: { type: 'string', required: true, secret: true, minLength: 1, maxLength: 1024 },
+    method: { type: 'methodRef', required: false, default: 'aes256' },
+  },
+
+  /**
+   * 参数校验与规范化（PW-4：后端独立校验，不信任前端）。
+   * @param {{password?: string, method?: string}} raw
+   * @param {{formatId: string}} context
+   * @returns {{ok: true, value: {password: string, method: string}} | {ok: false, error: {code, message, details}}}
+   */
+  validateParams(raw, { formatId } = {}) {
+    if (!raw || typeof raw.password !== 'string' || raw.password.length === 0) {
+      return { ok: false, error: { code: ERROR_CODES.VALIDATION_FAILED, message: '密码不能为空' } };
+    }
+    if (raw.password.length > this.params.password.maxLength) {
+      return { ok: false, error: { code: ERROR_CODES.VALIDATION_FAILED, message: `密码过长（上限 ${this.params.password.maxLength} 字符）` } };
+    }
+    const methodId = raw.method || this.params.method.default;
+    const method = methodById(methodId);
+    if (!method) {
+      return { ok: false, error: { code: ERROR_CODES.VALIDATION_FAILED, message: `未知加密算法：${String(methodId)}` } };
+    }
+    if (!method.available()) {
+      return { ok: false, error: { code: ERROR_CODES.VALIDATION_FAILED, message: `算法 ${method.name} 当前不可用` } };
+    }
+    if (formatId && !this.appliesTo.includes(formatId)) {
+      // PW-4 双保险：格式没声明能力 → 400（前端置灰只是体验）
+      return { ok: false, error: { code: ERROR_CODES.VALIDATION_FAILED, message: `格式 ${formatId} 不支持加密能力` } };
+    }
+    return { ok: true, value: { password: raw.password, method: methodId } };
+  },
+
+  /**
+   * 压缩前：把能力参数翻译成格式插件认识的东西（不做 IO）。
+   * @returns {{archiverFormat: string, extra: {encryptionMethod: string, password: string}}}
+   */
+  prepareCreate({ params }) {
+    const method = methodById(params.method) || methodById(this.params.method.default);
+    return {
+      archiverFormat: method.engine.archiverFormat,
+      extra: {
+        encryptionMethod: method.engine.encryptionMethod,
+        password: params.password,
+      },
+    };
+  },
+
+  /**
+   * 压缩后自测（PW-2：删除原文件的前置条件）——用同一密码试解一次。
+   *
+   * 实现走 unzipper.Open.file（与格式插件 test() 同一读取面）：
+   * - 全部条目带密码完整读通 + CRC 一致 → ok；
+   * - 任何条目读失败 → !ok（编排层把任务置 failed(VERIFY_FAILED)，INV-01 拦住删除）。
+   *
+   * @param {{archivePath: string, params: {password: string, method: string}, formatApi: object}} args
+   */
+  async verify({ archivePath, params }) {
+    const method = methodById(params.method);
+    if (!method) return { ok: false, error: `未知算法 ${params.method}` };
+    // 统一走 7z 试解：
+    // unzipper 只有 ZipCrypto 的解密实现，AES-256 包（compressionMethod=99）会被它
+    // 当成普通 inflate 解读 → 报「inflate 失败/坏数据」或 BAD_PASSWORD，属**假阴性**。
+    // 7-Zip 两种加密都能读，且本地环境与 NAS 上通常都有；探测不到时明确报错，不静默放行。
+    return verifyWith7z(archivePath, params.password);
+  },
+
+  /**
+   * 解压时：给出候选密码序列（用户输入优先，其次常用密码本按 lastUsedAt 倒序）。
+   * P3 的密码本由调用方注入 candidates；本能力只定义顺序语义。
+   */
+  prepareExtract({ userPassword, archiveCandidates = [] }) {
+    const candidates = [];
+    if (userPassword) candidates.push(userPassword);
+    for (const item of archiveCandidates) {
+      const value = typeof item === 'string' ? item : item && item.password;
+      if (value && !candidates.includes(value)) candidates.push(value);
+    }
+    return { candidates };
+  },
+
+  /**
+   * 脱敏（PW-1）：日志 / API 响应 / 落盘一律过这里——只留布尔与方法名，绝不回明文。
+   */
+  redact(params) {
+    return {
+      hasPassword: Boolean(params && params.password),
+      method: params && params.method ? params.method : undefined,
+    };
+  },
+
+  /**
+   * 加密元数据（GET /capabilities/password 用）：给前端渲染算法下拉与 caveat。
+   * 绝不包含任何密码值。
+   */
+  describe() {
+    return {
+      id: this.id,
+      name: this.name,
+      appliesTo: [...this.appliesTo],
+      methods: [...METHODS.values()].map((method) => ({
+        id: method.id,
+        name: method.name,
+        description: method.description,
+        compatibility: method.compatibility,
+        caveat: method.caveat,
+        available: method.available(),
+      })),
+    };
+  },
+
+  /**
+   * 解压侧加密判定（P4）：给格式插件 extract 用——判别条目加密方式。
+   * @param {{flags?: number, compressionMethod?: number}} entryVars unzipper 条目变量
+   * @returns {'none' | 'zip20' | 'aes-unsupported'}
+   */
+  classifyEntry(entryVars) {
+    const flags = Number(entryVars && entryVars.flags) || 0;
+    if ((flags & FLAG_ENCRYPTED) === 0) return 'none';
+    if (Number(entryVars && entryVars.compressionMethod) === COMPRESSION_METHOD_AES) return 'aes-unsupported';
+    return 'zip20';
+  },
+
+  /** 算法表暴露（解压侧/路由查询 caveat 用） */
+  methods: METHODS,
+};
+
+// —— 内部工具（不导出） ——
+
+import { execFile, execFileSync } from 'node:child_process';
+import { promisify } from 'node:util';
+
+import unzipperPkg from 'unzipper';
+const unzipper = unzipperPkg;
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * 探测 7z 可执行文件（tool-self-detection：环境变量 → PATH → 常见绝对路径）。
+ * 找不到返回 null，由调用方给**明确错误**，绝不静默当作「验证通过」。
+ */
+let cached7z = null;
+let cached7zProbed = false;
+function resolve7zBinary() {
+  if (cached7zProbed) return cached7z;
+  cached7zProbed = true;
+  const candidates = [
+    process.env.ZC_7Z_BIN,
+    '7z',
+    '7za',
+    '7zz',
+    '/bin/7z',
+    '/usr/bin/7z',
+    '/usr/local/bin/7z',
+    '/volume1/@appstore/7-Zip/usr/local/bin/7z',
+  ].filter(Boolean);
+  for (const candidate of candidates) {
+    try {
+      // 只做「能否调用」的轻量探测：--help 在 7z 各分支上都可用且不碰归档
+      execFileSync(candidate, ['--help'], { stdio: 'ignore', timeout: 5000 });
+      cached7z = candidate;
+      return cached7z;
+    } catch {
+      /* 试下一个 */
+    }
+  }
+  return null;
+}
+
+/**
+ * 用 7z 试解一次加密包（PW-2 的实现）。
+ * 7z t 会校验 CRC 并要求正确密码 —— 等价于「用这个密码完整读一遍」。
+ */
+export async function verifyWith7z(archivePath, password) {
+  const binary = resolve7zBinary();
+  if (!binary) {
+    return { ok: false, error: '未找到 7z，无法自测加密包（可设置 ZC_7Z_BIN 指定路径）' };
+  }
+  try {
+    await execFileAsync(binary, ['t', `-p${password}`, '-y', archivePath], {
+      timeout: 120000,
+      maxBuffer: 8 * 1024 * 1024,
+    });
+    return { ok: true };
+  } catch (error) {
+    const output = `${error && error.stdout ? error.stdout : ''}${error && error.stderr ? error.stderr : ''}`;
+    if (/wrong password|password is incorrect|加密|密码/i.test(output)) {
+      return { ok: false, error: '密码错误' };
+    }
+    // 绝不能把 execFile 的 error.message 直接透出去：它含**完整命令行**（`-p<明文密码>`）与本机绝对路径。
+    // 这些字串会被写进任务记录的 error 字段，等于把密码和目录结构泄漏到 API 响应里（实测踩过）。
+    return { ok: false, error: '加密包自测失败（7z 无法读取该包：可能格式不支持，或包已损坏）' };
+  }
+}
+
+async function unzipperOpen(archivePath) {
+  return unzipper.Open.file(archivePath);
+}
+
+function isDirectoryEntry(entry) {
+  return /\/$/.test(String(entry.path)) || entry.type === 'Directory';
+}
+
+/**
+ * 7z 实际解包（P4：AES-256 与 ZipCrypto 的统一解压通道——unzipper 只认 ZipCrypto，
+ * AES 走它必假阴性，所以加密包解压统一走 7z，一个实现两种算法）。
+ *
+ * 解到 **指定输出目录**（调用方传入临时目录），zip-slip 由两层防护：
+ * ① 7z 自身的路径规范化（p7zip 对 `../` 条目会拒绝或剥离）；
+ * ② 调用方在解包后仍走 planTargets 白名单链把文件**搬**进最终目标（不在解包目录直接交付）。
+ *
+ * @returns {{ok: true} | {ok: false, code: 'BAD_PASSWORD'|'ARCHIVE_CORRUPTED'|'SEVENZIP_MISSING'|'INTERNAL_ERROR', message: string}}
+ */
+export async function extractWith7z(archivePath, password, outputDir) {
+  const binary = resolve7zBinary();
+  if (!binary) {
+    return {
+      ok: false,
+      code: 'SEVENZIP_MISSING',
+      message: '当前环境缺少 7z，无法解压加密压缩包，请安装 7-Zip 或设置 ZC_7Z_BIN 环境变量',
+    };
+  }
+  try {
+    await execFileAsync(binary, ['x', `-p${password}`, '-y', `-o${outputDir}`, archivePath], {
+      timeout: 600000,
+      maxBuffer: 8 * 1024 * 1024,
+    });
+    return { ok: true };
+  } catch (error) {
+    const output = `${error && error.stdout ? error.stdout : ''}${error && error.stderr ? error.stderr : ''}`;
+    if (/wrong password/i.test(output)) {
+      return { ok: false, code: 'BAD_PASSWORD', message: '密码错误' };
+    }
+    if (/Cannot open|Errors|ERROR/i.test(output) && /corrupt|损坏|unexpected end/i.test(output)) {
+      return { ok: false, code: 'ARCHIVE_CORRUPTED', message: '压缩包损坏' };
+    }
+    return { ok: false, code: 'INTERNAL_ERROR', message: (error && error.message) || '解压失败' };
+  }
+}
+
+/** 7z 可用性探测（解压路由判「缺 7z」用，不执行解包） */
+export function sevenZipAvailable() {
+  return resolve7zBinary() !== null;
+}
+
+/** 加密条目检测（供 extract 路由/格式包判别）：任一非目录条目加密 → true */
+export async function archiveHasEncryption(archivePath) {
+  const directory = await unzipperOpen(archivePath);
+  for (const entry of directory.files) {
+    if (isDirectoryEntry(entry)) continue;
+    const flags = Number(entry.flags) || 0;
+    if ((flags & FLAG_ENCRYPTED) !== 0) {
+      return { encrypted: true, isAes: Number(entry.compressionMethod) === COMPRESSION_METHOD_AES };
+    }
+  }
+  return { encrypted: false, isAes: false };
+}

package/server/plugins/capabilities/password/methods/aes256.js

@@ -0,0 +1,31 @@
+// AES-256 加密算法模块（docs/19 §4.3 算法契约）
+//
+// 引擎：archiver-zip-encrypted（纯 JS，aes-js）——加密方法名 aes256。
+// 兼容性事实来自实测与 docs/18 §附二：7-Zip / WinZip / macOS 归档工具可解；
+// Linux Info-ZIP unzip 6.00 与 Windows 资源管理器**解不开**（资源管理器能看列表）。
+
+export default {
+  id: 'aes256',
+  name: 'AES-256',
+  description: 'WinZip 2003 标准（AES-256），安全性最高',
+
+  compatibility: {
+    sevenZip: true,
+    winZip: true,
+    macArchiveUtility: true,
+    winExplorer: false, // 能看列表不能解压
+    linuxUnzip: false, // Info-ZIP unzip 6.00 不支持
+  },
+  caveat: 'Linux unzip 6.00 与 Windows 资源管理器无法解开；7-Zip / WinZip / macOS 可解',
+
+  // 纯 JS 实现，无外部依赖，恒可用
+  available() {
+    return true;
+  },
+
+  // 引擎适配：能力插件 prepareCreate 把它展开进格式插件的 create 选项
+  engine: {
+    archiverFormat: 'zip-encrypted',
+    encryptionMethod: 'aes256',
+  },
+};

package/server/plugins/capabilities/password/methods/zip20.js

@@ -0,0 +1,29 @@
+// ZipCrypto（传统加密）算法模块（docs/19 §4.3 算法契约）
+//
+// 引擎：archiver-zip-encrypted——加密方法名 zip20。
+// 兼容性：几乎所有解压工具都支持（Windows 资源管理器 / Linux unzip / 7-Zip），
+// 但加密强度弱（可被暴力破解），caveat 必须如实告知用户。
+
+export default {
+  id: 'zip20',
+  name: 'ZipCrypto（传统）',
+  description: '传统 Zip 加密，兼容性最好但强度弱',
+
+  compatibility: {
+    sevenZip: true,
+    winZip: true,
+    macArchiveUtility: true,
+    winExplorer: true,
+    linuxUnzip: true,
+  },
+  caveat: '几乎所有工具可解，但加密强度弱（可被破解），敏感数据请选 AES-256',
+
+  available() {
+    return true;
+  },
+
+  engine: {
+    archiverFormat: 'zip-encrypted',
+    encryptionMethod: 'zip20',
+  },
+};

package/server/plugins/formats/_shared/createGuards.js

@@ -0,0 +1,26 @@
+// 格式包共用的「创建前置守卫」（各格式不许各写一份，避免漂移）
+//
+// 契约（docs/M0/插件契约.md §3.4 第 7 条）：**绝不覆盖** ——
+// `tempPath`（`outputPath + '.part'`）与 `outputPath` 任一已存在就必须直接抛 TARGET_EXISTS，
+// 由总入口负责命名唯一化；格式包不许自作主张覆盖或改名。
+
+import { ERROR_CODES, apiError } from '../../../lib/errors.js';
+import { pathExists } from '../../../lib/fs-probe.js';
+import { safeName } from './entrySafety.js';
+
+/**
+ * @param {{tempPath: string, outputPath: string}} ctx 格式包上下文
+ * @param {() => Promise<boolean>} isAvailable 该格式的可用性探测
+ * @param {string} formatId 用于错误提示的格式 id
+ */
+export async function assertCreatable(ctx, isAvailable, formatId) {
+  if (!(await isAvailable())) {
+    throw apiError(ERROR_CODES.FORMAT_UNAVAILABLE, `${formatId} 格式当前不可用`);
+  }
+  if (await pathExists(ctx.tempPath)) {
+    throw apiError(ERROR_CODES.TARGET_EXISTS, '临时产物已存在', { file: safeName(ctx.tempPath) });
+  }
+  if (await pathExists(ctx.outputPath)) {
+    throw apiError(ERROR_CODES.TARGET_EXISTS, '目标压缩包已存在（绝不覆盖）', { file: safeName(ctx.outputPath) });
+  }
+}