hx-cdn-forge 2.0.0

package/dist/split.js

@@ -0,0 +1,309 @@
+#!/usr/bin/env node
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var crypto = require('crypto');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/core/manifest.ts
+function serializeInfoYaml(info) {
+  const lines = [
+    `originalName: ${info.originalName}`,
+    `totalSize: ${info.totalSize}`,
+    `mimeType: ${info.mimeType}`,
+    `chunkSize: ${info.chunkSize}`,
+    `createdAt: "${info.createdAt}"`,
+    "chunks:"
+  ];
+  for (const chunk of info.chunks) {
+    lines.push(`  - fileName: ${chunk.fileName}`);
+    lines.push(`    index: ${chunk.index}`);
+    lines.push(`    size: ${chunk.size}`);
+    lines.push(`    sha256: ${chunk.sha256}`);
+  }
+  return lines.join("\n") + "\n";
+}
+function parseCacheYaml(text) {
+  const lines = text.split("\n");
+  let sourcePath = "";
+  let sourceHash = "";
+  let sourceSize = 0;
+  let generatedAt = "";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("sourcePath:")) sourcePath = extractValue(trimmed);
+    else if (trimmed.startsWith("sourceHash:")) sourceHash = extractValue(trimmed);
+    else if (trimmed.startsWith("sourceSize:")) sourceSize = parseInt(extractValue(trimmed), 10);
+    else if (trimmed.startsWith("generatedAt:")) generatedAt = extractValue(trimmed);
+  }
+  return { sourcePath, sourceHash, sourceSize, generatedAt };
+}
+function serializeCacheYaml(cache) {
+  return [
+    `sourcePath: ${cache.sourcePath}`,
+    `sourceHash: ${cache.sourceHash}`,
+    `sourceSize: ${cache.sourceSize}`,
+    `generatedAt: "${cache.generatedAt}"`,
+    ""
+  ].join("\n");
+}
+function extractValue(line) {
+  const idx = line.indexOf(":");
+  if (idx < 0) return "";
+  let val = line.slice(idx + 1).trim();
+  if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+    val = val.slice(1, -1);
+  }
+  return val;
+}
+
+// src/cli/split.ts
+var DEFAULT_CHUNK_SIZE = 19 * 1024 * 1024;
+async function splitFile(opts) {
+  const { source, outputDir, mappingPrefix, chunkSize, force } = opts;
+  if (!fs__namespace.existsSync(source)) {
+    console.error(`\u274C \u6E90\u6587\u4EF6\u4E0D\u5B58\u5728: ${source}`);
+    process.exit(1);
+  }
+  const stat = fs__namespace.statSync(source);
+  if (!stat.isFile()) {
+    console.error(`\u274C \u4E0D\u662F\u6587\u4EF6: ${source}`);
+    process.exit(1);
+  }
+  console.log(`\u{1F4E6} \u6E90\u6587\u4EF6: ${source} (${formatSize(stat.size)})`);
+  if (stat.size <= chunkSize) {
+    console.log(`\u2705 \u6587\u4EF6\u5C0F\u4E8E\u5207\u7247\u9608\u503C (${formatSize(chunkSize)})\uFF0C\u65E0\u9700\u5207\u7247`);
+    return;
+  }
+  const mappedPath = mapPath(source, mappingPrefix);
+  const targetDir = path__namespace.join(outputDir, mappedPath);
+  const cacheFile = path__namespace.join(targetDir, ".cache.yaml");
+  const infoFile = path__namespace.join(targetDir, "info.yaml");
+  console.log(`\u{1F4C2} \u8F93\u51FA\u76EE\u5F55: ${targetDir}`);
+  console.log(`\u{1F5FA}\uFE0F  \u6620\u5C04\u8DEF\u5F84: ${mappedPath}`);
+  const sourceHash = await computeFileHash(source);
+  if (!force && fs__namespace.existsSync(cacheFile)) {
+    try {
+      const cacheText = fs__namespace.readFileSync(cacheFile, "utf-8");
+      const cache2 = parseCacheYaml(cacheText);
+      if (cache2.sourceHash === sourceHash && cache2.sourceSize === stat.size) {
+        console.log(`\u23ED\uFE0F  \u6E90\u6587\u4EF6\u672A\u53D8\u5316\uFF0C\u8DF3\u8FC7 (hash: ${sourceHash.slice(0, 12)}...)`);
+        return;
+      }
+      console.log(`\u{1F504} \u6E90\u6587\u4EF6\u5DF2\u53D8\u5316\uFF0C\u91CD\u65B0\u751F\u6210\u5207\u7247`);
+    } catch {
+    }
+  }
+  fs__namespace.mkdirSync(targetDir, { recursive: true });
+  const fileName = path__namespace.basename(source);
+  const chunks = [];
+  const fileBuffer = fs__namespace.readFileSync(source);
+  let offset = 0;
+  let index = 0;
+  while (offset < fileBuffer.length) {
+    const end = Math.min(offset + chunkSize, fileBuffer.length);
+    const chunkData = fileBuffer.subarray(offset, end);
+    const chunkFileName = `${index}-${fileName}`;
+    const chunkPath = path__namespace.join(targetDir, chunkFileName);
+    fs__namespace.writeFileSync(chunkPath, chunkData);
+    const chunkHash = crypto__namespace.createHash("sha256").update(chunkData).digest("hex");
+    chunks.push({
+      fileName: chunkFileName,
+      index,
+      size: chunkData.length,
+      sha256: chunkHash
+    });
+    console.log(`  \u2702\uFE0F  ${chunkFileName} (${formatSize(chunkData.length)})`);
+    offset = end;
+    index++;
+  }
+  const info = {
+    originalName: fileName,
+    totalSize: stat.size,
+    mimeType: guessMimeType(fileName),
+    chunkSize,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    chunks
+  };
+  fs__namespace.writeFileSync(infoFile, serializeInfoYaml(info), "utf-8");
+  console.log(`\u{1F4CB} \u751F\u6210 info.yaml`);
+  const cache = {
+    sourcePath: source,
+    sourceHash,
+    sourceSize: stat.size,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  fs__namespace.writeFileSync(cacheFile, serializeCacheYaml(cache), "utf-8");
+  console.log(`\u{1F4BE} \u751F\u6210 .cache.yaml`);
+  console.log(`
+\u2705 \u5B8C\u6210! ${chunks.length} \u4E2A\u5207\u7247, \u603B\u8BA1 ${formatSize(stat.size)}`);
+}
+function main() {
+  const args = process.argv.slice(2);
+  if (args.includes("--help") || args.includes("-h") || args.length === 0) {
+    printHelp();
+    return;
+  }
+  const opts = {
+    source: getArg(args, "--source", "-s") ?? "",
+    outputDir: getArg(args, "--output", "-o") ?? "",
+    mappingPrefix: getArg(args, "--prefix", "-p") ?? "",
+    chunkSize: parseSize(getArg(args, "--chunk-size", "-c") ?? `${DEFAULT_CHUNK_SIZE}`),
+    force: args.includes("--force") || args.includes("-f")
+  };
+  if (!opts.source) {
+    console.error("\u274C \u7F3A\u5C11 --source \u53C2\u6570");
+    process.exit(1);
+  }
+  if (!opts.outputDir) {
+    console.error("\u274C \u7F3A\u5C11 --output \u53C2\u6570");
+    process.exit(1);
+  }
+  splitFile(opts);
+}
+function printHelp() {
+  console.log(`
+hx-cdn-split \u2014 HX-CDN-Forge \u5927\u6587\u4EF6\u5207\u7247\u5DE5\u5177
+
+\u7528\u6CD5:
+  hx-cdn-split --source <\u8DEF\u5F84> --output <\u76EE\u5F55> [\u9009\u9879]
+
+\u5FC5\u586B:
+  -s, --source <path>     \u6E90\u6587\u4EF6\u8DEF\u5F84
+  -o, --output <dir>      \u8F93\u51FA\u5B58\u50A8\u6839\u76EE\u5F55
+
+\u53EF\u9009:
+  -p, --prefix <prefix>   \u6620\u5C04\u524D\u7F00 (\u4ECE source \u8DEF\u5F84\u53BB\u9664)
+  -c, --chunk-size <size> \u5207\u7247\u5927\u5C0F (\u9ED8\u8BA4 19MB)
+                          \u652F\u6301 B/KB/MB \u540E\u7F00, \u5982: 19MB, 10240KB
+  -f, --force             \u5F3A\u5236\u91CD\u65B0\u751F\u6210 (\u5FFD\u7565\u7F13\u5B58)
+  -h, --help              \u663E\u793A\u5E2E\u52A9
+
+\u793A\u4F8B:
+  # \u5C06 25MB \u7684 ASS \u6587\u4EF6\u5207\u7247
+  hx-cdn-split -s static/ass/loli.ass -o static/cdn-black -p static
+
+  # \u4F7F\u7528\u81EA\u5B9A\u4E49\u5207\u7247\u5927\u5C0F
+  hx-cdn-split -s data/big.bin -o cdn-data -p data -c 10MB
+
+  # \u5F3A\u5236\u91CD\u65B0\u751F\u6210
+  hx-cdn-split -s static/ass/loli.ass -o static/cdn-black -p static -f
+`.trim());
+}
+function getArg(args, long, short) {
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === long || args[i] === short) {
+      return args[i + 1];
+    }
+  }
+  return void 0;
+}
+function parseSize(str) {
+  const match = str.match(/^(\d+(?:\.\d+)?)\s*(B|KB|MB|GB)?$/i);
+  if (!match) return parseInt(str, 10) || DEFAULT_CHUNK_SIZE;
+  const num = parseFloat(match[1]);
+  const unit = (match[2] ?? "B").toUpperCase();
+  switch (unit) {
+    case "GB":
+      return Math.floor(num * 1024 * 1024 * 1024);
+    case "MB":
+      return Math.floor(num * 1024 * 1024);
+    case "KB":
+      return Math.floor(num * 1024);
+    default:
+      return Math.floor(num);
+  }
+}
+function formatSize(bytes) {
+  if (bytes >= 1024 * 1024 * 1024) return `${(bytes / 1024 / 1024 / 1024).toFixed(2)} GB`;
+  if (bytes >= 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(2)} MB`;
+  if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${bytes} B`;
+}
+function mapPath(filePath, prefix) {
+  let p = filePath.replace(/\\/g, "/");
+  if (prefix) {
+    const normalizedPrefix = prefix.replace(/\\/g, "/");
+    if (p.startsWith(normalizedPrefix)) {
+      p = p.slice(normalizedPrefix.length);
+    }
+    if (p.startsWith("/")) p = p.slice(1);
+  }
+  return p;
+}
+async function computeFileHash(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto__namespace.createHash("sha256");
+    const stream = fs__namespace.createReadStream(filePath);
+    stream.on("data", (data) => hash.update(data));
+    stream.on("end", () => resolve(hash.digest("hex")));
+    stream.on("error", reject);
+  });
+}
+function guessMimeType(fileName) {
+  const ext = path__namespace.extname(fileName).toLowerCase();
+  const mimeMap = {
+    ".ass": "text/x-ssa",
+    ".srt": "text/plain",
+    ".json": "application/json",
+    ".yaml": "text/yaml",
+    ".yml": "text/yaml",
+    ".txt": "text/plain",
+    ".bin": "application/octet-stream",
+    ".zip": "application/zip",
+    ".tar": "application/x-tar",
+    ".gz": "application/gzip",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".svg": "image/svg+xml",
+    ".mp3": "audio/mpeg",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+    ".wasm": "application/wasm",
+    ".pdf": "application/pdf",
+    ".css": "text/css",
+    ".js": "application/javascript",
+    ".mjs": "application/javascript",
+    ".ts": "text/typescript",
+    ".html": "text/html"
+  };
+  return mimeMap[ext] ?? "application/octet-stream";
+}
+if (typeof __require !== "undefined" && __require.main === module) {
+  main();
+}
+
+exports.cli = main;
+exports.splitFile = splitFile;

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "hx-cdn-forge",
+  "version": "2.0.0",
+  "description": "GitHub CDN proxy with transparent large-file splitting, multi-CDN parallel download, and turbo mode",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "hx-cdn-split": "./dist/split.js"
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./styles.css": "./dist/index.css"
+  },
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "keywords": [
+    "cdn",
+    "cdn-forge",
+    "github-cdn",
+    "jsdelivr",
+    "file-splitting",
+    "parallel-download",
+    "multi-cdn",
+    "turbo-mode",
+    "react",
+    "typescript",
+    "china-friendly",
+    "large-file"
+  ],
+  "author": "HX",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/HengXin666/HX-CDN-Forge"
+  },
+  "bugs": {
+    "url": "https://github.com/HengXin666/HX-CDN-Forge/issues"
+  },
+  "homepage": "https://github.com/HengXin666/HX-CDN-Forge#readme",
+  "scripts": {
+    "build": "tsup",
+    "dev": "vite",
+    "type-check": "tsc --noEmit",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src/**/*.{ts,tsx}",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^25.5.0",
+    "@types/react": "^18.2.0",
+    "@types/react-dom": "^18.2.0",
+    "@vitejs/plugin-react": "^4.7.0",
+    "jest": "^29.7.0",
+    "parcel": "^2.11.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "ts-jest": "^29.1.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vite": "^5.4.21"
+  },
+  "peerDependencies": {
+    "react": ">=16.8.0",
+    "react-dom": ">=16.8.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/src/cli/split.ts

@@ -0,0 +1,311 @@
+/**
+ * CLI 差分切片工具
+ *
+ * 用法:
+ *   npx hx-cdn-split --source static/ass/loli.ass \
+ *     --output static/cdn-black \
+ *     --prefix static \
+ *     --chunk-size 19MB
+ *
+ * 或在 package.json scripts 中:
+ *   "cdn:split": "hx-cdn-split --source ... --output ... --prefix ..."
+ *
+ * 功能:
+ * - 将大文件切片为多个 < threshold 的小文件
+ * - 生成 info.yaml (切片清单)
+ * - 生成 .cache.yaml (源文件哈希，用于增量更新检测)
+ * - 支持增量更新: 源文件未变化时跳过
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import { serializeInfoYaml, serializeCacheYaml, parseCacheYaml } from '../core/manifest';
+import type { SplitInfo, SplitChunkInfo, SplitCache } from '../types';
+
+// ============================================================
+// 配置
+// ============================================================
+
+interface SplitOptions {
+  source: string;       // 源文件路径 (相对或绝对)
+  outputDir: string;    // 输出根目录
+  mappingPrefix: string;// 从 source 路径去除的前缀
+  chunkSize: number;    // 切片大小 (字节)
+  force: boolean;       // 是否强制重新生成
+}
+
+const DEFAULT_CHUNK_SIZE = 19 * 1024 * 1024; // 19MB (留余量给 20MB 的 CDN 限制)
+
+// ============================================================
+// 主函数
+// ============================================================
+
+export async function splitFile(opts: SplitOptions): Promise<void> {
+  const { source, outputDir, mappingPrefix, chunkSize, force } = opts;
+
+  // 1. 验证源文件
+  if (!fs.existsSync(source)) {
+    console.error(`❌ 源文件不存在: ${source}`);
+    process.exit(1);
+  }
+
+  const stat = fs.statSync(source);
+  if (!stat.isFile()) {
+    console.error(`❌ 不是文件: ${source}`);
+    process.exit(1);
+  }
+
+  console.log(`📦 源文件: ${source} (${formatSize(stat.size)})`);
+
+  if (stat.size <= chunkSize) {
+    console.log(`✅ 文件小于切片阈值 (${formatSize(chunkSize)})，无需切片`);
+    return;
+  }
+
+  // 2. 计算映射路径
+  const mappedPath = mapPath(source, mappingPrefix);
+  const targetDir = path.join(outputDir, mappedPath);
+  const cacheFile = path.join(targetDir, '.cache.yaml');
+  const infoFile = path.join(targetDir, 'info.yaml');
+
+  console.log(`📂 输出目录: ${targetDir}`);
+  console.log(`🗺️  映射路径: ${mappedPath}`);
+
+  // 3. 检查增量更新
+  const sourceHash = await computeFileHash(source);
+
+  if (!force && fs.existsSync(cacheFile)) {
+    try {
+      const cacheText = fs.readFileSync(cacheFile, 'utf-8');
+      const cache = parseCacheYaml(cacheText);
+      if (cache.sourceHash === sourceHash && cache.sourceSize === stat.size) {
+        console.log(`⏭️  源文件未变化，跳过 (hash: ${sourceHash.slice(0, 12)}...)`);
+        return;
+      }
+      console.log(`🔄 源文件已变化，重新生成切片`);
+    } catch {
+      // cache 解析失败，重新生成
+    }
+  }
+
+  // 4. 创建输出目录
+  fs.mkdirSync(targetDir, { recursive: true });
+
+  // 5. 切片
+  const fileName = path.basename(source);
+  const chunks: SplitChunkInfo[] = [];
+  const fileBuffer = fs.readFileSync(source);
+  let offset = 0;
+  let index = 0;
+
+  while (offset < fileBuffer.length) {
+    const end = Math.min(offset + chunkSize, fileBuffer.length);
+    const chunkData = fileBuffer.subarray(offset, end);
+    const chunkFileName = `${index}-${fileName}`;
+    const chunkPath = path.join(targetDir, chunkFileName);
+
+    // 写入分片
+    fs.writeFileSync(chunkPath, chunkData);
+
+    // 计算分片哈希
+    const chunkHash = crypto.createHash('sha256').update(chunkData).digest('hex');
+
+    chunks.push({
+      fileName: chunkFileName,
+      index,
+      size: chunkData.length,
+      sha256: chunkHash,
+    });
+
+    console.log(`  ✂️  ${chunkFileName} (${formatSize(chunkData.length)})`);
+
+    offset = end;
+    index++;
+  }
+
+  // 6. 生成 info.yaml
+  const info: SplitInfo = {
+    originalName: fileName,
+    totalSize: stat.size,
+    mimeType: guessMimeType(fileName),
+    chunkSize,
+    createdAt: new Date().toISOString(),
+    chunks,
+  };
+
+  fs.writeFileSync(infoFile, serializeInfoYaml(info), 'utf-8');
+  console.log(`📋 生成 info.yaml`);
+
+  // 7. 生成 .cache.yaml
+  const cache: SplitCache = {
+    sourcePath: source,
+    sourceHash,
+    sourceSize: stat.size,
+    generatedAt: new Date().toISOString(),
+  };
+
+  fs.writeFileSync(cacheFile, serializeCacheYaml(cache), 'utf-8');
+  console.log(`💾 生成 .cache.yaml`);
+
+  console.log(`\n✅ 完成! ${chunks.length} 个切片, 总计 ${formatSize(stat.size)}`);
+}
+
+// ============================================================
+// CLI 入口
+// ============================================================
+
+function main(): void {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--help') || args.includes('-h') || args.length === 0) {
+    printHelp();
+    return;
+  }
+
+  const opts: SplitOptions = {
+    source: getArg(args, '--source', '-s') ?? '',
+    outputDir: getArg(args, '--output', '-o') ?? '',
+    mappingPrefix: getArg(args, '--prefix', '-p') ?? '',
+    chunkSize: parseSize(getArg(args, '--chunk-size', '-c') ?? `${DEFAULT_CHUNK_SIZE}`),
+    force: args.includes('--force') || args.includes('-f'),
+  };
+
+  if (!opts.source) {
+    console.error('❌ 缺少 --source 参数');
+    process.exit(1);
+  }
+  if (!opts.outputDir) {
+    console.error('❌ 缺少 --output 参数');
+    process.exit(1);
+  }
+
+  splitFile(opts);
+}
+
+function printHelp(): void {
+  console.log(`
+hx-cdn-split — HX-CDN-Forge 大文件切片工具
+
+用法:
+  hx-cdn-split --source <路径> --output <目录> [选项]
+
+必填:
+  -s, --source <path>     源文件路径
+  -o, --output <dir>      输出存储根目录
+
+可选:
+  -p, --prefix <prefix>   映射前缀 (从 source 路径去除)
+  -c, --chunk-size <size> 切片大小 (默认 19MB)
+                          支持 B/KB/MB 后缀, 如: 19MB, 10240KB
+  -f, --force             强制重新生成 (忽略缓存)
+  -h, --help              显示帮助
+
+示例:
+  # 将 25MB 的 ASS 文件切片
+  hx-cdn-split -s static/ass/loli.ass -o static/cdn-black -p static
+
+  # 使用自定义切片大小
+  hx-cdn-split -s data/big.bin -o cdn-data -p data -c 10MB
+
+  # 强制重新生成
+  hx-cdn-split -s static/ass/loli.ass -o static/cdn-black -p static -f
+`.trim());
+}
+
+// ============================================================
+// 辅助函数
+// ============================================================
+
+function getArg(args: string[], long: string, short: string): string | undefined {
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === long || args[i] === short) {
+      return args[i + 1];
+    }
+  }
+  return undefined;
+}
+
+function parseSize(str: string): number {
+  const match = str.match(/^(\d+(?:\.\d+)?)\s*(B|KB|MB|GB)?$/i);
+  if (!match) return parseInt(str, 10) || DEFAULT_CHUNK_SIZE;
+
+  const num = parseFloat(match[1]!);
+  const unit = (match[2] ?? 'B').toUpperCase();
+
+  switch (unit) {
+    case 'GB': return Math.floor(num * 1024 * 1024 * 1024);
+    case 'MB': return Math.floor(num * 1024 * 1024);
+    case 'KB': return Math.floor(num * 1024);
+    default: return Math.floor(num);
+  }
+}
+
+function formatSize(bytes: number): string {
+  if (bytes >= 1024 * 1024 * 1024) return `${(bytes / 1024 / 1024 / 1024).toFixed(2)} GB`;
+  if (bytes >= 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(2)} MB`;
+  if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${bytes} B`;
+}
+
+function mapPath(filePath: string, prefix: string): string {
+  let p = filePath.replace(/\\/g, '/');
+  if (prefix) {
+    const normalizedPrefix = prefix.replace(/\\/g, '/');
+    if (p.startsWith(normalizedPrefix)) {
+      p = p.slice(normalizedPrefix.length);
+    }
+    if (p.startsWith('/')) p = p.slice(1);
+  }
+  return p;
+}
+
+async function computeFileHash(filePath: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash('sha256');
+    const stream = fs.createReadStream(filePath);
+    stream.on('data', (data) => hash.update(data));
+    stream.on('end', () => resolve(hash.digest('hex')));
+    stream.on('error', reject);
+  });
+}
+
+function guessMimeType(fileName: string): string {
+  const ext = path.extname(fileName).toLowerCase();
+  const mimeMap: Record<string, string> = {
+    '.ass': 'text/x-ssa',
+    '.srt': 'text/plain',
+    '.json': 'application/json',
+    '.yaml': 'text/yaml',
+    '.yml': 'text/yaml',
+    '.txt': 'text/plain',
+    '.bin': 'application/octet-stream',
+    '.zip': 'application/zip',
+    '.tar': 'application/x-tar',
+    '.gz': 'application/gzip',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.svg': 'image/svg+xml',
+    '.mp3': 'audio/mpeg',
+    '.mp4': 'video/mp4',
+    '.webm': 'video/webm',
+    '.wasm': 'application/wasm',
+    '.pdf': 'application/pdf',
+    '.css': 'text/css',
+    '.js': 'application/javascript',
+    '.mjs': 'application/javascript',
+    '.ts': 'text/typescript',
+    '.html': 'text/html',
+  };
+  return mimeMap[ext] ?? 'application/octet-stream';
+}
+
+// 如果直接执行此文件
+if (typeof require !== 'undefined' && require.main === module) {
+  main();
+}
+
+export { main as cli };