vite-plugin-deploy-oss 3.2.1 → 3.3.1

package/.prettierignore

@@ -0,0 +1,5 @@
+dist
+node_modules
+playground/__dist__
+coverage
+*.log

package/.prettierrc.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://json.schemastore.org/prettierrc",
+  "arrowParens": "always",
+  "bracketSameLine": false,
+  "jsxSingleQuote": true,
+  "printWidth": 120,
+  "quoteProps": "as-needed",
+  "semi": false,
+  "singleQuote": true,
+  "tabWidth": 2,
+  "endOfLine": "lf"
+}

package/README.md

@@ -12,6 +12,14 @@
 pnpm add vite-plugin-deploy-oss -D
 ```
 
+## 调试模式
+
+```bash
+pnpm run build:test:debug
+```
+
+这会进入带调试信息的上传模式，构建结束后额外输出每个关键步骤花了多久。
+
 ## 使用
 
 ```ts
@@ -26,6 +34,8 @@ export default {
     vitePluginDeployOss({
       // 建议按环境变量开关上传，避免本地/CI误上传
       open: process.env.DEPLOY_OSS === '1',
+      // 输出调试耗时信息，方便排查慢在哪里
+      debug: process.env.DEPLOY_OSS_DEBUG === '1',
       // 终端实时动效进度面板（默认 true）
       fancy: true,
 
@@ -53,6 +63,7 @@ export default {
 
 - 当前版本仅支持 ESM（`import`），不再提供 CommonJS（`require`）入口。
 - `open` 默认 `true`，建议通过环境变量控制开关（例如 `DEPLOY_OSS=1` 时再上传）。
+- `debug` 默认关闭。开启后会在结束时额外输出每个关键步骤花了多久，方便排查慢点和卡点。
 - `fancy` 默认 `true`，TTY 终端下会显示实时动效进度（速度、预计剩余、并发、当前文件）。
 - `failOnError` 默认 `true`，上传有失败会抛错，适合 CI 场景保证发布质量。
 - `manifest` 默认关闭。开启后会在构建目录生成并上传 `oss-manifest.json`。

package/dist/index.d.ts

@@ -1,9 +1,10 @@
-import oss from 'ali-oss';
 import { Plugin } from 'vite';
+import oss from 'ali-oss';
 
 interface ManifestOption {
     fileName?: string;
 }
+type ManifestConfig = boolean | ManifestOption | undefined;
 interface vitePluginDeployOssOption extends Omit<oss.Options, 'accessKeyId' | 'accessKeySecret' | 'bucket' | 'region'> {
     configBase?: string;
     accessKeyId: string;
@@ -17,14 +18,42 @@ interface vitePluginDeployOssOption extends Omit<oss.Options, 'accessKeyId' | 'a
     autoDelete?: boolean;
     skip?: string | string[];
     open?: boolean;
+    debug?: boolean;
     fancy?: boolean;
     noCache?: boolean;
     failOnError?: boolean;
     concurrency?: number;
     retryTimes?: number;
     multipartThreshold?: number;
-    manifest?: boolean | ManifestOption;
+    manifest?: ManifestConfig;
+}
+interface UploadResult {
+    success: boolean;
+    file: string;
+    relativeFilePath: string;
+    name: string;
+    size: number;
+    retries: number;
+    error?: Error;
+}
+interface UploadTask {
+    filePath: string;
+    relativeFilePath: string;
+    name: string;
+    size: number;
+    cacheControl?: string;
 }
+interface ManifestFileItem {
+    file: string;
+    key: string;
+    url: string;
+    md5: string;
+}
+interface ManifestPayload {
+    version: number;
+    files: ManifestFileItem[];
+}
+
 declare function vitePluginDeployOss(option: vitePluginDeployOssOption): Plugin;
 
-export { vitePluginDeployOss as default, type vitePluginDeployOssOption };
+export { type ManifestConfig, type ManifestFileItem, type ManifestOption, type ManifestPayload, type UploadResult, type UploadTask, vitePluginDeployOss as default, type vitePluginDeployOssOption };

package/dist/index.js

@@ -1,24 +1,27 @@
 // src/index.ts
 import oss from "ali-oss";
-import chalk from "chalk";
+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";
+import { normalizePath } from "vite";
+
+// src/utils/file.ts
 import { createHash } from "crypto";
 import { createReadStream } from "fs";
-import { mkdir, readdir, rm, stat, unlink, writeFile } from "fs/promises";
-import { dirname, resolve } from "path";
-import ora from "ora";
-import { normalizePath } from "vite";
+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((resolve2, reject) => {
+  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", () => resolve2(hash.digest("hex")));
+    stream.on("end", () => resolvePromise(hash.digest("hex")));
   });
 };
-var GARBAGE_FILE_REGEX = /(?:Thumbs\.db|\.DS_Store)$/i;
-var DEFAULT_MANIFEST_FILE_NAME = "oss-manifest.json";
 var removeEmptyDirectories = async (rootDir) => {
   const deletedDirectories = [];
   const visit = async (dirPath) => {
@@ -43,9 +46,53 @@ var removeEmptyDirectories = async (rootDir) => {
   await visit(resolve(rootDir));
   return deletedDirectories;
 };
-var normalizeObjectKey = (targetDir, relativeFilePath) => normalizePath(`${targetDir}/${relativeFilePath}`).replace(/\/{2,}/g, "/").replace(/^\/+/, "");
+
+// 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 = normalizePath(fileName || DEFAULT_MANIFEST_FILE_NAME).replace(/^\/+/, "").replace(/\/{2,}/g, "/");
+  const normalized = normalizePathSegments(fileName || DEFAULT_MANIFEST_FILE_NAME);
   return normalized || DEFAULT_MANIFEST_FILE_NAME;
 };
 var resolveManifestFileName = (manifest) => {
@@ -53,46 +100,16 @@ var resolveManifestFileName = (manifest) => {
   if (manifest === true) return DEFAULT_MANIFEST_FILE_NAME;
   return normalizeManifestFileName(manifest.fileName);
 };
-var normalizeUrlBase = (base) => {
-  const normalized = base.replace(/\\/g, "/");
-  const protocolSeparatorIndex = normalized.indexOf("://");
-  if (protocolSeparatorIndex >= 0) {
-    const pathIndex = normalized.indexOf("/", protocolSeparatorIndex + 3);
-    if (pathIndex < 0) return normalized;
-    return `${normalized.slice(0, pathIndex)}${normalized.slice(pathIndex).replace(/\/{2,}/g, "/")}`;
-  }
-  if (normalized.startsWith("//")) {
-    const pathIndex = normalized.indexOf("/", 2);
-    if (pathIndex < 0) return normalized;
-    return `${normalized.slice(0, pathIndex)}${normalized.slice(pathIndex).replace(/\/{2,}/g, "/")}`;
-  }
-  return normalized.replace(/\/{2,}/g, "/");
-};
-var encodeUrlPath = (path) => encodeURI(path.replace(/^\/+/, ""));
-var joinUrlPath = (base, path) => `${normalizeUrlBase(base).replace(/\/+$/, "")}/${encodeUrlPath(path)}`;
+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;
 };
-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
-  };
-};
+
+// 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"];
@@ -113,24 +130,110 @@ var formatDuration = (seconds) => {
   if (mins === 0) return `${secs}s`;
   return `${mins}m${String(secs).padStart(2, "0")}s`;
 };
-var trimMiddle = (text, maxLength) => {
-  if (text.length <= maxLength) return text;
-  if (maxLength <= 10) return text.slice(0, maxLength);
-  const leftLength = Math.floor((maxLength - 3) / 2);
-  const rightLength = maxLength - 3 - leftLength;
-  return `${text.slice(0, leftLength)}...${text.slice(-rightLength)}`;
+
+// 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 buildCapsuleBar = (ratio, width = 30) => {
-  const safeRatio = Math.max(0, Math.min(1, ratio));
+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 "";
-  if (safeRatio >= 1) {
-    return chalk.green("\u2588".repeat(width));
+  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;
   }
-  const pointerIndex = Math.min(width - 1, Math.floor(width * safeRatio));
-  const done = pointerIndex > 0 ? chalk.green("\u2588".repeat(pointerIndex)) : "";
-  const pointer = chalk.cyanBright("\u25B8");
-  const pending = pointerIndex < width - 1 ? chalk.gray("\u2591".repeat(width - pointerIndex - 1)) : "";
-  return `${done}${pointer}${pending}`;
+};
+
+// src/index.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
+  };
 };
 function vitePluginDeployOss(option) {
   const {
@@ -146,6 +249,7 @@ function vitePluginDeployOss(option) {
     autoDelete = false,
     alias,
     open = true,
+    debug = false,
     fancy = true,
     noCache = false,
     failOnError = true,
@@ -155,12 +259,15 @@ function vitePluginDeployOss(option) {
     manifest = false,
     ...props
   } = option || {};
+  const normalizedUploadDir = normalizePathSegments(uploadDir);
+  const normalizedConfigBase = configBase ? ensureTrailingSlash(normalizeUrlLikeBase(configBase)) : void 0;
+  const normalizedAlias = alias ? normalizeUrlLikeBase(alias) : void 0;
   let buildFailed = false;
   let upload = false;
-  let outDir = normalizePath(resolve("dist"));
+  let outDir = normalizePath(resolve2("dist"));
   let resolvedConfig = null;
   const useInteractiveOutput = fancy && Boolean(process.stdout?.isTTY) && Boolean(process.stderr?.isTTY) && !process.env.CI;
-  const clearScreen = () => {
+  const clearViewport = () => {
     if (!useInteractiveOutput) return;
     process.stdout.write("\x1B[2J\x1B[0f");
   };
@@ -173,8 +280,7 @@ function vitePluginDeployOss(option) {
     if (!uploadDir) errors.push("uploadDir is required");
     if (!Number.isInteger(retryTimes) || retryTimes < 1) errors.push("retryTimes must be >= 1");
     if (!Number.isInteger(concurrency) || concurrency < 1) errors.push("concurrency must be >= 1");
-    if (!Number.isFinite(multipartThreshold) || multipartThreshold <= 0)
-      errors.push("multipartThreshold must be > 0");
+    if (!Number.isFinite(multipartThreshold) || multipartThreshold <= 0) errors.push("multipartThreshold must be > 0");
     return errors;
   };
   const uploadSingleTask = async (client, task) => uploadFileWithRetry(client, task, false);
@@ -202,7 +308,9 @@ function vitePluginDeployOss(option) {
             try {
               await unlink(task.filePath);
             } catch (error) {
-              console.warn(`${chalk.yellow("\u26A0")} \u5220\u9664\u672C\u5730\u6587\u4EF6\u5931\u8D25: ${task.filePath}`);
+              console.warn(
+                `${getLogSymbol("warning")} \u5220\u9664\u672C\u5730\u6587\u4EF6\u5931\u8D25: ${truncateTerminalText(task.relativeFilePath, 18)}`
+              );
             }
           }
           return {
@@ -219,9 +327,8 @@ function vitePluginDeployOss(option) {
       } catch (error) {
         if (attempt === maxRetries) {
           if (!silentLogs) {
-            console.log(
-              `${chalk.red("\u2717")} ${task.filePath} => ${error instanceof Error ? error.message : String(error)}`
-            );
+            const reason = error instanceof Error ? error.message : String(error);
+            console.log(`${getLogSymbol("danger")} ${truncateTerminalText(task.relativeFilePath, 18)}  ${reason}`);
           }
           return {
             success: false,
@@ -234,9 +341,11 @@ function vitePluginDeployOss(option) {
           };
         } else {
           if (!silentLogs) {
-            console.log(`${chalk.yellow("\u26A0")} ${task.filePath} \u4E0A\u4F20\u5931\u8D25\uFF0C\u6B63\u5728\u91CD\u8BD5 (${attempt}/${maxRetries})...`);
+            console.log(
+              `${getLogSymbol("warning")} ${truncateTerminalText(task.relativeFilePath, 18)}  \u6B63\u5728\u91CD\u8BD5 (${attempt}/${maxRetries})`
+            );
           }
-          await new Promise((resolve2) => setTimeout(resolve2, 1e3 * attempt));
+          await new Promise((resolve3) => setTimeout(resolve3, 1e3 * attempt));
         }
       }
     }
@@ -252,16 +361,18 @@ function vitePluginDeployOss(option) {
   };
   const uploadFilesInBatches = async (client, files, windowSize = concurrency) => {
     const results = [];
+    const debugEntries = [];
     const totalFiles = files.length;
     const tasks = [];
     let completed = 0;
     let failed = 0;
     let uploadedBytes = 0;
     let retries = 0;
+    const taskPrepareStartedAt = Date.now();
     const taskCandidates = await Promise.all(
       files.map(async (relativeFilePath) => {
-        const filePath = normalizePath(resolve(outDir, relativeFilePath));
-        const name = normalizeObjectKey(uploadDir, relativeFilePath);
+        const filePath = normalizePath(resolve2(outDir, relativeFilePath));
+        const name = normalizeObjectKey(normalizedUploadDir, relativeFilePath);
         try {
           const fileStats = await stat(filePath);
           return { task: { filePath, relativeFilePath, name, size: fileStats.size } };
@@ -270,6 +381,11 @@ function vitePluginDeployOss(option) {
         }
       })
     );
+    debugEntries.push({
+      label: "\u751F\u6210\u4E0A\u4F20\u4EFB\u52A1",
+      durationMs: Date.now() - taskPrepareStartedAt,
+      detail: `${files.length} \u4E2A\u6587\u4EF6`
+    });
     for (const candidate of taskCandidates) {
       if (candidate.task) {
         tasks.push(candidate.task);
@@ -289,47 +405,58 @@ function vitePluginDeployOss(option) {
     }
     const totalBytes = tasks.reduce((sum, task) => sum + task.size, 0);
     const startAt = Date.now();
-    const activeFiles = /* @__PURE__ */ new Set();
     const safeWindowSize = Math.max(1, Math.min(windowSize, tasks.length || 1));
     const silentLogs = Boolean(useInteractiveOutput);
-    const spinner = useInteractiveOutput ? ora({ text: "\u51C6\u5907\u4E0A\u4F20...", spinner: "dots12" }).start() : null;
-    const reportEvery = Math.max(1, Math.ceil(totalFiles / 10));
+    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 progressRatio = totalFiles > 0 ? completed / totalFiles : 1;
-      const percentage = Math.round(progressRatio * 100);
       const elapsedSeconds = (Date.now() - startAt) / 1e3;
       const speed = elapsedSeconds > 0 ? uploadedBytes / elapsedSeconds : 0;
-      const etaSeconds = speed > 0 ? Math.max(0, (totalBytes - uploadedBytes) / speed) : 0;
-      const activeList = Array.from(activeFiles);
-      const currentFile = activeList.length > 0 ? trimMiddle(activeList[activeList.length - 1], 86) : "-";
-      if (!spinner) {
+      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(
-            `${chalk.gray("\u8FDB\u5EA6:")} ${completed}/${totalFiles} (${percentage}%) | ${chalk.gray("\u6570\u636E:")} ${formatBytes(uploadedBytes)}/${formatBytes(totalBytes)} | ${chalk.gray("\u901F\u5EA6:")} ${formatBytes(speed)}/s`
+            `${chalk3.gray("\u4E0A\u4F20\u8FDB\u5EA6")} ${renderInlineStats([
+              chalk3.bold(`${completed}/${totalFiles}`),
+              `${percentage}%`,
+              `${formatBytes(uploadedBytes)}/${formatBytes(totalBytes)}`,
+              `${formatBytes(speed)}/s`
+            ])}`
           );
           lastReportedCompleted = completed;
         }
         return;
       }
-      const bar = buildCapsuleBar(progressRatio);
-      const warnLine = retries > 0 || failed > 0 ? `
-${chalk.yellow("\u91CD\u8BD5")}: ${retries}  ${chalk.yellow("\u5931\u8D25")}: ${failed}` : "";
-      spinner.text = [
-        `${chalk.cyan("\u6B63\u5728\u4E0A\u4F20:")} ${chalk.white(currentFile)}`,
-        `${bar} ${chalk.bold(`${percentage}%`)} ${chalk.gray(`(${completed}/${totalFiles})`)} ${chalk.gray("|")} ${chalk.blue(formatBytes(uploadedBytes))}/${chalk.blue(formatBytes(totalBytes))} ${chalk.gray("|")} ${chalk.magenta(`${formatBytes(speed)}/s`)} ${chalk.gray("|")} \u9884\u8BA1 ${chalk.yellow(formatDuration(etaSeconds))}`
-      ].join("\n");
-      spinner.text += warnLine;
+      progressBar.update(completed, {
+        speed: chalk3.magenta(formatBytes(speed)),
+        elapsed: formatDuration(elapsedSeconds).replace(/s$/, "")
+      });
     };
-    const refreshTimer = spinner ? setInterval(updateProgress, 120) : null;
+    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];
-        activeFiles.add(task.name);
         updateProgress();
         const result = await uploadFileWithRetry(client, task, silentLogs);
         completed++;
@@ -340,7 +467,6 @@ ${chalk.yellow("\u91CD\u8BD5")}: ${retries}  ${chalk.yellow("\u5931\u8D25")}: ${
           failed++;
         }
         results.push(result);
-        activeFiles.delete(task.name);
         updateProgress();
       }
     };
@@ -350,18 +476,23 @@ ${chalk.yellow("\u91CD\u8BD5")}: ${retries}  ${chalk.yellow("\u5931\u8D25")}: ${
     } finally {
       if (refreshTimer) clearInterval(refreshTimer);
     }
-    if (spinner) {
+    if (progressBar) {
       const elapsedSeconds = (Date.now() - startAt) / 1e3;
-      const successCount = results.filter((item) => item.success).length;
       const speed = elapsedSeconds > 0 ? uploadedBytes / elapsedSeconds : 0;
-      spinner.succeed(
-        `${chalk.green("\u4E0A\u4F20\u6210\u529F")} ${successCount} \u4E2A\u6587\u4EF6\u3002
-${buildCapsuleBar(1)} 100% (${totalFiles}/${totalFiles}) ${chalk.gray("|")} \u901F\u5EA6 ${chalk.magenta(`${formatBytes(speed)}/s`)} ${chalk.gray("|")} \u8017\u65F6 ${chalk.yellow(formatDuration(elapsedSeconds))}`
-      );
+      progressBar.update(totalFiles, {
+        speed: chalk3.magenta(formatBytes(speed)),
+        elapsed: formatDuration(elapsedSeconds).replace(/s$/, "")
+      });
+      progressBar.stop();
     } else {
-      console.log(`${chalk.green("\u2714")} \u6240\u6709\u6587\u4EF6\u4E0A\u4F20\u5B8C\u6210 (${totalFiles}/${totalFiles})`);
+      console.log(`${getLogSymbol("success")} \u6240\u6709\u6587\u4EF6\u4E0A\u4F20\u5B8C\u6210 (${totalFiles}/${totalFiles})`);
     }
-    return results;
+    debugEntries.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 };
   };
   return {
     name: "vite-plugin-deploy-oss",
@@ -372,20 +503,19 @@ ${buildCapsuleBar(1)} 100% (${totalFiles}/${totalFiles}) ${chalk.gray("|")} \u90
     },
     config(config) {
       if (!open || buildFailed) return;
-      clearScreen();
       const validationErrors = validateOptions();
       if (validationErrors.length > 0) {
-        console.log(`${chalk.red("\u2717 \u914D\u7F6E\u9519\u8BEF:")}
+        console.log(`${chalk3.red("\u2717 \u914D\u7F6E\u9519\u8BEF:")}
 ${validationErrors.map((err) => `  - ${err}`).join("\n")}`);
         return;
       }
       upload = true;
-      config.base = configBase || config.base;
+      config.base = normalizedConfigBase || config.base;
       return config;
     },
     configResolved(config) {
       resolvedConfig = config;
-      outDir = normalizePath(resolve(config.root, config.build.outDir));
+      outDir = normalizePath(resolve2(config.root, config.build.outDir));
     },
     closeBundle: {
       sequential: true,
@@ -393,80 +523,80 @@ ${validationErrors.map((err) => `  - ${err}`).join("\n")}`);
       async handler() {
         if (!open || !upload || buildFailed || !resolvedConfig) return;
         const startTime = Date.now();
+        const debugEntries = [];
         const client = new oss({ region, accessKeyId, accessKeySecret, secure, bucket, ...props });
         const manifestFileName = resolveManifestFileName(manifest);
+        const collectFilesStartedAt = Date.now();
         const files = globSync("**/*", {
           cwd: outDir,
           nodir: true,
           ignore: Array.isArray(skip) ? skip : [skip]
         }).map((file) => normalizePath(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(`${chalk.yellow("\u26A0 \u6CA1\u6709\u627E\u5230\u9700\u8981\u4E0A\u4F20\u7684\u6587\u4EF6")}`);
+          console.log(`${getLogSymbol("warning")} \u6CA1\u6709\u627E\u5230\u9700\u8981\u4E0A\u4F20\u7684\u6587\u4EF6`);
           return;
         }
-        clearScreen();
-        console.log(chalk.cyan(`
-\u{1F680} OSS \u90E8\u7F72\u5F00\u59CB
-`));
-        console.log(`${chalk.gray("Bucket:")}   ${chalk.green(bucket)}`);
-        console.log(`${chalk.gray("Region:")}   ${chalk.green(region)}`);
-        console.log(`${chalk.gray("Source:")}   ${chalk.yellow(outDir)}`);
-        console.log(`${chalk.gray("Target:")}   ${chalk.yellow(uploadDir)}`);
-        if (alias) console.log(`${chalk.gray("Alias:")}    ${chalk.green(alias)}`);
-        console.log(`${chalk.gray("Files:")}    ${chalk.blue(files.length)}
-`);
+        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(outDir, 30)}`)
+              }
+            ],
+            "info"
+          )
+        );
         try {
-          const results = await uploadFilesInBatches(client, files, concurrency);
+          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 duration = durationSeconds.toFixed(2);
           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;
-          clearScreen();
-          console.log("\n" + chalk.gray("\u2500".repeat(40)) + "\n");
-          if (failedCount === 0) {
-            console.log(`${chalk.green("\u{1F389} \u90E8\u7F72\u6210\u529F!")}`);
-          } else {
-            console.log(`${chalk.yellow("\u26A0 \u90E8\u7F72\u5B8C\u6210\u4F46\u5B58\u5728\u9519\u8BEF")}`);
-          }
-          console.log(`
-${chalk.gray("\u7EDF\u8BA1:")}`);
-          console.log(` ${chalk.green("\u2714")} \u6210\u529F: ${chalk.bold(successCount)}`);
-          if (failedCount > 0) {
-            console.log(` ${chalk.red("\u2717")} \u5931\u8D25: ${chalk.bold(failedCount)}`);
-          }
-          console.log(` ${chalk.cyan("\u21C4")} \u91CD\u8BD5: ${chalk.bold(retryCount)}`);
-          console.log(` ${chalk.blue("\u{1F4E6}")} \u6570\u636E: ${chalk.bold(formatBytes(uploadedBytes))}`);
-          console.log(` ${chalk.magenta("\u26A1")} \u5E73\u5747\u901F\u5EA6: ${chalk.bold(`${formatBytes(avgSpeed)}/s`)}`);
-          console.log(` ${chalk.blue("\u23F1")} \u8017\u65F6: ${chalk.bold(duration)}s`);
-          console.log("");
-          if (failedCount > 0) {
-            const failedItems = results.filter((result) => !result.success);
-            const previewCount = Math.min(5, failedItems.length);
-            console.log(chalk.red("\u5931\u8D25\u660E\u7EC6:"));
-            for (let i = 0; i < previewCount; i++) {
-              const item = failedItems[i];
-              const reason = item.error?.message || "unknown error";
-              console.log(` ${chalk.red("\u2022")} ${item.name} => ${reason}`);
-            }
-            if (failedItems.length > previewCount) {
-              console.log(chalk.gray(` ... \u8FD8\u6709 ${failedItems.length - previewCount} \u4E2A\u5931\u8D25\u6587\u4EF6`));
-            }
-            console.log("");
-          }
+          let manifestSummary = null;
           if (manifestFileName) {
             const manifestRelativeFilePath = manifestFileName;
-            const manifestFilePath = normalizePath(resolve(outDir, manifestRelativeFilePath));
-            const manifestObjectKey = normalizeObjectKey(uploadDir, manifestRelativeFilePath);
+            const manifestFilePath = normalizePath(resolve2(outDir, manifestRelativeFilePath));
+            const manifestObjectKey = normalizeObjectKey(normalizedUploadDir, manifestRelativeFilePath);
+            const manifestStartedAt = Date.now();
             await mkdir(dirname(manifestFilePath), { recursive: true });
             await writeFile(
               manifestFilePath,
-              JSON.stringify(await createManifestPayload(results, configBase, alias), null, 2),
+              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,
@@ -477,30 +607,94 @@ ${chalk.gray("\u7EDF\u8BA1:")}`);
             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
+              });
+            }
             const manifestUrl = resolveUploadedFileUrl(
               manifestRelativeFilePath,
               manifestObjectKey,
-              configBase,
-              alias
+              normalizedConfigBase,
+              normalizedAlias
             );
-            console.log(chalk.cyan("Manifest:"));
-            console.log(` ${chalk.gray("File:")}   ${chalk.yellow(manifestFilePath)}`);
-            console.log(` ${chalk.gray("Target:")} ${chalk.yellow(manifestObjectKey)}`);
-            console.log(` ${chalk.gray("URL:")}    ${chalk.green(manifestUrl)}`);
-            console.log("");
+            manifestSummary = truncateTerminalText(manifestUrl || manifestObjectKey, 20);
           }
           try {
+            const cleanupStartedAt = Date.now();
             await removeEmptyDirectories(outDir);
+            if (debug) {
+              debugEntries.push({
+                label: "\u6E05\u7406\u7A7A\u76EE\u5F55",
+                durationMs: Date.now() - cleanupStartedAt
+              });
+            }
           } catch (error) {
-            console.warn(`${chalk.yellow("\u26A0 \u6E05\u7406\u7A7A\u76EE\u5F55\u5931\u8D25:")} ${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`);
           }
         } catch (error) {
           console.log(`
-${chalk.red("\u274C \u4E0A\u4F20\u8FC7\u7A0B\u4E2D\u53D1\u751F\u9519\u8BEF:")} ${error}
+${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));
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-deploy-oss",
-  "version": "3.2.1",
+  "version": "3.3.1",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",
@@ -33,6 +33,7 @@
   "devDependencies": {
     "@types/ali-oss": "^6.23.3",
     "@types/node": "^22.19.13",
+    "prettier": "3.8.1",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3"
   },
@@ -40,16 +41,23 @@
     "vite": "^6.0.3 || ^7 || ^8"
   },
   "dependencies": {
+    "@types/cli-progress": "^3.11.6",
     "ali-oss": "^6.23.0",
     "chalk": "^5.6.2",
+    "cli-progress": "^3.12.0",
+    "cli-truncate": "^5.2.0",
     "glob": "^13.0.6",
-    "ora": "^9.3.0"
+    "log-symbols": "^7.0.1",
+    "string-width": "^8.2.0"
   },
   "scripts": {
     "build": "tsup",
     "typecheck": "tsc -p tsconfig.json",
     "pack": "pnpm run build && pnpm pack",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
     "build:test": "cd playground && vite build",
-    "build:test:deploy": "cd playground && vite build --mode deploy"
+    "build:test:deploy": "cd playground && vite build --mode deploy",
+    "build:test:debug": "cd playground && vite build --mode deploy-debug"
   }
 }