vite-plugin-deploy-oss 3.4.2 → 3.5.0

package/dist/index.js

@@ -1,502 +1,20 @@
-// src/index.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";
-import { normalizePath } from "vite";
-
-// 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;
-  }
-};
+import {
+  deployOss,
+  ensureTrailingSlash,
+  normalizeSlash,
+  normalizeUrlLikeBase
+} from "./chunk-6D7VVVXN.js";
 
 // 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
-  };
-};
+import { resolve } from "path";
+var defineDeployConfig = (option) => option;
 function vitePluginDeployOss(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,
-    ...props
-  } = option || {};
-  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 { open = true, configBase } = option || {};
   let buildFailed = false;
   let upload = false;
-  let outDir = normalizePath(resolve2("dist"));
+  let outDir = normalizeSlash(resolve("dist"));
   let resolvedConfig = null;
-  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 validateOptions = () => {
-    const errors = [];
-    if (!accessKeyId) errors.push("accessKeyId is required");
-    if (!accessKeySecret) errors.push("accessKeySecret is required");
-    if (!bucket) errors.push("bucket is required");
-    if (!region) errors.push("region is required");
-    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");
-    return errors;
-  };
-  const uploadSingleTask = async (client, task) => uploadFileWithRetry(client, task, false);
-  const uploadFileWithRetry = async (client, 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 client.multipartUpload(task.name, task.filePath, {
-          timeout: 6e5,
-          partSize: 1024 * 1024,
-          parallel: Math.max(1, Math.min(concurrency, 4)),
-          headers
-        }) : await client.put(task.name, task.filePath, {
-          timeout: 6e5,
-          headers
-        });
-        if (result.res.status === 200) {
-          if (effectiveAutoDelete) {
-            try {
-              await unlink(task.filePath);
-            } catch (error) {
-              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
-          };
-        } else {
-          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
-          };
-        } else {
-          if (!silentLogs) {
-            console.log(
-              `${getLogSymbol("warning")} ${truncateTerminalText(task.relativeFilePath, 18)}  \u6B63\u5728\u91CD\u8BD5 (${attempt}/${maxRetries})`
-            );
-          }
-          await new Promise((resolve3) => setTimeout(resolve3, 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 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(resolve2(outDir, 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 };
-        }
-      })
-    );
-    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);
-      } 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;
-        }
-        return;
-      }
-      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(client, 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})`);
-    }
-    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 };
-  };
+  const normalizedConfigBase = configBase ? ensureTrailingSlash(normalizeUrlLikeBase(configBase)) : void 0;
   return {
     name: "vite-plugin-deploy-oss",
     apply: "build",
@@ -506,204 +24,30 @@ function vitePluginDeployOss(option) {
     },
     config(config) {
       if (!open || buildFailed) return;
-      const validationErrors = validateOptions();
-      if (validationErrors.length > 0) {
-        throw new Error(`vite-plugin-deploy-oss \u914D\u7F6E\u9519\u8BEF:
-${validationErrors.map((err) => `  - ${err}`).join("\n")}`);
-      }
       upload = true;
       config.base = normalizedConfigBase || config.base;
       return config;
     },
     configResolved(config) {
       resolvedConfig = config;
-      outDir = normalizePath(resolve2(config.root, config.build.outDir));
+      outDir = normalizeSlash(resolve(config.root, config.build.outDir));
     },
     closeBundle: {
       sequential: true,
       order: "post",
       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 collectFilesStartedAt = Date.now();
-        const files = globSync("**/*", {
-          cwd: outDir,
-          nodir: true,
-          ignore: effectiveSkip
-        }).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`
+        await deployOss({
+          ...option,
+          configBase: normalizedConfigBase,
+          outDir
         });
-        if (files.length === 0) {
-          console.log(`${getLogSymbol("warning")} \u6CA1\u6709\u627E\u5230\u9700\u8981\u4E0A\u4F20\u7684\u6587\u4EF6`);
-          return;
-        }
-        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 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;
-          if (manifestFileName) {
-            const manifestRelativeFilePath = manifestFileName;
-            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, 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
-              });
-            }
-            const manifestUrl = resolveUploadedFileUrl(
-              manifestRelativeFilePath,
-              manifestObjectKey,
-              normalizedConfigBase,
-              normalizedAlias
-            );
-            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(`${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(`
-${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));
-          }
-        }
       }
     }
   };
 }
 export {
-  vitePluginDeployOss as default
+  vitePluginDeployOss as default,
+  defineDeployConfig,
+  deployOss
 };