ql-publish 0.0.8 → 0.0.9

package/README.md

@@ -0,0 +1,259 @@
+# ql-publish
+
+一个面向前端项目的自动化发布工具，封装了 SSH/SFTP 上传、阿里云 CDN 刷新、OSS 上传与远程旧文件清理等常见发布动作。
+
+## 如何发布本项目到 npm
+
+> 面向本仓库维护者：发布新版本到 [npm registry](https://www.npmjs.com/package/ql-publish) 的标准流程。
+
+1. **登录 npm 账号**（首次或登录过期时执行）
+
+   ```bash
+   npm login
+   # 按提示输入用户名、密码、邮箱、OTP
+   # 验证当前登录身份：
+   npm whoami
+   ```
+
+2. **确认 registry 指向官方源**（如果用过淘宝镜像需切回）
+
+   ```bash
+   npm config get registry
+   # 不是 https://registry.npmjs.org/ 时执行：
+   npm config set registry https://registry.npmjs.org/
+   ```
+
+3. **更新版本号**：修改 [package.json](package.json) 里的 `version`，或使用：
+
+   ```bash
+   npm version patch   # 0.0.9 -> 0.0.10
+   npm version minor   # 0.0.9 -> 0.1.0
+   npm version major   # 0.0.9 -> 1.0.0
+   ```
+
+4. **同步更新文档**：在本 README 「更新日志」追加新版本变更说明。
+
+5. **本地自检**：发布前先看看会被打包进 npm 的文件有哪些。
+
+   ```bash
+   npm pack --dry-run
+   ```
+
+6. **正式发布**
+
+   ```bash
+   npm publish
+   # 如果包名带 scope（如 @xxx/ql-publish）且需要公开：
+   # npm publish --access public
+   ```
+
+7. **验证发布结果**
+
+   ```bash
+   npm view ql-publish version
+   ```
+
+> 注意：npm 已发布的版本号**不可覆盖**，发错了只能 `npm unpublish`（24 小时内）或发布更高版本号修复。
+
+## 安装
+
+```bash
+npm i ql-publish
+# or
+yarn add ql-publish
+# or
+pnpm add ql-publish
+```
+
+## 导出的 API
+
+| 方法 | 用途 |
+| --- | --- |
+| `initConfig(config, coreConfig)` | 注入业务配置与凭证配置，所有后续方法必须先调用一次 |
+| `upload()` | 把本地构建产物通过 SFTP 上传到远程服务器，并写入 `fileMap.json` 作为发布基线 |
+| `clear()` | 根据远程 `fileMap.json` 的 `mtime` 基线，递归清理「修改时间不晚于基线」的旧文件，支持白名单 |
+| `refresh()` | 刷新阿里云 CDN（按 `config[NODE_ENV].cdn` 列表） |
+| `reset()` | 回滚到上一次发布的备份版本（依赖 `backUp: true`） |
+
+## 配置结构
+
+调用方需要构造两个对象：业务配置 `config`、凭证配置 `coreConfig`，分别通过 `initConfig` 传入。
+
+### `config`（业务配置）
+
+```js
+module.exports = {
+  test: {
+    localPath: '本地构建产物目录（绝对路径）',
+    path: '远程服务器部署路径',
+    backUpSeconds: 60 * 60 * 24 * 30, // 备份保留时长（秒）
+    backUp: false,                    // 是否开启备份
+    clearExcludes: ['dist.tar.gz'],   // 清理白名单，详见下文
+  },
+  pro: {
+    localPath: '...',
+    path: '...',
+    backUpSeconds: 60 * 60 * 24 * 7,
+    backUp: true,
+    clearExcludes: ['dist.tar.gz'],
+    cdn: [
+      { type: 'File', url: 'https://example.com/your-app/' },
+      { type: 'File', url: 'https://example.com/your-app/index.html' },
+    ],
+  },
+  oss: {
+    localDir: '本地构建产物目录（绝对路径）',
+    targetDir: 'oss 上的目标前缀',
+    backUpSeconds: 60 * 60 * 24 * 30,
+    cdn: [/* 同上 */],
+  },
+};
+```
+
+### `coreConfig`（凭证配置）
+
+```js
+const fs = require('fs');
+
+module.exports = {
+  cdn: {
+    accessKeyId: process.env.cdn_accessKeyId,
+    accessKeySecret: process.env.cdn_accessKeySecret,
+    endpoint: 'cdn.aliyuncs.com',
+  },
+  test: {
+    host: '服务器 IP',
+    port: 22,
+    username: 'root',
+    privateKey: fs.readFileSync(process.env.id_ed25519),
+  },
+  pro: {
+    host: '...',
+    port: 22,
+    username: 'root',
+    privateKey: fs.readFileSync(process.env.ali_rsa),
+  },
+  oss: {
+    accessKeyId: process.env.oss_accessKeyId,
+    accessKeySecret: process.env.oss_accessKeySecret,
+    region: 'oss-cn-shenzhen',
+    bucket: process.env.oss_bucket,
+  },
+};
+```
+
+## 使用示例
+
+最佳实践是把 4 个动作各自拆成独立脚本，再用 `package.json` 的 `scripts` 串联 `cross-env NODE_ENV=test|pro`。
+
+```js
+// upload.js
+const config = require('./config');
+const coreConfig = require('./core/core');
+const { initConfig, upload } = require('ql-publish');
+
+initConfig(config, coreConfig);
+upload();
+```
+
+```js
+// clear.js
+const config = require('./config');
+const coreConfig = require('./core/core');
+const { initConfig, clear } = require('ql-publish');
+
+initConfig(config, coreConfig);
+clear();
+```
+
+```js
+// refresh.js
+const config = require('./config');
+const coreConfig = require('./core/core');
+const { initConfig, refresh } = require('ql-publish');
+
+initConfig(config, coreConfig);
+refresh();
+```
+
+```js
+// reset.js
+const config = require('./config');
+const coreConfig = require('./core/core');
+const { initConfig, reset } = require('ql-publish');
+
+initConfig(config, coreConfig);
+reset();
+```
+
+```json
+// package.json 片段
+{
+  "scripts": {
+    "upload:test": "cross-env NODE_ENV=test node ./upload/index.js",
+    "upload:pro":  "cross-env NODE_ENV=pro  node ./upload/index.js",
+    "clear:test":  "cross-env NODE_ENV=test node ./upload/clear.js",
+    "clear:pro":   "cross-env NODE_ENV=pro  node ./upload/clear.js",
+    "refresh:cdn": "cross-env NODE_ENV=pro  node ./upload/refresh.js",
+    "reset:test":  "cross-env NODE_ENV=test node ./upload/reset.js",
+    "reset:pro":   "cross-env NODE_ENV=pro  node ./upload/reset.js"
+  }
+}
+```
+
+## `clearExcludes` 清理白名单（v0.0.9+）
+
+`clear()` 默认会把远程目录下「mtime 不晚于发布基线」的旧文件全部删除。若你的发布流程在服务器上保留了**与版本无关的常驻文件**（例如压缩包归档、人工上传的资源），可以通过 `clearExcludes` 让它们免删。
+
+### 配置位置
+
+```js
+// config.js
+module.exports = {
+  test: {
+    // ...其它字段
+    clearExcludes: ['dist.tar.gz'],
+  },
+  pro: {
+    // ...其它字段
+    clearExcludes: ['dist.tar.gz'],
+  },
+};
+```
+
+### 三类匹配规则
+
+| 规则形态 | 匹配方式 | 大小写 | 示例 |
+| --- | --- | --- | --- |
+| 以 `.` 开头 | 扩展名后缀匹配（`endsWith`），支持多段后缀 | 不区分 | `.tar.gz`、`.zip` |
+| 含 `*` 字符 | 子串匹配（去掉所有 `*` 后用 `includes`） | 区分 | `*keep*`、`backup-*` |
+| 其它 | 文件名精确匹配（`===`） | 区分 | `dist.tar.gz`、`fileMap.json` |
+
+任一规则命中即跳过删除。
+
+### 配置示例
+
+```js
+// 1) 只想保留某个具体文件
+clearExcludes: ['dist.tar.gz']
+
+// 2) 想保留全部压缩包归档
+clearExcludes: ['.tar.gz', '.zip']
+
+// 3) 想保留所有名字里带 keep 的文件，且排除所有 .zip
+clearExcludes: ['*keep*', '.zip']
+```
+
+### 行为说明
+
+- 白名单**只作用于文件层级**：目录始终会被递归进入，以便清理其子文件。
+- 命中白名单时控制台会打印 `⏭ 已保留文件: <远程路径>`，便于核对。
+- 启动时若 `clearExcludes` 非空，会先打印 `🛡 本次清理将保留以下规则命中的文件: [...]`，供发布者在二次确认之前可视化检查规则。
+- 未配置 / 配置为空数组 / 非数组类型 → 退化为**无白名单**，行为与 `0.0.8` 完全一致，可零成本升级。
+
+## 更新日志
+
+### 0.0.9
+
+- 新增 `clearExcludes` 配置，支持「精确文件名 / 扩展名后缀 / 子串」三类规则跳过清理。
+- 旧版本零破坏性升级：未配置该字段时行为与 `0.0.8` 完全一致。

package/config/config.js

@@ -24,11 +24,13 @@ module.exports = {
         // 项目旧版本代码保存最近3个月备份
         backUpSeconds: _config.test.backUpSeconds,
         // 如果私钥有密码，需要提供
-        // passphrase: 'your-passphrase', 
+        // passphrase: 'your-passphrase',
         // 服务器上的部署路径
         path: _config.test.path,
         // 是否备份
         backUp: _config.test.backUp,
+        // 清理时跳过的文件白名单（支持精确名 / .扩展名 / *子串 三种规则）
+        clearExcludes: _config.test.clearExcludes,
     },
     pro: {
         localPath: _config.pro.localPath,
@@ -40,11 +42,13 @@ module.exports = {
         // 项目旧版本代码保存最近3个月备份
         backUpSeconds: _config.pro.backUpSeconds,
         // 如果私钥有密码，需要提供
-        // passphrase: 'your-passphrase', 
+        // passphrase: 'your-passphrase',
         // 服务器上的部署路径
         path: _config.pro.path,
         // 是否备份
         backUp: _config.pro.backUp,
+        // 清理时跳过的文件白名单（支持精确名 / .扩展名 / *子串 三种规则）
+        clearExcludes: _config.pro.clearExcludes,
         // cdn 配置
         ...ossConfigCdn(),
     },

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ql-publish",
-    "version": "0.0.8",
+    "version": "0.0.9",
     "scripts": {},
     "dependencies": {
         "@alicloud/cdn20180510": "^7.0.1",

package/upload/clear.js

@@ -1,159 +1,267 @@
-const config = require('../config/config.js')[process.env.NODE_ENV];
-const logger = require('../utils/logger');
-const { Client } = require('ssh2');
-const readline = require("readline");
-const path = require("path");
-
-const readStreamByFile = async (sftp, remoteFilePath) => {
-    return new Promise((resolve) => {
-        console.log(`准备读取文件: ${remoteFilePath}`);
-
-        // 创建读取流
-        const readStream = sftp.createReadStream(remoteFilePath, {
-            encoding: 'utf8' // 以UTF-8编码读取
-        });
-
-        let fileContent = '';
-
-        // 收集文件内容
-        readStream.on('data', (chunk) => {
-            fileContent += chunk;
-        });
-
-        // 读取完成处理
-        readStream.on('end', () => {
-            try {
-                // 解析JSON数据
-                const jsonData = JSON.parse(fileContent);
-                console.log('文件内容解析成功:');
-                resolve(jsonData)
-            } catch (parseErr) {
-                logger.error('JSON解析失败:', parseErr);
-                console.log('原始文件内容:', fileContent);
-                process.exit(1);
-            }
-        });
-
-        // 处理读取错误
-        readStream.on('error', (err) => {
-            logger.error('读取文件时发生错误:', err);
-            process.exit(1);
-        });
-    })
-}
-
-const isHasDir = (sftp, dirPath) => {
-    return new Promise(resolve => {
-        sftp.stat(dirPath, (err) => {
-            resolve(!err);
-        })
-    })
-}
-
-const authProjectName = () => {
-    return new Promise((resolve) => {
-        // 创建readline接口
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout
-        });
-
-        // 向用户提问
-        rl.question(`${process.env.NODE_ENV}环境：是否确认删除map映射文件 ${config.path} 项目? (输入 y 继续) `, (answer) => {
-            // 检查用户输入是否为'y'（不区分大小写）
-            if (answer.trim().toLowerCase() === 'y') {
-                resolve(true);
-            } else {
-                logger.error('❌ 发布程序终止');
-                resolve(false);
-            }
-            // 关闭接口
-            rl.close();
-        });
-    })
-}
-
-const deleteFileByMapJson = async (sftp, currentSourceDir, mtime) => {
-    // 获取源目录中的所有项目
-    const items = await new Promise((resolve, reject) => {
-        sftp.readdir(currentSourceDir, (err, list) => {
-            if (err) {
-                reject(new Error(`读取目录失败 ${currentSourceDir}: ${err.message}`));
-            } else {
-                resolve(list);
-            }
-        });
-    });
-
-    // 处理每个项目
-    for (const item of items) {
-        const sourcePath = path.posix.join(currentSourceDir, item.filename);
-
-        if (item.attrs.isDirectory()) {
-            // 如果是目录，递归处理
-            await deleteFileByMapJson(sftp, sourcePath, mtime);
-        } else {
-            // 删除文件
-            if (mtime >= item.attrs.mtime) {
-                // logger.info(`✅ 已删除文件: ${sourcePath}`);
-                await sftp.unlink(sourcePath);
-            }
-        }
-    }
-}
-
-async function run() {
-    if (!await authProjectName()) {
-        process.exit(1);
-    }
-
-    let conn, sftp;
-
-    try {
-        logger.warn('连接到服务器...');
-        // 连接到服务器
-        conn = new Client();
-        await new Promise((resolve, reject) => {
-            conn.on('ready', resolve);
-            conn.on('error', (err) => reject(new Error(`❌ 服务器连接失败: ${err.message}`)));
-            conn.connect(config);
-        });
-        logger.info('✅ 已成功连接到服务器');
-
-        // 初始化SFTP
-        sftp = await new Promise((resolve, reject) => {
-            conn.sftp((err, sftpClient) => {
-                if (err) {
-                    reject(new Error(`SFTP初始化失败: ${err.message}`));
-                } else {
-                    resolve(sftpClient);
-                }
-            });
-        });
-
-        // 没有项目目录，直接返回
-        if (!await isHasDir(sftp, config.path)) {
-            logger.warn('✅ 新项目，无需清理旧文件')
-            return
-        }
-        // 没有map文件，直接返回
-        if (!await isHasDir(sftp, `${config.path}/fileMap.json`)) {
-            logger.warn('✅ 没有map映射文件，无需清理旧文件')
-            return
-        }
-        const { mtime } = await readStreamByFile(sftp, `${config.path}/fileMap.json`);
-        logger.warn('正在删除文件...')
-        await deleteFileByMapJson(sftp, config.path, mtime);
-        await deleteFileByMapJson(sftp, config.path, mtime);
-        logger.success(`✅ ${process.env.NODE_ENV}环境，根据map删除映射文件成功！`)
-    } catch (err) {
-        logger.error('❌ 过程出错:', err.message);
-    } finally {
-        // 关闭连接
-        if (sftp) sftp.end();
-        if (conn) conn.end();
-        // console.log('连接已关闭');
-    }
-}
-
-run();
+/**
+ * 远程目录清理脚本
+ * 根据已上传的 fileMap.json 中的 mtime（上一次发布时间基线），
+ * 通过 SFTP 递归删除服务器上「修改时间不晚于该基线」的旧文件。
+ * 支持通过 config.clearExcludes 配置白名单跳过指定文件。
+ */
+
+const config = require('../config/config.js')[process.env.NODE_ENV];
+const logger = require('../utils/logger');
+const { Client } = require('ssh2');
+const readline = require("readline");
+const path = require("path");
+
+/**
+ * 通过 SFTP 读取远程 JSON 文件并解析
+ * @param {object} sftp SFTP 客户端
+ * @param {string} remoteFilePath 远程文件路径
+ * @returns {Promise<object>} 解析后的 JSON 对象
+ */
+const readStreamByFile = async (sftp, remoteFilePath) => {
+    return new Promise((resolve) => {
+        console.log(`准备读取文件: ${remoteFilePath}`);
+
+        // 创建读取流
+        const readStream = sftp.createReadStream(remoteFilePath, {
+            encoding: 'utf8' // 以UTF-8编码读取
+        });
+
+        let fileContent = '';
+
+        // 收集文件内容
+        readStream.on('data', (chunk) => {
+            fileContent += chunk;
+        });
+
+        // 读取完成处理
+        readStream.on('end', () => {
+            try {
+                // 解析JSON数据
+                const jsonData = JSON.parse(fileContent);
+                console.log('文件内容解析成功:');
+                resolve(jsonData)
+            } catch (parseErr) {
+                logger.error('JSON解析失败:', parseErr);
+                console.log('原始文件内容:', fileContent);
+                process.exit(1);
+            }
+        });
+
+        // 处理读取错误
+        readStream.on('error', (err) => {
+            logger.error('读取文件时发生错误:', err);
+            process.exit(1);
+        });
+    })
+}
+
+/**
+ * 判断远程路径是否存在（文件或目录均可）
+ * @param {object} sftp SFTP 客户端
+ * @param {string} dirPath 远程路径
+ * @returns {Promise<boolean>}
+ */
+const isHasDir = (sftp, dirPath) => {
+    return new Promise(resolve => {
+        sftp.stat(dirPath, (err) => {
+            resolve(!err);
+        })
+    })
+}
+
+/**
+ * 终端二次确认，避免误删
+ * @returns {Promise<boolean>} 用户输入 y 返回 true，其它返回 false
+ */
+const authProjectName = () => {
+    return new Promise((resolve) => {
+        // 创建readline接口
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        // 向用户提问
+        rl.question(`${process.env.NODE_ENV}环境：是否确认删除map映射文件 ${config.path} 项目? (输入 y 继续) `, (answer) => {
+            // 检查用户输入是否为'y'（不区分大小写）
+            if (answer.trim().toLowerCase() === 'y') {
+                resolve(true);
+            } else {
+                logger.error('❌ 发布程序终止');
+                resolve(false);
+            }
+            // 关闭接口
+            rl.close();
+        });
+    })
+}
+
+/**
+ * 构建清理白名单匹配器
+ * 支持三类规则：
+ *  1) 以 "." 开头：按扩展名后缀匹配（不区分大小写），可处理多段扩展名如 ".tar.gz"
+ *  2) 含 "*" 字符：按子串匹配（去掉所有 "*" 后用 includes 判断，区分大小写）
+ *  3) 其它：按完整文件名精确匹配（区分大小写）
+ * @param {string[]} rawList 原始白名单数组
+ * @returns {(filename: string) => boolean} 匹配函数，命中任一规则即返回 true
+ */
+const buildExcludeMatcher = (rawList) => {
+    // 无配置或类型不合法时，退化为「永不跳过」，保持向后兼容
+    if (!Array.isArray(rawList) || rawList.length === 0) {
+        return () => false;
+    }
+
+    // 将规则按类型分桶，避免每次遍历都重复判断规则形态
+    const extRules = [];      // 扩展名后缀（.tar.gz 等），小写存储
+    const includeRules = [];  // 子串规则
+    const exactRules = [];    // 精确文件名
+
+    for (const item of rawList) {
+        // 跳过非字符串与空串，防御性处理
+        if (typeof item !== 'string' || item.trim() === '') continue;
+        const rule = item.trim();
+
+        if (rule.startsWith('.')) {
+            // 扩展名规则：转小写以便不区分大小写匹配
+            extRules.push(rule.toLowerCase());
+        } else if (rule.includes('*')) {
+            // 子串规则：去掉所有 * 通配符，仅取剩余子串做 includes 判断
+            const sub = rule.replace(/\*/g, '');
+            if (sub) includeRules.push(sub);
+        } else {
+            // 精确文件名规则
+            exactRules.push(rule);
+        }
+    }
+
+    // 返回闭包匹配函数，命中任一桶即视为跳过
+    return (filename) => {
+        if (!filename) return false;
+        const lower = filename.toLowerCase();
+
+        // 1) 扩展名后缀匹配（不区分大小写）
+        for (const ext of extRules) {
+            if (lower.endsWith(ext)) return true;
+        }
+        // 2) 子串匹配（区分大小写）
+        for (const sub of includeRules) {
+            if (filename.includes(sub)) return true;
+        }
+        // 3) 精确文件名匹配（区分大小写）
+        for (const exact of exactRules) {
+            if (filename === exact) return true;
+        }
+        return false;
+    };
+};
+
+/**
+ * 递归遍历远程目录，删除 mtime 不晚于基线的旧文件
+ * 命中白名单的文件保留不删，目录始终递归进入
+ * @param {object} sftp SFTP 客户端
+ * @param {string} currentSourceDir 当前遍历的远程目录
+ * @param {number} mtime 来自 fileMap.json 的发布时间基线
+ * @param {(filename: string) => boolean} shouldSkip 白名单匹配函数
+ */
+const deleteFileByMapJson = async (sftp, currentSourceDir, mtime, shouldSkip) => {
+    // 获取源目录中的所有项目
+    const items = await new Promise((resolve, reject) => {
+        sftp.readdir(currentSourceDir, (err, list) => {
+            if (err) {
+                reject(new Error(`读取目录失败 ${currentSourceDir}: ${err.message}`));
+            } else {
+                resolve(list);
+            }
+        });
+    });
+
+    // 处理每个项目
+    for (const item of items) {
+        const sourcePath = path.posix.join(currentSourceDir, item.filename);
+
+        if (item.attrs.isDirectory()) {
+            // 如果是目录，递归处理（目录不参与白名单匹配，确保能下钻清理子文件）
+            await deleteFileByMapJson(sftp, sourcePath, mtime, shouldSkip);
+        } else {
+            // 白名单命中则保留不删，并打印日志方便发布者核对
+            if (shouldSkip(item.filename)) {
+                logger.info(`⏭ 已保留文件: ${sourcePath}`);
+                continue;
+            }
+            // 删除文件：仅当文件 mtime 不晚于基线（属于"旧版本残留"）才删
+            if (mtime >= item.attrs.mtime) {
+                await sftp.unlink(sourcePath);
+            }
+        }
+    }
+}
+
+/**
+ * 主流程：确认 -> 连接 -> 校验 -> 读取基线 -> 递归清理 -> 关闭连接
+ */
+async function run() {
+    // 1. 终端二次确认，避免误删生产环境
+    if (!await authProjectName()) {
+        process.exit(1);
+    }
+
+    // 2. 构建白名单匹配器，并把规则回显给发布者
+    const shouldSkip = buildExcludeMatcher(config.clearExcludes);
+    if (Array.isArray(config.clearExcludes) && config.clearExcludes.length > 0) {
+        logger.warn(`🛡 本次清理将保留以下规则命中的文件: ${JSON.stringify(config.clearExcludes)}`);
+    }
+
+    let conn, sftp;
+
+    try {
+        logger.warn('连接到服务器...');
+        // 3. 建立 SSH 连接
+        conn = new Client();
+        await new Promise((resolve, reject) => {
+            conn.on('ready', resolve);
+            conn.on('error', (err) => reject(new Error(`❌ 服务器连接失败: ${err.message}`)));
+            conn.connect(config);
+        });
+        logger.info('✅ 已成功连接到服务器');
+
+        // 4. 初始化 SFTP 通道
+        sftp = await new Promise((resolve, reject) => {
+            conn.sftp((err, sftpClient) => {
+                if (err) {
+                    reject(new Error(`SFTP初始化失败: ${err.message}`));
+                } else {
+                    resolve(sftpClient);
+                }
+            });
+        });
+
+        // 5. 前置校验：目标目录不存在 → 视为新项目，直接退出
+        if (!await isHasDir(sftp, config.path)) {
+            logger.warn('✅ 新项目，无需清理旧文件')
+            return
+        }
+        // 6. 前置校验：缺少 fileMap.json → 缺少基线，无法判定旧文件，直接退出
+        if (!await isHasDir(sftp, `${config.path}/fileMap.json`)) {
+            logger.warn('✅ 没有map映射文件，无需清理旧文件')
+            return
+        }
+
+        // 7. 读取基线 mtime
+        const { mtime } = await readStreamByFile(sftp, `${config.path}/fileMap.json`);
+        logger.warn('正在删除文件...')
+
+        // 8. 连续递归两次：第二次用于兜底清理首轮删除后变空的子目录残留
+        await deleteFileByMapJson(sftp, config.path, mtime, shouldSkip);
+        await deleteFileByMapJson(sftp, config.path, mtime, shouldSkip);
+
+        logger.success(`✅ ${process.env.NODE_ENV}环境，根据map删除映射文件成功！`)
+    } catch (err) {
+        logger.error('❌ 过程出错:', err.message);
+    } finally {
+        // 9. 关闭连接，避免句柄泄漏
+        if (sftp) sftp.end();
+        if (conn) conn.end();
+    }
+}
+
+run();