vite-plugin-deploy-ftp 1.2.2 → 3.0.0

package/dist/index.js

@@ -1,147 +1,459 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+// src/index.ts
+import { checkbox, select } from "@inquirer/prompts";
+import archiver from "archiver";
+import { Client } from "basic-ftp";
+import chalk from "chalk";
+import dayjs from "dayjs";
+import fs from "fs";
+import { stat } from "fs/promises";
+import os from "os";
+import path from "path";
+import ora from "ora";
+import { normalizePath } from "vite";
+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`;
+};
+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)}`;
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+var buildCapsuleBar = (ratio, width = 30) => {
+  const safeRatio = Math.max(0, Math.min(1, ratio));
+  if (width <= 0) return "";
+  if (safeRatio >= 1) {
+    return chalk.green("\u2588".repeat(width));
   }
-  return to;
+  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}`;
+};
+var normalizeRemotePath = (targetDir, relativeFilePath) => {
+  const joined = normalizePath(`${targetDir}/${relativeFilePath}`).replace(/\/{2,}/g, "/");
+  if (targetDir.startsWith("/")) return joined.startsWith("/") ? joined : `/${joined}`;
+  return joined.replace(/^\/+/, "");
+};
+var sleep = async (ms) => {
+  await new Promise((resolve) => setTimeout(resolve, ms));
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  default: () => vitePluginDeployFtp
-});
-module.exports = __toCommonJS(index_exports);
-var import_prompts = require("@inquirer/prompts");
-var import_archiver = __toESM(require("archiver"));
-var import_basic_ftp = require("basic-ftp");
-var import_chalk = __toESM(require("chalk"));
-var import_dayjs = __toESM(require("dayjs"));
-var import_node_fs = __toESM(require("fs"));
-var import_node_os = __toESM(require("os"));
-var import_node_path = __toESM(require("path"));
-var import_ora = __toESM(require("ora"));
-var import_vite = require("vite");
 function vitePluginDeployFtp(option) {
+  const safeOption = option || {};
   const {
     open = true,
-    uploadPath,
+    uploadPath = "",
     singleBack = false,
     singleBackFiles = ["index.html"],
     showBackFile = false,
     maxRetries = 3,
     retryDelay = 1e3,
-    autoUpload = false
-  } = option || {};
-  const isMultiFtp = "ftps" in option;
-  const ftpConfigs = isMultiFtp ? option.ftps : [{ ...option, name: option.name || option.alias || option.host }];
-  const defaultFtp = isMultiFtp ? option.defaultFtp : void 0;
-  if (!uploadPath || isMultiFtp && (!option.ftps || option.ftps.length === 0)) {
+    autoUpload = false,
+    fancy = true,
+    failOnError = true,
+    concurrency = 1
+  } = safeOption;
+  const isMultiFtp = "ftps" in safeOption;
+  const ftpConfigs = isMultiFtp ? safeOption.ftps || [] : [{ ...safeOption, name: safeOption.name || safeOption.alias || safeOption.host }];
+  const defaultFtp = isMultiFtp ? safeOption.defaultFtp : void 0;
+  let outDir = normalizePath(path.resolve("dist"));
+  let upload = false;
+  let buildFailed = false;
+  let resolvedConfig = null;
+  const useInteractiveOutput = fancy && Boolean(process.stdout?.isTTY) && Boolean(process.stderr?.isTTY) && !process.env.CI;
+  const clearScreen = () => {
+    if (!useInteractiveOutput) return;
+    process.stdout.write("\x1B[2J\x1B[0f");
+  };
+  const validateOptions = () => {
+    const errors = [];
+    if (!uploadPath) errors.push("uploadPath is required");
+    if (!Number.isInteger(maxRetries) || maxRetries < 1) errors.push("maxRetries must be >= 1");
+    if (!Number.isFinite(retryDelay) || retryDelay < 0) errors.push("retryDelay must be >= 0");
+    if (!Number.isInteger(concurrency) || concurrency < 1) errors.push("concurrency must be >= 1");
+    if (isMultiFtp) {
+      if (!ftpConfigs.length) {
+        errors.push("ftps is required and must not be empty");
+      }
+      if (defaultFtp && !ftpConfigs.some((ftp) => ftp.name === defaultFtp)) {
+        errors.push(`defaultFtp "${defaultFtp}" does not match any ftp.name`);
+      }
+      const validConfigCount = ftpConfigs.filter(validateFtpConfig).length;
+      if (validConfigCount === 0) {
+        errors.push("at least one ftp config requires host, user and password");
+      }
+    } else {
+      const singleConfig = ftpConfigs[0];
+      if (!singleConfig?.host) errors.push("host is required");
+      if (!singleConfig?.user) errors.push("user is required");
+      if (!singleConfig?.password) errors.push("password is required");
+    }
+    return errors;
+  };
+  const uploadFileWithRetry = async (task, context) => {
+    for (let attempt = 1; attempt <= context.maxRetries; attempt++) {
+      try {
+        await context.ensureConnected();
+        const remoteDir = normalizePath(path.posix.dirname(task.remotePath));
+        if (remoteDir && remoteDir !== "." && !context.ensuredDirs.has(remoteDir)) {
+          await context.client.ensureDir(remoteDir);
+          context.ensuredDirs.add(remoteDir);
+        }
+        await context.client.uploadFrom(task.filePath, path.posix.basename(task.remotePath));
+        return {
+          success: true,
+          file: task.filePath,
+          name: task.remotePath,
+          size: task.size,
+          retries: attempt - 1
+        };
+      } catch (error) {
+        context.markDisconnected();
+        try {
+          context.client.close();
+        } catch {
+        }
+        if (attempt === context.maxRetries) {
+          if (!context.silentLogs) {
+            console.log(
+              `${chalk.red("\u2717")} ${task.filePath} => ${error instanceof Error ? error.message : String(error)}`
+            );
+          }
+          return {
+            success: false,
+            file: task.filePath,
+            name: task.remotePath,
+            size: task.size,
+            retries: attempt - 1,
+            error
+          };
+        }
+        if (!context.silentLogs) {
+          console.log(
+            `${chalk.yellow("\u26A0")} ${task.filePath} \u4E0A\u4F20\u5931\u8D25\uFF0C\u6B63\u5728\u91CD\u8BD5 (${attempt}/${context.maxRetries})...`
+          );
+        }
+        await sleep(context.retryDelay * attempt);
+      }
+    }
     return {
-      name: "vite-plugin-deploy-ftp",
-      apply: "build",
-      enforce: "post",
-      configResolved() {
-      },
-      closeBundle: { sequential: true, order: "post", async handler() {
-      } }
+      success: false,
+      file: task.filePath,
+      name: task.remotePath,
+      size: task.size,
+      retries: context.maxRetries,
+      error: new Error("Max retries exceeded")
     };
-  }
-  let outDir = "dist";
-  let buildFailed = false;
-  return {
-    name: "vite-plugin-deploy-ftp",
-    apply: "build",
-    enforce: "post",
-    buildEnd(error) {
-      if (error) buildFailed = true;
-    },
-    configResolved(config) {
-      outDir = config.build?.outDir || "dist";
-    },
-    closeBundle: {
-      sequential: true,
-      order: "post",
-      async handler() {
-        if (!open || buildFailed) return;
+  };
+  const uploadFilesInBatches = async (connectConfig, files, targetDir, windowSize = concurrency) => {
+    const results = [];
+    const totalFiles = files.length;
+    const tasks = [];
+    let completed = 0;
+    let failed = 0;
+    let uploadedBytes = 0;
+    let retries = 0;
+    const taskCandidates = await Promise.all(
+      files.map(async (relativeFilePath) => {
+        const filePath = normalizePath(path.resolve(outDir, relativeFilePath));
+        const remotePath = normalizeRemotePath(targetDir, relativeFilePath);
         try {
-          process.stdout.write("\x1B[2J\x1B[0f");
-          await deployToFtp();
+          const fileStats = await stat(filePath);
+          return { task: { filePath, remotePath, size: fileStats.size } };
         } catch (error) {
-          console.error(import_chalk.default.red("\u274C FTP \u90E8\u7F72\u5931\u8D25:"), error instanceof Error ? error.message : error);
-          throw error;
+          return { task: null, error, filePath, remotePath };
+        }
+      })
+    );
+    for (const candidate of taskCandidates) {
+      if (candidate.task) {
+        tasks.push(candidate.task);
+      } else {
+        failed++;
+        completed++;
+        results.push({
+          success: false,
+          file: candidate.filePath,
+          name: candidate.remotePath,
+          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 activeFiles = /* @__PURE__ */ new Set();
+    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));
+    let lastReportedCompleted = -1;
+    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 (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`
+          );
+          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;
+    };
+    const refreshTimer = spinner ? setInterval(updateProgress, 120) : null;
+    let currentIndex = 0;
+    const worker = async () => {
+      const client = new Client();
+      const ensuredDirs = /* @__PURE__ */ new Set();
+      let connected = false;
+      const ensureConnected = async () => {
+        if (connected) return;
+        await connectWithRetry(client, connectConfig, maxRetries, retryDelay, true);
+        connected = true;
+      };
+      const markDisconnected = () => {
+        connected = false;
+        ensuredDirs.clear();
+      };
+      try {
+        while (true) {
+          const index = currentIndex++;
+          if (index >= tasks.length) return;
+          const task = tasks[index];
+          activeFiles.add(task.remotePath);
+          updateProgress();
+          const result = await uploadFileWithRetry(task, {
+            client,
+            ensuredDirs,
+            ensureConnected,
+            markDisconnected,
+            silentLogs,
+            maxRetries,
+            retryDelay
+          });
+          completed++;
+          retries += result.retries;
+          if (result.success) {
+            uploadedBytes += result.size;
+          } else {
+            failed++;
+          }
+          results.push(result);
+          activeFiles.delete(task.remotePath);
+          updateProgress();
+        }
+      } finally {
+        client.close();
+      }
+    };
+    updateProgress();
+    try {
+      await Promise.all(Array.from({ length: safeWindowSize }, () => worker()));
+    } finally {
+      if (refreshTimer) clearInterval(refreshTimer);
+    }
+    if (spinner) {
+      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))}`
+      );
+    } else {
+      console.log(`${chalk.green("\u2714")} \u6240\u6709\u6587\u4EF6\u4E0A\u4F20\u5B8C\u6210 (${totalFiles}/${totalFiles})`);
+    }
+    return results;
+  };
+  const deploySingleTarget = async (ftpConfig) => {
+    const { host, port = 21, user, password, alias = "", name } = ftpConfig;
+    if (!host || !user || !password) {
+      console.error(chalk.red(`\u274C FTP\u914D\u7F6E "${name || host || "\u672A\u77E5"}" \u7F3A\u5C11\u5FC5\u9700\u53C2\u6570:`));
+      if (!host) console.error(chalk.red("  - \u7F3A\u5C11 host"));
+      if (!user) console.error(chalk.red("  - \u7F3A\u5C11 user"));
+      if (!password) console.error(chalk.red("  - \u7F3A\u5C11 password"));
+      return { name: name || host || "unknown", totalFiles: 0, failedCount: 1 };
+    }
+    const allFiles = getAllFiles(outDir);
+    const totalFiles = allFiles.length;
+    const { protocol, baseUrl } = parseAlias(alias);
+    const displayName = name || host;
+    const startTime = Date.now();
+    if (allFiles.length === 0) {
+      console.log(`${chalk.yellow("\u26A0 \u6CA1\u6709\u627E\u5230\u9700\u8981\u4E0A\u4F20\u7684\u6587\u4EF6")}`);
+      return { name: displayName, totalFiles: 0, failedCount: 0 };
+    }
+    clearScreen();
+    console.log(chalk.cyan(`
+\u{1F680} FTP \u90E8\u7F72\u5F00\u59CB
+`));
+    console.log(`${chalk.gray("Server:")}   ${chalk.green(displayName)}`);
+    console.log(`${chalk.gray("Host:")}     ${chalk.green(host)}`);
+    console.log(`${chalk.gray("Source:")}   ${chalk.yellow(outDir)}`);
+    console.log(`${chalk.gray("Target:")}   ${chalk.yellow(uploadPath)}`);
+    if (alias) console.log(`${chalk.gray("Alias:")}    ${chalk.green(alias)}`);
+    console.log(`${chalk.gray("Files:")}    ${chalk.blue(totalFiles)}
+`);
+    const connectConfig = { host, port, user, password };
+    const preflightClient = new Client();
+    const preflightSpinner = useInteractiveOutput ? ora(`\u8FDE\u63A5\u5230 ${displayName}...`).start() : null;
+    try {
+      await connectWithRetry(preflightClient, connectConfig, maxRetries, retryDelay, Boolean(preflightSpinner));
+      if (preflightSpinner) preflightSpinner.succeed("\u8FDE\u63A5\u6210\u529F");
+      await preflightClient.ensureDir(uploadPath);
+      const fileList = await preflightClient.list(uploadPath);
+      if (fileList.length) {
+        if (singleBack) {
+          await createSingleBackup(preflightClient, uploadPath, protocol, baseUrl, singleBackFiles, showBackFile);
+        } else {
+          const shouldBackup = await select({
+            message: `\u662F\u5426\u5907\u4EFD ${displayName} \u7684\u8FDC\u7A0B\u6587\u4EF6`,
+            choices: ["\u5426", "\u662F"],
+            default: "\u5426"
+          });
+          if (shouldBackup === "\u662F") {
+            await createBackupFile(preflightClient, uploadPath, protocol, baseUrl, showBackFile);
+          }
+        }
+      }
+      const results = await uploadFilesInBatches(connectConfig, allFiles, uploadPath, concurrency);
+      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`);
+      if (baseUrl) {
+        console.log(` ${chalk.green("\u{1F517}")} \u8BBF\u95EE\u5730\u5740: ${chalk.bold(buildUrl(protocol, baseUrl, uploadPath))}`);
+      }
+      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("");
       }
