vite-plugin-deploy-oss 3.4.2 → 3.5.0

package/dist/chunk-6D7VVVXN.js

@@ -0,0 +1,728 @@
+// src/deploy.ts
+import oss from "ali-oss";
+import chalk3 from "chalk";
+import cliProgress from "cli-progress";
+import { globSync } from "glob";
+import { mkdir, stat, unlink, writeFile } from "fs/promises";
+import { dirname, resolve as resolve2 } from "path";
+
+// src/utils/file.ts
+import { createHash } from "crypto";
+import { createReadStream } from "fs";
+import { readdir, rm } from "fs/promises";
+import { resolve } from "path";
+var GARBAGE_FILE_REGEX = /(?:Thumbs\.db|\.DS_Store)$/i;
+var getFileMd5 = (filePath) => {
+  return new Promise((resolvePromise, reject) => {
+    const hash = createHash("md5");
+    const stream = createReadStream(filePath);
+    stream.on("error", (err) => reject(err));
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolvePromise(hash.digest("hex")));
+  });
+};
+var removeEmptyDirectories = async (rootDir) => {
+  const deletedDirectories = [];
+  const visit = async (dirPath) => {
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    let hasNonEmptyContent = false;
+    for (const entry of entries) {
+      const entryPath = resolve(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        const removed = await visit(entryPath);
+        if (!removed) hasNonEmptyContent = true;
+        continue;
+      }
+      if (!GARBAGE_FILE_REGEX.test(entry.name)) {
+        hasNonEmptyContent = true;
+      }
+    }
+    if (hasNonEmptyContent) return false;
+    await rm(dirPath, { recursive: true, force: true });
+    deletedDirectories.push(dirPath);
+    return true;
+  };
+  await visit(resolve(rootDir));
+  return deletedDirectories;
+};
+
+// src/utils/path.ts
+var DEFAULT_MANIFEST_FILE_NAME = "oss-manifest.json";
+var normalizeSlash = (value) => value.replace(/\\/g, "/").trim();
+var normalizePathSegments = (...values) => values.filter((value) => Boolean(value)).flatMap((value) => normalizeSlash(value).split("/")).filter(Boolean).join("/");
+var splitUrlLikeBase = (value) => {
+  const normalized = normalizeSlash(value);
+  const protocolMatch = normalized.match(/^([a-zA-Z][a-zA-Z\d+.-]*:\/\/[^/]+)(.*)$/);
+  if (protocolMatch) {
+    return {
+      prefix: protocolMatch[1],
+      path: protocolMatch[2] || ""
+    };
+  }
+  const protocolRelativeMatch = normalized.match(/^(\/\/[^/]+)(.*)$/);
+  if (protocolRelativeMatch) {
+    return {
+      prefix: protocolRelativeMatch[1],
+      path: protocolRelativeMatch[2] || ""
+    };
+  }
+  if (normalized.startsWith("/")) {
+    return {
+      prefix: "/",
+      path: normalized
+    };
+  }
+  return {
+    prefix: "",
+    path: normalized
+  };
+};
+var normalizeUrlLikeBase = (base) => {
+  const { prefix, path } = splitUrlLikeBase(base);
+  const normalizedPath = normalizePathSegments(path);
+  if (!prefix) return normalizedPath;
+  if (!normalizedPath) return prefix;
+  if (prefix === "/") return `/${normalizedPath}`;
+  return `${prefix}/${normalizedPath}`;
+};
+var ensureTrailingSlash = (value) => {
+  if (!value || value.endsWith("/")) return value;
+  return `${value}/`;
+};
+var normalizeObjectKey = (targetDir, relativeFilePath) => normalizePathSegments(targetDir, relativeFilePath);
+var normalizeManifestFileName = (fileName) => {
+  const normalized = normalizePathSegments(fileName || DEFAULT_MANIFEST_FILE_NAME);
+  return normalized || DEFAULT_MANIFEST_FILE_NAME;
+};
+var resolveManifestFileName = (manifest) => {
+  if (!manifest) return null;
+  if (manifest === true) return DEFAULT_MANIFEST_FILE_NAME;
+  return normalizeManifestFileName(manifest.fileName);
+};
+var encodeUrlPath = (path) => encodeURI(normalizePathSegments(path));
+var joinUrlPath = (base, path) => `${normalizeUrlLikeBase(base).replace(/\/+$/, "")}/${encodeUrlPath(path)}`;
+var resolveUploadedFileUrl = (relativeFilePath, objectKey, configBase, alias) => {
+  if (configBase) return joinUrlPath(configBase, relativeFilePath);
+  if (alias) return joinUrlPath(alias, objectKey);
+  return objectKey;
+};
+
+// src/utils/progress.ts
+import chalk from "chalk";
+var formatBytes = (bytes) => {
+  if (!Number.isFinite(bytes) || bytes <= 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let value = bytes;
+  let unitIndex = 0;
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024;
+    unitIndex++;
+  }
+  const digits = value >= 100 || unitIndex === 0 ? 0 : 1;
+  return `${value.toFixed(digits)} ${units[unitIndex]}`;
+};
+var formatDuration = (seconds) => {
+  if (!Number.isFinite(seconds) || seconds < 0) return "--";
+  const rounded = Math.round(seconds);
+  const mins = Math.floor(rounded / 60);
+  const secs = rounded % 60;
+  if (mins === 0) return `${secs}s`;
+  return `${mins}m${String(secs).padStart(2, "0")}s`;
+};
+
+// src/utils/terminal.ts
+import chalk2 from "chalk";
+import cliTruncate from "cli-truncate";
+import logSymbols from "log-symbols";
+import stringWidth from "string-width";
+var panelBorderColor = {
+  info: "cyan",
+  success: "green",
+  warning: "yellow",
+  danger: "red"
+};
+var getTerminalWidth = () => process.stdout?.columns || 100;
+var getPanelInnerWidth = () => Math.max(46, Math.min(84, getTerminalWidth() - 4));
+var padVisual = (text, width) => `${text}${" ".repeat(Math.max(0, width - stringWidth(text)))}`;
+var fitVisual = (text, width) => {
+  if (width <= 0) return "";
+  return padVisual(cliTruncate(text, width, { position: "middle" }), width);
+};
+var truncateTerminalText = (text, reservedWidth = 26) => {
+  const maxWidth = Math.max(24, Math.min(88, getTerminalWidth() - reservedWidth));
+  return cliTruncate(text, maxWidth, { position: "middle" });
+};
+var renderPanel = (title, rows, tone = "info", footer) => {
+  const color = chalk2[panelBorderColor[tone]];
+  const innerWidth = getPanelInnerWidth();
+  const labelWidth = rows.length > 0 ? Math.max(...rows.map((row) => stringWidth(row.label))) : 0;
+  const contentLines = [chalk2.bold(cliTruncate(title, innerWidth, { position: "end" }))];
+  if (rows.length > 0) {
+    contentLines.push("");
+    for (const row of rows) {
+      const paddedLabel = padVisual(row.label, labelWidth);
+      const prefix = `${paddedLabel}  `;
+      const availableValueWidth = Math.max(8, innerWidth - stringWidth(prefix));
+      contentLines.push(`${chalk2.gray(prefix)}${fitVisual(row.value, availableValueWidth)}`);
+    }
+  }
+  if (footer) {
+    contentLines.push("");
+    contentLines.push(chalk2.gray(cliTruncate(footer, innerWidth, { position: "middle" })));
+  }
+  const top = color(`\u256D${"\u2500".repeat(innerWidth + 2)}\u256E`);
+  const bottom = color(`\u2570${"\u2500".repeat(innerWidth + 2)}\u256F`);
+  const body = contentLines.map((line) => `${color("\u2502")} ${fitVisual(line, innerWidth)} ${color("\u2502")}`).join("\n");
+  return `${top}
+${body}
+${bottom}`;
+};
+var renderInlineStats = (items) => items.filter(Boolean).join(chalk2.gray(" \xB7 "));
+var getPanelDot = (tone = "success") => {
+  switch (tone) {
+    case "info":
+      return chalk2.green("\u25CF");
+    case "success":
+      return chalk2.green("\u25CF");
+    case "warning":
+      return chalk2.yellow("\u25CF");
+    case "danger":
+      return chalk2.red("\u25CF");
+  }
+};
+var getLogSymbol = (tone) => {
+  switch (tone) {
+    case "success":
+      return logSymbols.success;
+    case "warning":
+      return logSymbols.warning;
+    case "danger":
+      return logSymbols.error;
+  }
+};
+
+// src/deploy.ts
+var formatTimingDuration = (durationMs) => {
+  if (durationMs < 1e3) return `${durationMs}ms`;
+  const seconds = durationMs / 1e3;
+  return `${seconds.toFixed(seconds >= 10 ? 1 : 2)}s`;
+};
+var renderDebugPanel = (entries) => {
+  const rows = entries.map((entry) => ({
+    label: `${entry.label}:`,
+    value: chalk3.cyan(
+      entry.detail ? `${formatTimingDuration(entry.durationMs)} \xB7 ${truncateTerminalText(entry.detail, 24)}` : formatTimingDuration(entry.durationMs)
+    )
+  }));
+  return renderPanel(`${getPanelDot("success")} \u8C03\u8BD5\u8017\u65F6`, rows, "info");
+};
+var createManifestPayload = async (results, configBase, alias) => {
+  const successfulResults = results.filter((result) => result.success);
+  const files = await Promise.all(
+    successfulResults.map(async (result) => {
+      const md5 = await getFileMd5(result.file);
+      return {
+        file: result.relativeFilePath,
+        key: result.name,
+        url: resolveUploadedFileUrl(result.relativeFilePath, result.name, configBase, alias),
+        md5
+      };
+    })
+  );
+  return {
+    version: Date.now(),
+    files
+  };
+};
+var validateOptions = (option, runtimeOption) => {
+  const errors = [];
+  if (!option.accessKeyId) errors.push("accessKeyId is required");
+  if (!option.accessKeySecret) errors.push("accessKeySecret is required");
+  if (!option.bucket) errors.push("bucket is required");
+  if (!option.region) errors.push("region is required");
+  if (!option.uploadDir) errors.push("uploadDir is required");
+  if (!Number.isInteger(runtimeOption.retryTimes) || runtimeOption.retryTimes < 1)
+    errors.push("retryTimes must be >= 1");
+  if (!Number.isInteger(runtimeOption.concurrency) || runtimeOption.concurrency < 1) {
+    errors.push("concurrency must be >= 1");
+  }
+  if (!Number.isFinite(runtimeOption.multipartThreshold) || runtimeOption.multipartThreshold <= 0) {
+    errors.push("multipartThreshold must be > 0");
+  }
+  return errors;
+};
+var deployOss = async (option) => {
+  const rawOption = option || {};
+  const {
+    accessKeyId,
+    accessKeySecret,
+    region,
+    bucket,
+    configBase,
+    skip = "**/index.html",
+    uploadDir,
+    overwrite = true,
+    secure = true,
+    autoDelete = false,
+    alias,
+    open = true,
+    debug = false,
+    fancy = true,
+    noCache = false,
+    failOnError = true,
+    concurrency = 5,
+    retryTimes = 3,
+    multipartThreshold = 10 * 1024 * 1024,
+    manifest = false,
+    outDir = "dist",
+    ...props
+  } = rawOption;
+  if (!open) {
+    return {
+      success: true,
+      results: [],
+      outDir: normalizeSlash(resolve2(outDir)),
+      durationSeconds: 0,
+      uploadedBytes: 0,
+      retryCount: 0
+    };
+  }
+  const validationErrors = validateOptions(rawOption, {
+    retryTimes,
+    concurrency,
+    multipartThreshold
+  });
+  if (validationErrors.length > 0) {
+    throw new Error(`vite-plugin-deploy-oss \u914D\u7F6E\u9519\u8BEF:
+${validationErrors.map((err) => `  - ${err}`).join("\n")}`);
+  }
+  const normalizedUploadDir = normalizePathSegments(uploadDir);
+  const normalizedConfigBase = configBase ? ensureTrailingSlash(normalizeUrlLikeBase(configBase)) : void 0;
+  const normalizedAlias = alias ? normalizeUrlLikeBase(alias) : void 0;
+  const manifestFileName = resolveManifestFileName(manifest);
+  const effectiveAutoDelete = manifestFileName ? false : autoDelete;
+  const effectiveSkip = manifestFileName ? [] : Array.isArray(skip) ? skip : [skip];
+  const resolvedOutDir = normalizeSlash(resolve2(outDir));
+  const useInteractiveOutput = fancy && Boolean(process.stdout?.isTTY) && Boolean(process.stderr?.isTTY) && !process.env.CI;
+  const clearViewport = () => {
+    if (!useInteractiveOutput) return;
+    process.stdout.write("\x1B[2J\x1B[0f");
+  };
+  const uploadFileWithRetry = async (client2, task, silentLogs, maxRetries = retryTimes) => {
+    const shouldUseMultipart = task.size >= multipartThreshold;
+    const headers = {
+      "x-oss-storage-class": "Standard",
+      "x-oss-object-acl": "default",
+      "Cache-Control": task.cacheControl || (noCache || task.name.endsWith(".html") ? "no-cache" : "public, max-age=86400, immutable"),
+      "x-oss-forbid-overwrite": overwrite ? "false" : "true"
+    };
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        const result = shouldUseMultipart ? await client2.multipartUpload(task.name, task.filePath, {
+          timeout: 6e5,
+          partSize: 1024 * 1024,
+          parallel: Math.max(1, Math.min(concurrency, 4)),
+          headers
+        }) : await client2.put(task.name, task.filePath, {
+          timeout: 6e5,
+          headers
+        });
+        if (result.res.status === 200) {
+          if (effectiveAutoDelete) {
+            try {
+              await unlink(task.filePath);
+            } catch {
+              console.warn(
+                `${getLogSymbol("warning")} \u5220\u9664\u672C\u5730\u6587\u4EF6\u5931\u8D25: ${truncateTerminalText(task.relativeFilePath, 18)}`
+              );
+            }
+          }
+          return {
+            success: true,
+            file: task.filePath,
+            relativeFilePath: task.relativeFilePath,
+            name: task.name,
+            size: task.size,
+            retries: attempt - 1
+          };
+        }
+        throw new Error(`Upload failed with status: ${result.res.status}`);
+      } catch (error) {
+        if (attempt === maxRetries) {
+          if (!silentLogs) {
+            const reason = error instanceof Error ? error.message : String(error);
+            console.log(`${getLogSymbol("danger")} ${truncateTerminalText(task.relativeFilePath, 18)}  ${reason}`);
+          }
+          return {
+            success: false,
+            file: task.filePath,
+            relativeFilePath: task.relativeFilePath,
+            name: task.name,
+            size: task.size,
+            retries: attempt - 1,
+            error
+          };
+        }
+        if (!silentLogs) {
+          console.log(
+            `${getLogSymbol("warning")} ${truncateTerminalText(task.relativeFilePath, 18)}  \u6B63\u5728\u91CD\u8BD5 (${attempt}/${maxRetries})`
+          );
+        }
+        await new Promise((resolvePromise) => setTimeout(resolvePromise, 1e3 * attempt));
+      }
+    }
+    return {
+      success: false,
+      file: task.filePath,
+      relativeFilePath: task.relativeFilePath,
+      name: task.name,
+      size: task.size,
+      retries: maxRetries,
+      error: new Error("Max retries exceeded")
+    };
+  };
+  const uploadSingleTask = async (client2, task) => uploadFileWithRetry(client2, task, false);
+  const uploadFilesInBatches = async (client2, files2, windowSize = concurrency) => {
+    const results = [];
+    const debugEntries2 = [];
+    const totalFiles = files2.length;
+    const tasks = [];
+    let completed = 0;
+    let failed = 0;
+    let uploadedBytes = 0;
+    let retries = 0;
+    const taskPrepareStartedAt = Date.now();
+    const taskCandidates = await Promise.all(
+      files2.map(async (relativeFilePath) => {
+        const filePath = normalizeSlash(resolve2(resolvedOutDir, relativeFilePath));
+        const name = normalizeObjectKey(normalizedUploadDir, relativeFilePath);
+        try {
+          const fileStats = await stat(filePath);
+          return { task: { filePath, relativeFilePath, name, size: fileStats.size } };
+        } catch (error) {
+          return { task: null, error, filePath, relativeFilePath, name };
+        }
+      })
+    );
+    debugEntries2.push({
+      label: "\u751F\u6210\u4E0A\u4F20\u4EFB\u52A1",
+      durationMs: Date.now() - taskPrepareStartedAt,
+      detail: `${files2.length} \u4E2A\u6587\u4EF6`
+    });
+    for (const candidate of taskCandidates) {
+      if (candidate.task) {
+        tasks.push(candidate.task);
+      } else {
+        failed++;
+        completed++;
+        results.push({
+          success: false,
+          file: candidate.filePath,
+          relativeFilePath: candidate.relativeFilePath,
+          name: candidate.name,
+          size: 0,
+          retries: 0,
+          error: candidate.error
+        });
+      }
+    }
+    const totalBytes = tasks.reduce((sum, task) => sum + task.size, 0);
+    const startAt = Date.now();
+    const safeWindowSize = Math.max(1, Math.min(windowSize, tasks.length || 1));
+    const silentLogs = Boolean(useInteractiveOutput);
+    const progressBar = useInteractiveOutput ? new cliProgress.SingleBar({
+      hideCursor: true,
+      clearOnComplete: true,
+      stopOnComplete: true,
+      barsize: 18,
+      barCompleteChar: "\u2588",
+      barIncompleteChar: "\u2591",
+      format: `${chalk3.gray("\u4E0A\u4F20")} ${chalk3.bold("{percentage}%")} ${chalk3.cyan("{bar}")} ${chalk3.gray("\xB7")} ${chalk3.magenta("{speed}/s")} ${chalk3.gray("\xB7")} ${chalk3.gray("{elapsed}")}s`
+    }) : null;
+    const reportEvery = Math.max(1, Math.ceil(totalFiles / 6));
+    let lastReportedCompleted = -1;
+    if (progressBar) {
+      progressBar.start(totalFiles, 0, {
+        speed: formatBytes(0),
+        elapsed: "0"
+      });
+    }
+    const updateProgress = () => {
+      const elapsedSeconds = (Date.now() - startAt) / 1e3;
+      const speed = elapsedSeconds > 0 ? uploadedBytes / elapsedSeconds : 0;
+      if (!progressBar) {
+        const progressRatio = totalFiles > 0 ? completed / totalFiles : 1;
+        const percentage = Math.round(progressRatio * 100);
+        if (completed === 0 && totalFiles > 0) return;
+        if (completed === lastReportedCompleted) return;
+        if (completed === totalFiles || completed % reportEvery === 0) {
+          console.log(
+            `${chalk3.gray("\u4E0A\u4F20\u8FDB\u5EA6")} ${renderInlineStats([
+              chalk3.bold(`${completed}/${totalFiles}`),
+              `${percentage}%`,
+              `${formatBytes(uploadedBytes)}/${formatBytes(totalBytes)}`,
+              `${formatBytes(speed)}/s`
+            ])}`
+          );
+          lastReportedCompleted = completed;
+        }
+      } else {
+        progressBar.update(completed, {
+          speed: chalk3.magenta(formatBytes(speed)),
+          elapsed: formatDuration(elapsedSeconds).replace(/s$/, "")
+        });
+      }
+    };
+    const refreshTimer = progressBar ? setInterval(updateProgress, 120) : null;
+    let currentIndex = 0;
+    const worker = async () => {
+      while (true) {
+        const index = currentIndex++;
+        if (index >= tasks.length) return;
+        const task = tasks[index];
+        updateProgress();
+        const result = await uploadFileWithRetry(client2, task, silentLogs);
+        completed++;
+        retries += result.retries;
+        if (result.success) {
+          uploadedBytes += result.size;
+        } else {
+          failed++;
+        }
+        results.push(result);
+        updateProgress();
+      }
+    };
+    updateProgress();
+    try {
+      await Promise.all(Array.from({ length: safeWindowSize }, () => worker()));
+    } finally {
+      if (refreshTimer) clearInterval(refreshTimer);
+    }
+    if (progressBar) {
+      const elapsedSeconds = (Date.now() - startAt) / 1e3;
+      const speed = elapsedSeconds > 0 ? uploadedBytes / elapsedSeconds : 0;
+      progressBar.update(totalFiles, {
+        speed: chalk3.magenta(formatBytes(speed)),
+        elapsed: formatDuration(elapsedSeconds).replace(/s$/, "")
+      });
+      progressBar.stop();
+    } else {
+      console.log(`${getLogSymbol("success")} \u6240\u6709\u6587\u4EF6\u4E0A\u4F20\u5B8C\u6210 (${totalFiles}/${totalFiles})`);
+    }
+    debugEntries2.push({
+      label: "\u4E0A\u4F20\u6587\u4EF6",
+      durationMs: Date.now() - startAt,
+      detail: `${tasks.length} \u4E2A\u6210\u529F\u5019\u9009 \xB7 \u5E76\u53D1 ${safeWindowSize}`
+    });
+    return { results, debugEntries: debugEntries2 };
+  };
+  const startTime = Date.now();
+  const debugEntries = [];
+  const client = new oss({ region, accessKeyId, accessKeySecret, secure, bucket, ...props });
+  const collectFilesStartedAt = Date.now();
+  const files = globSync("**/*", {
+    cwd: resolvedOutDir,
+    nodir: true,
+    ignore: effectiveSkip
+  }).map((file) => normalizeSlash(file)).filter((file) => file !== manifestFileName);
+  debugEntries.push({
+    label: "\u626B\u63CF\u672C\u5730\u6587\u4EF6",
+    durationMs: Date.now() - collectFilesStartedAt,
+    detail: `${files.length} \u4E2A\u6587\u4EF6`
+  });
+  if (files.length === 0) {
+    console.log(`${getLogSymbol("warning")} \u6CA1\u6709\u627E\u5230\u9700\u8981\u4E0A\u4F20\u7684\u6587\u4EF6`);
+    return {
+      success: true,
+      results: [],
+      outDir: resolvedOutDir,
+      durationSeconds: (Date.now() - startTime) / 1e3,
+      uploadedBytes: 0,
+      retryCount: 0
+    };
+  }
+  clearViewport();
+  console.log(
+    renderPanel(
+      `${getPanelDot("success")} \u51C6\u5907\u90E8\u7F72`,
+      [
+        { label: "\u4F4D\u7F6E:", value: chalk3.green(`${bucket} \xB7 ${region}`) },
+        {
+          label: "\u76EE\u6807:",
+          value: chalk3.yellow(
+            truncateTerminalText(
+              normalizedAlias ? `${normalizedUploadDir || "/"} \xB7 ${normalizedAlias}` : normalizedUploadDir || "/",
+              18
+            )
+          )
+        },
+        {
+          label: "\u6587\u4EF6:",
+          value: chalk3.blue(`${files.length} \u4E2A \xB7 ${truncateTerminalText(resolvedOutDir, 30)}`)
+        }
+      ],
+      "info"
+    )
+  );
+  try {
+    const uploadExecution = await uploadFilesInBatches(client, files, concurrency);
+    const { results, debugEntries: uploadDebugEntries } = uploadExecution;
+    if (debug) {
+      debugEntries.push(...uploadDebugEntries);
+    }
+    const successCount = results.filter((r) => r.success).length;
+    const failedCount = results.length - successCount;
+    const durationSeconds = (Date.now() - startTime) / 1e3;
+    const uploadedBytes = results.reduce((sum, result) => result.success ? sum + result.size : sum, 0);
+    const retryCount = results.reduce((sum, result) => sum + result.retries, 0);
+    const avgSpeed = durationSeconds > 0 ? uploadedBytes / durationSeconds : 0;
+    let manifestSummary = null;
+    let manifestUrl;
+    if (manifestFileName) {
+      const manifestRelativeFilePath = manifestFileName;
+      const manifestFilePath = normalizeSlash(resolve2(resolvedOutDir, manifestRelativeFilePath));
+      const manifestObjectKey = normalizeObjectKey(normalizedUploadDir, manifestRelativeFilePath);
+      const manifestStartedAt = Date.now();
+      await mkdir(dirname(manifestFilePath), { recursive: true });
+      await writeFile(
+        manifestFilePath,
+        JSON.stringify(await createManifestPayload(results, normalizedConfigBase, normalizedAlias), null, 2),
+        "utf8"
+      );
+      if (debug) {
+        debugEntries.push({
+          label: "\u751F\u6210\u6E05\u5355\u6587\u4EF6",
+          durationMs: Date.now() - manifestStartedAt,
+          detail: manifestRelativeFilePath
+        });
+      }
+      const manifestStats = await stat(manifestFilePath);
+      const manifestUploadStartedAt = Date.now();
+      const manifestResult = await uploadSingleTask(client, {
+        filePath: manifestFilePath,
+        relativeFilePath: manifestRelativeFilePath,
+        name: manifestObjectKey,
+        size: manifestStats.size,
+        cacheControl: "no-cache, no-store, must-revalidate"
+      });
+      if (!manifestResult.success) {
+        throw manifestResult.error || new Error(`Failed to upload manifest: ${manifestRelativeFilePath}`);
+      }
+      if (debug) {
+        debugEntries.push({
+          label: "\u4E0A\u4F20\u6E05\u5355\u6587\u4EF6",
+          durationMs: Date.now() - manifestUploadStartedAt,
+          detail: manifestRelativeFilePath
+        });
+      }
+      manifestUrl = resolveUploadedFileUrl(
+        manifestRelativeFilePath,
+        manifestObjectKey,
+        normalizedConfigBase,
+        normalizedAlias
+      );
+      manifestSummary = truncateTerminalText(manifestUrl || manifestObjectKey, 20);
+    }
+    try {
+      const cleanupStartedAt = Date.now();
+      await removeEmptyDirectories(resolvedOutDir);
+      if (debug) {
+        debugEntries.push({
+          label: "\u6E05\u7406\u7A7A\u76EE\u5F55",
+          durationMs: Date.now() - cleanupStartedAt
+        });
+      }
+    } catch (error) {
+      console.warn(`${getLogSymbol("warning")} \u6E05\u7406\u7A7A\u76EE\u5F55\u5931\u8D25: ${error}`);
+    }
+    const resultRows = [
+      {
+        label: "\u7ED3\u679C:",
+        value: failedCount === 0 ? chalk3.green(`${successCount}/${results.length} \u5168\u90E8\u6210\u529F`) : chalk3.yellow(`\u6210\u529F ${successCount} \u4E2A\uFF0C\u5931\u8D25 ${failedCount} \u4E2A`)
+      },
+      {
+        label: "\u7EDF\u8BA1:",
+        value: renderInlineStats([
+          `${retryCount} \u6B21\u91CD\u8BD5`,
+          formatBytes(uploadedBytes),
+          `${formatBytes(avgSpeed)}/s`,
+          formatDuration(durationSeconds)
+        ])
+      },
+      ...manifestSummary ? [{ label: "\u6E05\u5355:", value: chalk3.cyan(manifestSummary) }] : []
+    ];
+    if (failedCount > 0) {
+      const failedItems = results.filter((result) => !result.success).slice(0, 2);
+      resultRows.push(
+        ...failedItems.map((item, index) => ({
+          label: `\u5931\u8D25 ${index + 1}`,
+          value: chalk3.red(
+            `${truncateTerminalText(item.name, 26)} \xB7 ${truncateTerminalText(item.error?.message || "unknown error", 22)}`
+          )
+        }))
+      );
+      if (failedCount > failedItems.length) {
+        resultRows.push({
+          label: "\u5176\u4F59",
+          value: chalk3.gray(`\u8FD8\u6709 ${failedCount - failedItems.length} \u4E2A\u5931\u8D25\u9879\u672A\u5C55\u5F00`)
+        });
+      }
+    }
+    console.log(
+      renderPanel(
+        failedCount === 0 ? `${getPanelDot("success")} \u90E8\u7F72\u5B8C\u6210` : `${getPanelDot("warning")} \u90E8\u7F72\u5B8C\u6210`,
+        resultRows,
+        failedCount === 0 ? "success" : "warning"
+      )
+    );
+    if (debug) {
+      debugEntries.push({
+        label: "\u603B\u8017\u65F6",
+        durationMs: Date.now() - startTime
+      });
+      console.log(renderDebugPanel(debugEntries));
+    }
+    if (failedCount > 0 && failOnError) {
+      throw new Error(`Failed to upload ${failedCount} of ${results.length} files`);
+    }
+    return {
+      success: failedCount === 0,
+      results,
+      outDir: resolvedOutDir,
+      durationSeconds,
+      uploadedBytes,
+      retryCount,
+      manifestUrl
+    };
+  } catch (error) {
+    console.log(`
+${getLogSymbol("danger")} \u4E0A\u4F20\u8FC7\u7A0B\u4E2D\u53D1\u751F\u9519\u8BEF: ${error}
+`);
+    if (debug && debugEntries.length > 0) {
+      debugEntries.push({
+        label: "\u5931\u8D25\u524D\u8017\u65F6",
+        durationMs: Date.now() - startTime
+      });
+      console.log(renderDebugPanel(debugEntries));
+    }
+    if (failOnError) {
+      throw error instanceof Error ? error : new Error(String(error));
+    }
+    return {
+      success: false,
+      results: [],
+      outDir: resolvedOutDir,
+      durationSeconds: (Date.now() - startTime) / 1e3,
+      uploadedBytes: 0,
+      retryCount: 0
+    };
+  }
+};
+
+export {
+  normalizeSlash,
+  normalizeUrlLikeBase,
+  ensureTrailingSlash,
+  deployOss
+};