vite-plugin-deploy-ftp 3.0.0 → 3.0.1

package/dist/index.js

@@ -1,7 +1,6 @@
 // src/index.ts
 import { checkbox, select } from "@inquirer/prompts";
-import archiver from "archiver";
-import { Client } from "basic-ftp";
+import { Client, FileType } from "basic-ftp";
 import chalk from "chalk";
 import dayjs from "dayjs";
 import fs from "fs";
@@ -10,6 +9,7 @@ import os from "os";
 import path from "path";
 import ora from "ora";
 import { normalizePath } from "vite";
+import yazl from "yazl";
 var formatBytes = (bytes) => {
   if (!Number.isFinite(bytes) || bytes <= 0) return "0 B";
   const units = ["B", "KB", "MB", "GB", "TB"];
@@ -54,6 +54,12 @@ var normalizeRemotePath = (targetDir, relativeFilePath) => {
   if (targetDir.startsWith("/")) return joined.startsWith("/") ? joined : `/${joined}`;
   return joined.replace(/^\/+/, "");
 };
+var normalizeUploadPath = (targetPath) => {
+  const normalized = normalizePath(targetPath).replace(/\/{2,}/g, "/").trim();
+  if (!normalized || normalized === "." || normalized === "/") return "/";
+  const withoutTrailingSlash = normalized.replace(/\/+$/, "");
+  return withoutTrailingSlash.startsWith("/") ? withoutTrailingSlash : `/${withoutTrailingSlash}`;
+};
 var sleep = async (ms) => {
   await new Promise((resolve) => setTimeout(resolve, ms));
 };
@@ -75,6 +81,7 @@ function vitePluginDeployFtp(option) {
   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;
+  const normalizedUploadPath = normalizeUploadPath(uploadPath);
   let outDir = normalizePath(path.resolve("dist"));
   let upload = false;
   let buildFailed = false;
@@ -114,9 +121,8 @@ function vitePluginDeployFtp(option) {
       try {
         await context.ensureConnected();
         const remoteDir = normalizePath(path.posix.dirname(task.remotePath));
-        if (remoteDir && remoteDir !== "." && !context.ensuredDirs.has(remoteDir)) {
+        if (remoteDir && remoteDir !== ".") {
           await context.client.ensureDir(remoteDir);
-          context.ensuredDirs.add(remoteDir);
         }
         await context.client.uploadFrom(task.filePath, path.posix.basename(task.remotePath));
         return {
@@ -239,7 +245,6 @@ ${chalk.yellow("\u91CD\u8BD5")}: ${retries}  ${chalk.yellow("\u5931\u8D25")}: ${
     let currentIndex = 0;
     const worker = async () => {
       const client = new Client();
-      const ensuredDirs = /* @__PURE__ */ new Set();
       let connected = false;
       const ensureConnected = async () => {
         if (connected) return;
@@ -248,7 +253,6 @@ ${chalk.yellow("\u91CD\u8BD5")}: ${retries}  ${chalk.yellow("\u5931\u8D25")}: ${
       };
       const markDisconnected = () => {
         connected = false;
-        ensuredDirs.clear();
       };
       try {
         while (true) {
@@ -259,7 +263,6 @@ ${chalk.yellow("\u91CD\u8BD5")}: ${retries}  ${chalk.yellow("\u5931\u8D25")}: ${
           updateProgress();
           const result = await uploadFileWithRetry(task, {
             client,
-            ensuredDirs,
             ensureConnected,
             markDisconnected,
             silentLogs,
@@ -325,7 +328,7 @@ ${buildCapsuleBar(1)} 100% (${totalFiles}/${totalFiles}) ${chalk.gray("|")} \u90
     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)}`);
+    console.log(`${chalk.gray("Target:")}   ${chalk.yellow(normalizedUploadPath)}`);
     if (alias) console.log(`${chalk.gray("Alias:")}    ${chalk.green(alias)}`);
     console.log(`${chalk.gray("Files:")}    ${chalk.blue(totalFiles)}
 `);
@@ -335,11 +338,18 @@ ${buildCapsuleBar(1)} 100% (${totalFiles}/${totalFiles}) ${chalk.gray("|")} \u90
     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);
+      await preflightClient.ensureDir(normalizedUploadPath);
+      const fileList = await preflightClient.list();
       if (fileList.length) {
         if (singleBack) {
-          await createSingleBackup(preflightClient, uploadPath, protocol, baseUrl, singleBackFiles, showBackFile);
+          await createSingleBackup(
+            preflightClient,
+            normalizedUploadPath,
+            protocol,
+            baseUrl,
+            singleBackFiles,
+            showBackFile
+          );
         } else {
           const shouldBackup = await select({
             message: `\u662F\u5426\u5907\u4EFD ${displayName} \u7684\u8FDC\u7A0B\u6587\u4EF6`,
@@ -347,11 +357,22 @@ ${buildCapsuleBar(1)} 100% (${totalFiles}/${totalFiles}) ${chalk.gray("|")} \u90
             default: "\u5426"
           });
           if (shouldBackup === "\u662F") {
-            await createBackupFile(preflightClient, uploadPath, protocol, baseUrl, showBackFile);
+            await createBackupFile(
+              preflightClient,
+              normalizedUploadPath,
+              protocol,
+              baseUrl,
+              showBackFile
+            );
           }
         }
       }
-      const results = await uploadFilesInBatches(connectConfig, allFiles, uploadPath, concurrency);
+      const results = await uploadFilesInBatches(
+        connectConfig,
+        allFiles,
+        normalizedUploadPath,
+        concurrency
+      );
       const successCount = results.filter((r) => r.success).length;
       const failedCount = results.length - successCount;
       const durationSeconds = (Date.now() - startTime) / 1e3;
@@ -377,7 +398,9 @@ ${chalk.gray("\u7EDF\u8BA1:")}`);
       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(
+          ` ${chalk.green("\u{1F517}")} \u8BBF\u95EE\u5730\u5740: ${chalk.bold(buildUrl(protocol, baseUrl, normalizedUploadPath))}`
+        );
       }
       console.log("");
       if (failedCount > 0) {
@@ -541,6 +564,43 @@ function parseAlias(alias = "") {
 function buildUrl(protocol, baseUrl, targetPath) {
   return protocol + normalizePath(baseUrl + targetPath);
 }
+var backupArchivePattern = /^backup_\d{8}_\d{6}\.zip$/i;
+async function downloadRemoteFilesForBackup(client, remoteDir, localDir, downloadedFiles = []) {
+  if (!fs.existsSync(localDir)) {
+    fs.mkdirSync(localDir, { recursive: true });
+  }
+  const remoteEntries = await client.list(remoteDir);
+  for (const entry of remoteEntries) {
+    const remotePath = normalizePath(`${remoteDir}/${entry.name}`);
+    const localPath = path.join(localDir, entry.name);
+    if (entry.type === FileType.Directory) {
+      await downloadRemoteFilesForBackup(client, remotePath, localPath, downloadedFiles);
+      continue;
+    }
+    if (entry.type === FileType.SymbolicLink) {
+      continue;
+    }
+    if (backupArchivePattern.test(entry.name)) {
+      continue;
+    }
+    if (entry.type === FileType.File) {
+      await client.downloadTo(localPath, remotePath);
+      downloadedFiles.push({ remotePath, size: entry.size });
+      continue;
+    }
+    try {
+      await client.downloadTo(localPath, remotePath);
+      downloadedFiles.push({ remotePath, size: entry.size });
+    } catch (downloadError) {
+      try {
+        await downloadRemoteFilesForBackup(client, remotePath, localPath, downloadedFiles);
+      } catch {
+        throw downloadError;
+      }
+    }
+  }
+  return downloadedFiles;
+}
 async function connectWithRetry(client, config, maxRetries, retryDelay, silentLogs = false) {
   let lastError;
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
@@ -593,22 +653,19 @@ async function createBackupFile(client, dir, protocol, baseUrl, showBackFile = f
     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"))
-    );
+    backupSpinner.text = `\u4E0B\u8F7D\u8FDC\u7A0B\u6587\u4EF6\u4E2D ${chalk.yellow(`==> ${buildUrl(protocol, baseUrl, dir)}`)}`;
+    const downloadedFiles = await downloadRemoteFilesForBackup(client, dir, tempDir.path);
+    if (downloadedFiles.length === 0) {
+      backupSpinner.warn("\u672A\u627E\u5230\u53EF\u5907\u4EFD\u7684\u8FDC\u7A0B\u6587\u4EF6");
+      return;
+    }
     if (showBackFile) {
       console.log(chalk.cyan(`
-\u5F00\u59CB\u5907\u4EFD\u8FDC\u7A0B\u6587\u4EF6\uFF0C\u5171 ${filteredFiles.length} \u4E2A\u6587\u4EF6:`));
-      filteredFiles.forEach((file) => {
-        console.log(chalk.gray(`  - ${file.name} (${file.size} bytes)`));
+\u5F00\u59CB\u5907\u4EFD\u8FDC\u7A0B\u6587\u4EF6\uFF0C\u5171 ${downloadedFiles.length} \u4E2A\u6587\u4EF6:`));
+      downloadedFiles.forEach((file) => {
+        console.log(chalk.gray(`  - ${file.remotePath} (${file.size} bytes)`));
       });
     }
-    for (const file of filteredFiles) {
-      if (file.type === 1) {
-        await client.downloadTo(path.join(tempDir.path, file.name), normalizePath(`${dir}/${file.name}`));
-      }
-    }
     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 ${chalk.yellow(
@@ -637,18 +694,19 @@ async function createBackupFile(client, dir, protocol, baseUrl, showBackFile = f
 async function createZipFile(sourceDir, outputPath) {
   return new Promise((resolve, reject) => {
     const output = fs.createWriteStream(outputPath);
-    const archive = archiver("zip", {
-      zlib: { level: 9 }
-    });
-    output.on("close", () => {
-      resolve();
-    });
-    archive.on("error", (err) => {
-      reject(err);
-    });
-    archive.pipe(output);
-    archive.directory(sourceDir, false);
-    archive.finalize();
+    const zipFile = new yazl.ZipFile();
+    const handleError = (error) => {
+      reject(error instanceof Error ? error : new Error(String(error)));
+    };
+    output.on("close", resolve);
+    output.on("error", handleError);
+    zipFile.outputStream.on("error", handleError);
+    zipFile.outputStream.pipe(output);
+    for (const relativePath of getAllFiles(sourceDir)) {
+      const filePath = path.join(sourceDir, relativePath);
+      zipFile.addFile(filePath, normalizePath(relativePath));
+    }
+    zipFile.end();
   });
 }
 async function createSingleBackup(client, dir, protocol, baseUrl, singleBackFiles, showBackFile = false) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-deploy-ftp",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",
@@ -32,6 +32,7 @@
   "description": "将dist目录下的文件上传到ftp服务器",
   "devDependencies": {
     "@types/node": "^22.15.32",
+    "@types/yazl": "^3.3.0",
     "tsup": "^8.5.0",
     "typescript": "^5.8.3"
   },
@@ -40,12 +41,11 @@
   },
   "dependencies": {
     "@inquirer/prompts": "^7.5.3",
-    "@types/archiver": "^6.0.3",
-    "archiver": "^7.0.1",
     "basic-ftp": "^5.0.5",
     "chalk": "^5.4.1",
     "dayjs": "^1.11.13",
-    "ora": "^8.2.0"
+    "ora": "^8.2.0",
+    "yazl": "^3.3.1"
   },
   "scripts": {
     "build": "tsup",