+      return { name: displayName, totalFiles: results.length, failedCount };
+    } catch (error) {
+      if (preflightSpinner) preflightSpinner.fail(`\u274C \u4E0A\u4F20\u5230 ${displayName} \u5931\u8D25`);
+      console.log(`
+${chalk.red("\u274C \u4E0A\u4F20\u8FC7\u7A0B\u4E2D\u53D1\u751F\u9519\u8BEF:")} ${error}
+`);
+      return {
+        name: displayName,
+        totalFiles,
+        failedCount: totalFiles > 0 ? totalFiles : 1,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+    } finally {
+      preflightClient.close();
     }
   };
-  async function deployToFtp() {
+  const deployToFtp = async () => {
     if (!autoUpload) {
-      const ftpUploadChoice = await (0, import_prompts.select)({
+      const ftpUploadChoice = await select({
         message: "\u662F\u5426\u4E0A\u4F20FTP",
         choices: ["\u662F", "\u5426"],
         default: "\u662F"
       });
-      if (ftpUploadChoice === "\u5426") return;
+      if (ftpUploadChoice === "\u5426") return [];
     }
     let selectedConfigs = [];
     if (isMultiFtp) {
       if (defaultFtp) {
         const defaultConfig = ftpConfigs.find((ftp) => ftp.name === defaultFtp);
-        if (defaultConfig) {
-          if (validateFtpConfig(defaultConfig)) {
-            console.log(import_chalk.default.blue(`\u4F7F\u7528\u9ED8\u8BA4FTP\u914D\u7F6E: ${defaultFtp}`));
-            selectedConfigs = [defaultConfig];
-          } else {
-            console.log(import_chalk.default.yellow(`\u26A0\uFE0F \u9ED8\u8BA4FTP\u914D\u7F6E "${defaultFtp}" \u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\uFF0C\u5C06\u8FDB\u884C\u624B\u52A8\u9009\u62E9`));
-          }
+        if (defaultConfig && validateFtpConfig(defaultConfig)) {
+          console.log(chalk.blue(`\u4F7F\u7528\u9ED8\u8BA4FTP\u914D\u7F6E: ${defaultFtp}`));
+          selectedConfigs = [defaultConfig];
+        } else if (defaultConfig) {
+          console.log(chalk.yellow(`\u26A0 \u9ED8\u8BA4FTP\u914D\u7F6E "${defaultFtp}" \u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\uFF0C\u5C06\u8FDB\u884C\u624B\u52A8\u9009\u62E9`));
         }
       }
       if (selectedConfigs.length === 0) {
         const validConfigs = ftpConfigs.filter(validateFtpConfig);
         const invalidConfigs = ftpConfigs.filter((config) => !validateFtpConfig(config));
         if (invalidConfigs.length > 0) {
-          console.log(import_chalk.default.yellow("\n \u4EE5\u4E0BFTP\u914D\u7F6E\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\uFF0C\u5DF2\u4ECE\u9009\u62E9\u5217\u8868\u4E2D\u6392\u9664:"));
+          console.log(chalk.yellow("\n\u4EE5\u4E0BFTP\u914D\u7F6E\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570\uFF0C\u5DF2\u4ECE\u9009\u62E9\u5217\u8868\u4E2D\u6392\u9664:"));
           invalidConfigs.forEach((config) => {
             const missing = [];
             if (!config.host) missing.push("host");
             if (!config.user) missing.push("user");
             if (!config.password) missing.push("password");
-            console.log(import_chalk.default.yellow(`  - ${config.name || "\u672A\u547D\u540D"}: \u7F3A\u5C11 ${missing.join(", ")}`));
+            console.log(chalk.yellow(`  - ${config.name || "\u672A\u547D\u540D"}: \u7F3A\u5C11 ${missing.join(", ")}`));
           });
           console.log();
         }
         if (validConfigs.length === 0) {
-          console.error(import_chalk.default.red("\u274C \u6CA1\u6709\u53EF\u7528\u7684\u6709\u6548FTP\u914D\u7F6E"));
-          return;
+          console.error(chalk.red("\u274C \u6CA1\u6709\u53EF\u7528\u7684\u6709\u6548FTP\u914D\u7F6E"));
+          return [];
         }
-        const choices = validConfigs.map((ftp) => ({
-          name: ftp.name,
-          value: ftp
-        }));
-        selectedConfigs = await (0, import_prompts.checkbox)({
+        selectedConfigs = await checkbox({
           message: "\u9009\u62E9\u8981\u4E0A\u4F20\u7684FTP\u670D\u52A1\u5668\uFF08\u53EF\u591A\u9009\uFF09",
-          choices,
+          choices: validConfigs.map((ftp) => ({
+            name: ftp.name || ftp.host || "\u672A\u547D\u540DFTP",
+            value: ftp
+          })),
           required: true
         });
       }
@@ -151,130 +463,71 @@ function vitePluginDeployFtp(option) {
         selectedConfigs = [{ ...singleConfig, name: singleConfig.name || singleConfig.host }];
       } else {
         const missing = [];
-        if (!singleConfig.host) missing.push("host");
-        if (!singleConfig.user) missing.push("user");
-        if (!singleConfig.password) missing.push("password");
-        console.error(import_chalk.default.red(`\u274C FTP\u914D\u7F6E\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570: ${missing.join(", ")}`));
-        return;
+        if (!singleConfig?.host) missing.push("host");
+        if (!singleConfig?.user) missing.push("user");
+        if (!singleConfig?.password) missing.push("password");
+        console.error(chalk.red(`\u274C FTP\u914D\u7F6E\u7F3A\u5C11\u5FC5\u9700\u53C2\u6570: ${missing.join(", ")}`));
+        return [];
       }
     }
+    const deployResults = [];
     for (const ftpConfig of selectedConfigs) {
-      const { host, port = 21, user, password, alias = "", name } = ftpConfig;
-      if (!host || !user || !password) {
-        console.error(import_chalk.default.red(`\u274C FTP\u914D\u7F6E "${name || host || "\u672A\u77E5"}" \u7F3A\u5C11\u5FC5\u9700\u53C2\u6570:`));
-        if (!host) console.error(import_chalk.default.red("  - \u7F3A\u5C11 host"));
-        if (!user) console.error(import_chalk.default.red("  - \u7F3A\u5C11 user"));
-        if (!password) console.error(import_chalk.default.red("  - \u7F3A\u5C11 password"));
-        continue;
+      const targetResult = await deploySingleTarget(ftpConfig);
+      deployResults.push(targetResult);
+    }
+    return deployResults;
+  };
+  return {
+    name: "vite-plugin-deploy-ftp",
+    apply: "build",
+    enforce: "post",
+    buildEnd(error) {
+      if (error) buildFailed = true;
+    },
+    config(config) {
+      if (!open || buildFailed) return;
+      clearScreen();
+      const validationErrors = validateOptions();
+      if (validationErrors.length > 0) {
+        console.log(`${chalk.red("\u2717 \u914D\u7F6E\u9519\u8BEF:")}
+${validationErrors.map((err) => `  - ${err}`).join("\n")}`);
+        return;
       }
-      const { protocol, baseUrl } = parseAlias(alias);
-      const displayName = name || host;
-      const allFiles = getAllFiles(outDir);
-      const totalFiles = allFiles.length;
-      console.log(import_chalk.default.bold(`
-\u{1F680} FTP \u90E8\u7F72\u5F00\u59CB`));
-      console.log();
-      console.log(`Host:     ${import_chalk.default.blue(host)}`);
-      console.log(`User:     ${import_chalk.default.blue(user)}`);
-      console.log(`Source:   ${import_chalk.default.blue(outDir)}`);
-      console.log(`Target:   ${import_chalk.default.blue(uploadPath)}`);
-      console.log(`Files:    ${import_chalk.default.blue(totalFiles)}`);
-      console.log();
-      const client = new import_basic_ftp.Client();
-      let uploadSpinner;
-      const startTime = Date.now();
-      try {
-        uploadSpinner = (0, import_ora.default)(`\u8FDE\u63A5\u5230 ${displayName} \u4E2D...`).start();
-        await connectWithRetry(client, { host, port, user, password }, maxRetries, retryDelay);
-        uploadSpinner.color = "green";
-        uploadSpinner.text = "\u8FDE\u63A5\u6210\u529F";
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        const fileList = await client.list(uploadPath);
-        uploadSpinner.succeed("\u8FDE\u63A5\u6210\u529F!");
-        const startDir = await client.pwd();
-        if (fileList.length) {
-          if (singleBack) {
-            await createSingleBackup(client, uploadPath, protocol, baseUrl, singleBackFiles, showBackFile);
-          } else {
-            const isBackFiles = await (0, import_prompts.select)({
-              message: `\u662F\u5426\u5907\u4EFD ${displayName} \u7684\u8FDC\u7A0B\u6587\u4EF6`,
-              choices: ["\u5426", "\u662F"],
-              default: "\u5426"
-            });
-            if (isBackFiles === "\u662F") {
-              await createBackupFile(client, uploadPath, protocol, baseUrl, showBackFile);
-            }
-          }
-        }
-        const progressSpinner = (0, import_ora.default)("\u51C6\u5907\u4E0A\u4F20...").start();
-        let uploadedCount = 0;
-        const groups = {};
-        for (const file of allFiles) {
-          const dir = import_node_path.default.dirname(file);
-          if (!groups[dir]) groups[dir] = [];
-          groups[dir].push(import_node_path.default.basename(file));
-        }
-        for (const relDir of Object.keys(groups)) {
-          await client.cd(startDir);
-          const remoteDir = (0, import_vite.normalizePath)(import_node_path.default.join(uploadPath, relDir));
-          await client.ensureDir(remoteDir);
-          for (const fileName of groups[relDir]) {
-            const currentFile = import_node_path.default.join(relDir, fileName);
-            const displayPath = (0, import_vite.normalizePath)(currentFile);
-            progressSpinner.text = `\u6B63\u5728\u4E0A\u4F20: ${import_chalk.default.dim(displayPath)}
-${formatProgressBar(uploadedCount, totalFiles)}`;
-            const localFile = import_node_path.default.join(outDir, relDir, fileName);
-            await client.uploadFrom(localFile, fileName);
-            uploadedCount++;
-          }
-        }
-        progressSpinner.succeed("\u6240\u6709\u6587\u4EF6\u4E0A\u4F20\u5B8C\u6210!");
-        console.log(import_chalk.default.green(formatProgressBar(totalFiles, totalFiles)));
-        process.stdout.write("\x1B[2J\x1B[0f");
-        console.log(import_chalk.default.gray("\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n"));
-        const duration = ((Date.now() - startTime) / 1e3).toFixed(2);
-        console.log(`\u{1F389} \u90E8\u7F72\u6210\u529F!`);
-        console.log();
-        console.log(`\u7EDF\u8BA1:`);
-        console.log(` \u2714 \u6210\u529F: ${import_chalk.default.green(totalFiles)}`);
-        console.log(` \u23F1 \u8017\u65F6: ${import_chalk.default.green(duration + "s")}`);
-        console.log();
-        if (baseUrl) {
-          console.log(`\u8BBF\u95EE\u5730\u5740: ${import_chalk.default.green(buildUrl(protocol, baseUrl, uploadPath))}`);
-          console.log();
-        }
-      } catch (error) {
-        if (uploadSpinner) {
-          uploadSpinner.fail(`\u274C \u4E0A\u4F20\u5230 ${displayName} \u5931\u8D25`);
+      upload = true;
+      return config;
+    },
+    configResolved(config) {
+      resolvedConfig = config;
+      outDir = normalizePath(path.resolve(config.root, config.build.outDir));
+    },
+    closeBundle: {
+      sequential: true,
+      order: "post",
+      async handler() {
+        if (!open || !upload || buildFailed || !resolvedConfig) return;
+        const deployResults = await deployToFtp();
+        if (deployResults.length === 0) return;
+        const failedTargets = deployResults.filter((target) => target.failedCount > 0);
+        if (failedTargets.length > 0 && failOnError) {
+          throw new Error(`Failed to deploy ${failedTargets.length} of ${deployResults.length} FTP targets`);
         }
-        console.error(import_chalk.default.red(`\u274C \u4E0A\u4F20\u5230 ${displayName} \u5931\u8D25:`), error instanceof Error ? error.message : error);
-        throw error;
-      } finally {
-        client.close();
       }
     }
-  }
+  };
 }
 function getAllFiles(dirPath, arrayOfFiles = [], relativePath = "") {
-  const files = import_node_fs.default.readdirSync(dirPath);
-  files.forEach(function(file) {
-    const fullPath = import_node_path.default.join(dirPath, file);
-    const relPath = import_node_path.default.join(relativePath, file);
-    if (import_node_fs.default.statSync(fullPath).isDirectory()) {
+  const files = fs.readdirSync(dirPath);
+  files.forEach((file) => {
+    const fullPath = path.join(dirPath, file);
+    const relPath = path.join(relativePath, file);
+    if (fs.statSync(fullPath).isDirectory()) {
       getAllFiles(fullPath, arrayOfFiles, relPath);
     } else {
-      arrayOfFiles.push(relPath);
+      arrayOfFiles.push(normalizePath(relPath));
     }
   });
   return arrayOfFiles;
 }
-function formatProgressBar(current, total, width = 30) {
-  const percentage = Math.round(current / total * 100);
-  const filled = Math.round(width * current / total);
-  const empty = width - filled;
-  const bar = "\u2588".repeat(filled) + "\u2591".repeat(empty);
-  return `${bar} ${percentage}% (${current}/${total})`;
-}
 function validateFtpConfig(config) {
   return !!(config.host && config.user && config.password);
 }
@@ -285,10 +538,10 @@ function parseAlias(alias = "") {
     baseUrl: baseUrl || ""
   };
 }
-function buildUrl(protocol, baseUrl, path2) {
-  return protocol + (0, import_vite.normalizePath)(baseUrl + path2);
+function buildUrl(protocol, baseUrl, targetPath) {
+  return protocol + normalizePath(baseUrl + targetPath);
 }
-async function connectWithRetry(client, config, maxRetries, retryDelay) {
+async function connectWithRetry(client, config, maxRetries, retryDelay, silentLogs = false) {
   let lastError;
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
     try {
@@ -302,66 +555,70 @@ async function connectWithRetry(client, config, maxRetries, retryDelay) {
     } catch (error) {
       lastError = error instanceof Error ? error : new Error(String(error));
       if (attempt < maxRetries) {
-        console.log(import_chalk.default.yellow(`\u26A0\uFE0F \u8FDE\u63A5\u5931\u8D25\uFF0C${retryDelay}ms \u540E\u91CD\u8BD5 (${attempt}/${maxRetries})`));
-        await new Promise((resolve) => setTimeout(resolve, retryDelay));
+        if (!silentLogs) {
+          console.log(chalk.yellow(`\u26A0 \u8FDE\u63A5\u5931\u8D25\uFF0C${retryDelay}ms \u540E\u91CD\u8BD5 (${attempt}/${maxRetries})`));
+        }
+        await sleep(retryDelay * attempt);
       }
     }
   }
   throw new Error(`\u274C FTP \u8FDE\u63A5\u5931\u8D25\uFF0C\u5DF2\u91CD\u8BD5 ${maxRetries} \u6B21: ${lastError?.message}`);
 }
 function createTempDir(basePath) {
-  const tempBaseDir = import_node_os.default.tmpdir();
-  const tempPath = import_node_path.default.join(tempBaseDir, "vite-plugin-deploy-ftp", basePath);
-  if (!import_node_fs.default.existsSync(tempPath)) {
-    import_node_fs.default.mkdirSync(tempPath, { recursive: true });
+  const tempBaseDir = os.tmpdir();
+  const tempPath = path.join(tempBaseDir, "vite-plugin-deploy-ftp", basePath);
+  if (!fs.existsSync(tempPath)) {
+    fs.mkdirSync(tempPath, { recursive: true });
   }
   return {
     path: tempPath,
     cleanup: () => {
       try {
-        if (import_node_fs.default.existsSync(tempPath)) {
-          import_node_fs.default.rmSync(tempPath, { recursive: true, force: true });
+        if (fs.existsSync(tempPath)) {
+          fs.rmSync(tempPath, { recursive: true, force: true });
         }
       } catch (error) {
-        console.warn(import_chalk.default.yellow(`\u26A0\uFE0F \u6E05\u7406\u4E34\u65F6\u76EE\u5F55\u5931\u8D25: ${tempPath}`), error);
+        console.warn(chalk.yellow(`\u26A0 \u6E05\u7406\u4E34\u65F6\u76EE\u5F55\u5931\u8D25: ${tempPath}`), error);
       }
     }
   };
 }
 async function createBackupFile(client, dir, protocol, baseUrl, showBackFile = false) {
-  const backupSpinner = (0, import_ora.default)(`\u521B\u5EFA\u5907\u4EFD\u6587\u4EF6\u4E2D ${import_chalk.default.yellow(`==> ${buildUrl(protocol, baseUrl, dir)}`)}`).start();
-  const fileName = `backup_${(0, import_dayjs.default)().format("YYYYMMDD_HHmmss")}.zip`;
+  const backupSpinner = ora(`\u521B\u5EFA\u5907\u4EFD\u6587\u4EF6\u4E2D ${chalk.yellow(`==> ${buildUrl(protocol, baseUrl, dir)}`)}`).start();
+  const fileName = `backup_${dayjs().format("YYYYMMDD_HHmmss")}.zip`;
   const tempDir = createTempDir("backup-zip");
-  const zipFilePath = import_node_path.default.join(import_node_os.default.tmpdir(), "vite-plugin-deploy-ftp", fileName);
+  const zipFilePath = path.join(os.tmpdir(), "vite-plugin-deploy-ftp", fileName);
   try {
-    const zipDir = import_node_path.default.dirname(zipFilePath);
-    if (!import_node_fs.default.existsSync(zipDir)) {
-      import_node_fs.default.mkdirSync(zipDir, { recursive: true });
+    const zipDir = path.dirname(zipFilePath);
+    if (!fs.existsSync(zipDir)) {
+      fs.mkdirSync(zipDir, { recursive: true });
     }
     const remoteFiles = await client.list(dir);
-    const filteredFiles = remoteFiles.filter((file) => !file.name.startsWith("backup_") || !file.name.endsWith(".zip"));
+    const filteredFiles = remoteFiles.filter(
+      (file) => !(file.name.startsWith("backup_") && file.name.endsWith(".zip"))
+    );
     if (showBackFile) {
-      console.log(import_chalk.default.cyan(`
+      console.log(chalk.cyan(`
 \u5F00\u59CB\u5907\u4EFD\u8FDC\u7A0B\u6587\u4EF6\uFF0C\u5171 ${filteredFiles.length} \u4E2A\u6587\u4EF6:`));
       filteredFiles.forEach((file) => {
-        console.log(import_chalk.default.gray(`  - ${file.name} (${file.size} bytes)`));
+        console.log(chalk.gray(`  - ${file.name} (${file.size} bytes)`));
       });
     }
     for (const file of filteredFiles) {
       if (file.type === 1) {
-        await client.downloadTo(import_node_path.default.join(tempDir.path, file.name), (0, import_vite.normalizePath)(`${dir}/${file.name}`));
+        await client.downloadTo(path.join(tempDir.path, file.name), normalizePath(`${dir}/${file.name}`));
       }
     }
-    backupSpinner.text = `\u4E0B\u8F7D\u8FDC\u7A0B\u6587\u4EF6\u6210\u529F ${import_chalk.default.yellow(`==> ${buildUrl(protocol, baseUrl, dir)}`)}`;
+    backupSpinner.text = `\u4E0B\u8F7D\u8FDC\u7A0B\u6587\u4EF6\u6210\u529F ${chalk.yellow(`==> ${buildUrl(protocol, baseUrl, dir)}`)}`;
     await createZipFile(tempDir.path, zipFilePath);
-    backupSpinner.text = `\u538B\u7F29\u5B8C\u6210, \u51C6\u5907\u4E0A\u4F20 ${import_chalk.default.yellow(
-      `==> ${buildUrl(protocol, baseUrl, dir + "/" + fileName)}`
+    backupSpinner.text = `\u538B\u7F29\u5B8C\u6210, \u51C6\u5907\u4E0A\u4F20 ${chalk.yellow(
+      `==> ${buildUrl(protocol, baseUrl, `${dir}/${fileName}`)}`
     )}`;
-    await client.uploadFrom(zipFilePath, (0, import_vite.normalizePath)(`${dir}/${fileName}`));
+    await client.uploadFrom(zipFilePath, normalizePath(`${dir}/${fileName}`));
     const backupUrl = buildUrl(protocol, baseUrl, `${dir}/${fileName}`);
     backupSpinner.succeed("\u5907\u4EFD\u5B8C\u6210");
-    console.log(import_chalk.default.cyan("\n\u5907\u4EFD\u6587\u4EF6:"));
-    console.log(import_chalk.default.green(`${backupUrl}`));
+    console.log(chalk.cyan("\n\u5907\u4EFD\u6587\u4EF6:"));
+    console.log(chalk.green(`${backupUrl}`));
     console.log();
   } catch (error) {
     backupSpinner.fail("\u5907\u4EFD\u5931\u8D25");
@@ -369,18 +626,18 @@ async function createBackupFile(client, dir, protocol, baseUrl, showBackFile = f
   } finally {
     tempDir.cleanup();
     try {
-      if (import_node_fs.default.existsSync(zipFilePath)) {
-        import_node_fs.default.rmSync(zipFilePath);
+      if (fs.existsSync(zipFilePath)) {
+        fs.rmSync(zipFilePath);
       }
     } catch (error) {
-      console.warn(import_chalk.default.yellow("\u26A0\uFE0F \u6E05\u7406zip\u6587\u4EF6\u5931\u8D25"), error);
+      console.warn(chalk.yellow("\u26A0 \u6E05\u7406zip\u6587\u4EF6\u5931\u8D25"), error);
     }
   }
 }
 async function createZipFile(sourceDir, outputPath) {
   return new Promise((resolve, reject) => {
-    const output = import_node_fs.default.createWriteStream(outputPath);
-    const archive = (0, import_archiver.default)("zip", {
+    const output = fs.createWriteStream(outputPath);
+    const archive = archiver("zip", {
       zlib: { level: 9 }
     });
     output.on("close", () => {
@@ -395,8 +652,8 @@ async function createZipFile(sourceDir, outputPath) {
   });
 }
 async function createSingleBackup(client, dir, protocol, baseUrl, singleBackFiles, showBackFile = false) {
-  const timestamp = (0, import_dayjs.default)().format("YYYYMMDD_HHmmss");
-  const backupSpinner = (0, import_ora.default)(`\u5907\u4EFD\u6307\u5B9A\u6587\u4EF6\u4E2D ${import_chalk.default.yellow(`==> ${buildUrl(protocol, baseUrl, dir)}`)}`).start();
+  const timestamp = dayjs().format("YYYYMMDD_HHmmss");
+  const backupSpinner = ora(`\u5907\u4EFD\u6307\u5B9A\u6587\u4EF6\u4E2D ${chalk.yellow(`==> ${buildUrl(protocol, baseUrl, dir)}`)}`).start();
   const tempDir = createTempDir("single-backup");
   let backupProgressSpinner;
   try {
@@ -411,13 +668,13 @@ async function createSingleBackup(client, dir, protocol, baseUrl, singleBackFile
     }
     backupSpinner.stop();
     if (showBackFile) {
-      console.log(import_chalk.default.cyan(`
+      console.log(chalk.cyan(`
 \u5F00\u59CB\u5355\u6587\u4EF6\u5907\u4EFD\uFF0C\u5171 ${backupTasks.length} \u4E2A\u6587\u4EF6:`));
       backupTasks.forEach((task) => {
-        console.log(import_chalk.default.gray(`  - ${task.fileName}`));
+        console.log(chalk.gray(`  - ${task.fileName}`));
       });
     }
-    backupProgressSpinner = (0, import_ora.default)("\u6B63\u5728\u5907\u4EFD\u6587\u4EF6...").start();
+    backupProgressSpinner = ora("\u6B63\u5728\u5907\u4EFD\u6587\u4EF6...").start();
     const concurrencyLimit = 3;
     let backedUpCount = 0;
     const backedUpFiles = [];
@@ -425,18 +682,18 @@ async function createSingleBackup(client, dir, protocol, baseUrl, singleBackFile
       const batch = backupTasks.slice(i, i + concurrencyLimit);
       const promises = batch.map(async ({ fileName }) => {
         try {
-          const localTempPath = import_node_path.default.join(tempDir.path, fileName);
-          const [name, ext] = fileName.split(".");
-          const suffix = ext ? `.${ext}` : "";
-          const backupFileName = `${name}.${timestamp}${suffix}`;
-          const backupRemotePath = (0, import_vite.normalizePath)(`${dir}/${backupFileName}`);
-          await client.downloadTo(localTempPath, (0, import_vite.normalizePath)(`${dir}/${fileName}`));
+          const localTempPath = path.join(tempDir.path, fileName);
+          const extIndex = fileName.lastIndexOf(".");
+          const name = extIndex > -1 ? fileName.slice(0, extIndex) : fileName;
+          const ext = extIndex > -1 ? fileName.slice(extIndex) : "";
+          const backupFileName = `${name}.${timestamp}${ext}`;
+          const backupRemotePath = normalizePath(`${dir}/${backupFileName}`);
+          await client.downloadTo(localTempPath, normalizePath(`${dir}/${fileName}`));
           await client.uploadFrom(localTempPath, backupRemotePath);
-          const backupUrl = buildUrl(protocol, baseUrl, backupRemotePath);
-          backedUpFiles.push(backupUrl);
+          backedUpFiles.push(buildUrl(protocol, baseUrl, backupRemotePath));
           return true;
         } catch (error) {
-          console.warn(import_chalk.default.yellow(`\u5907\u4EFD\u6587\u4EF6 ${fileName} \u5931\u8D25:`), error instanceof Error ? error.message : error);
+          console.warn(chalk.yellow(`\u5907\u4EFD\u6587\u4EF6 ${fileName} \u5931\u8D25:`), error instanceof Error ? error.message : error);
           return false;
         }
       });
@@ -445,9 +702,9 @@ async function createSingleBackup(client, dir, protocol, baseUrl, singleBackFile
     }
     if (backedUpCount > 0) {
       backupProgressSpinner.succeed("\u5907\u4EFD\u5B8C\u6210");
-      console.log(import_chalk.default.cyan("\n\u5907\u4EFD\u6587\u4EF6:"));
+      console.log(chalk.cyan("\n\u5907\u4EFD\u6587\u4EF6:"));
       backedUpFiles.forEach((url) => {
-        console.log(import_chalk.default.green(`\u{1F517}  ${url}`));
+        console.log(chalk.green(`\u{1F517}  ${url}`));
       });
       console.log();
     } else {
@@ -464,3 +721,6 @@ async function createSingleBackup(client, dir, protocol, baseUrl, singleBackFile
     tempDir.cleanup();
   }
 }
+export {
+  vitePluginDeployFtp as default
+};