ql-publish 0.0.1

package/upload/reset.js

@@ -0,0 +1,353 @@
+const config = require('../config/config.js')[process.env.NODE_ENV];
+const inquirer = require('inquirer');
+const logger = require('../utils/logger');
+const readline = require('readline');
+const refreshCdn = require('../cdn/refresh')
+const { Client } = require("ssh2");
+const path = require("path");
+const { PassThrough } = require("stream");
+const dayjs = require("dayjs");
+
+
+/**
+ * 确保目录存在，如果不存在则创建
+ * @param {Object} sftp - SFTP客户端实例
+ * @param {string} dirPath - 目录路径
+ */
+function ensureDirectoryExists(sftp, dirPath) {
+    return new Promise((resolve, reject) => {
+        sftp.stat(dirPath, (err) => {
+            if (!err) {
+                // 目录已存在
+                resolve();
+                return;
+            }
+
+            // 递归创建父目录
+            const parentDir = path.posix.dirname(dirPath);
+            if (parentDir === dirPath) {
+                // 已经是根目录
+                reject(new Error(`无法创建目录: ${dirPath}`));
+                return;
+            }
+
+            // 先确保父目录存在，再创建当前目录
+            ensureDirectoryExists(sftp, parentDir)
+                .then(() => {
+                    sftp.mkdir(dirPath, (err) => {
+                        if (err) {
+                            reject(new Error(`创建目录失败 ${dirPath}: ${err.message}`));
+                        } else {
+                            // console.log(`已创建目录: ${dirPath}`);
+                            resolve();
+                        }
+                    });
+                })
+                .catch(reject);
+        });
+    });
+}
+
+const reduceLog = () => {
+    return Math.random() * 2 > 1.98
+}
+
+
+/**
+ * 复制单个文件
+ * @param {Object} sftp - SFTP客户端实例
+ * @param {string} sourcePath - 源文件路径
+ * @param {string} targetPath - 目标文件路径
+ */
+function copyFile(sftp, sourcePath, targetPath) {
+    return new Promise((resolve) => {
+        const readStream = sftp.createReadStream(sourcePath);
+        const writeStream = sftp.createWriteStream(targetPath);
+        const transferStream = new PassThrough();
+
+        // 错误处理
+        readStream.on('error', (err) => {
+            console.error(`读取文件失败 ${sourcePath}: ${err.message}`);
+            resolve(false);
+        });
+
+        writeStream.on('error', (err) => {
+            console.error(`写入文件失败 ${targetPath}: ${err.message}`);
+            resolve(false);
+        });
+
+        writeStream.on('close', () => {
+            // console.log(`写入流已关闭: ${targetPath}`);
+            reduceLog(1.9) && logger.log(`✅ 已复制到: ${targetPath}`);
+            resolve(true);
+        });
+
+        // 完成处理
+        writeStream.on('finish', () => {
+            // console.log(`已复制: ${sourcePath}`);
+            resolve(true);
+        });
+
+        // 管道传输
+        readStream.pipe(transferStream).pipe(writeStream);
+    });
+}
+
+/**
+ * 递归复制目录内容
+ * @param {Object} sftp - SFTP客户端实例
+ * @param {string} currentSourceDir - 当前源目录
+ * @param {string} currentTargetDir - 当前目标目录
+ */
+async function recursiveCopy(sftp, currentSourceDir, currentTargetDir) {
+    // 确保目标目录存在
+    await ensureDirectoryExists(sftp, currentTargetDir);
+
+    // 获取源目录中的所有项目
+    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);
+        const targetPath = path.posix.join(currentTargetDir, item.filename);
+
+        if (item.attrs.isDirectory()) {
+            // 如果是目录，递归处理
+            await recursiveCopy(sftp, sourcePath, targetPath);
+        } else {
+            // 如果是文件，直接复制
+            await copyFile(sftp, sourcePath, targetPath);
+        }
+    }
+}
+
+const resetDir = async (sftp, resetName) => {
+    logger.warn(`开始回滚代码`, `从${config.path}_old/${resetName}/，到${config.path}/`);
+    const oldDir = `${config.path}_old/${resetName}/`;
+    // 备份上一次的代码
+    await recursiveCopy(sftp, oldDir, `${config.path}/`);
+}
+
+const authProjectName = (name) => {
+    return new Promise((resolve) => {
+        // 创建readline接口
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        // 向用户提问
+        rl.question(`${process.env.NODE_ENV}环境：是否确认回滚 ${name} 项目? (输入 y 继续) `, (answer) => {
+            // 检查用户输入是否为'y'（不区分大小写）
+            if (answer.trim().toLowerCase() === 'y') {
+                resolve(true);
+            } else {
+                logger.error('❌ 发布程序终止');
+                resolve(false);
+            }
+            // 关闭接口
+            rl.close();
+        });
+    })
+}
+
+/**
+ * 获取文件列表
+ */
+const getFileList = () => {
+    return new Promise(async resolve => {
+        const { sftp, close } = await getSftp();
+        const authDirectoryByName = (name) => {
+            return new Promise(r => {
+                // 检查目录是否存在
+                sftp.stat(name, (err, stats) => {
+                    if (!err && stats.isDirectory()) {
+                        r(true)
+                        return;
+                    }
+                    // 目录不存在，创建目录
+                    sftp.mkdir(name, (err) => {
+                        if (err) {
+                            console.error(`❌ 创建目录 ${name} 失败:`, err);
+                            process.exit(1);
+                            r(false)
+                        } else {
+                            logger.log(`✅ 目录 ${name} 创建成功`);
+                            r(true)
+                        }
+                        close();
+                    });
+                });
+            })
+        }
+
+        if (!await authDirectoryByName(`${config.path}_old`)) {
+            process.exit(1);
+            return
+        }
+
+        // 读取目录内容
+        sftp.readdir(`${config.path}_old`, (err, list) => {
+            if (err) {
+                console.error('读取目录失败:', err);
+                process.exit(1);
+                return;
+            }
+
+            // 遍历并显示目录内容
+            resolve(list.map(item => {
+                return item.filename
+            }).sort((a, b) => {
+                let _a = a.split('_');
+                _a = `${_a[0]}-${_a[1]}-${_a[2]} ${_a[3]}:${_a[4]}:${_a[5]}`;
+
+                let _b = b.split('_');
+                _b = `${_b[0]}-${_b[1]}-${_b[2]} ${_b[3]}:${_b[4]}:${_b[5]}`;
+
+                return dayjs(_b).diff(dayjs(_a));
+            }));
+        });
+    })
+}
+
+const sftpReaddir = async (sftp, pathStr) => {
+    return new Promise((resolve) => {
+        // 读取目录内容
+        sftp.readdir(pathStr, (err, entries) => {
+            if (err) {
+                logger.error(`❌ 读取目录失败 ${pathStr}: ${err.message}`);
+                resolve([]);
+            } else {
+                resolve(entries);
+            }
+        });
+    })
+}
+
+// 递归删除文件夹及其内容
+async function deleteRemoteDirectory(sftp, pathStr) {
+    try {
+        // 获取目录下的所有条目
+        const entries = await sftpReaddir(sftp, pathStr);
+        // 先删除目录中的所有内容
+        for (const entry of entries) {
+            const fullPath = `${pathStr}/${entry.filename}`;
+            // 判断是文件还是目录
+            if (entry.attrs.isDirectory()) {
+                // 递归删除子目录
+                await deleteRemoteDirectory(sftp, fullPath);
+            } else {
+                // 删除文件
+                await sftp.unlink(fullPath);
+            }
+        }
+        // 最后删除空目录
+        await sftp.rmdir(pathStr);
+        logger.log(`✅ 已删除目录: ${pathStr}`);
+    } catch (err) {
+        logger.error(`❌ 删除过程中出错: ${err.message}`);
+        process.exit(1);
+    }
+}
+
+const getSftp = () => {
+    return new Promise(async resolve => {
+        let conn, sftp;
+        try {
+            logger.warn('连接到服务器...');
+            // 连接到服务器
+            conn = new Client();
+            await new Promise((r, reject) => {
+                conn.on('ready', r);
+                conn.on('error', (err) => reject(new Error(`❌ 服务器连接失败: ${err.message}`)));
+                conn.connect(config);
+            });
+            logger.info('✅ 已成功连接到服务器');
+
+            // 初始化SFTP
+            sftp = await new Promise((r, reject) => {
+                conn.sftp((err, sftpClient) => {
+                    if (err) {
+                        reject(new Error(`SFTP初始化失败: ${err.message}`));
+                    } else {
+                        r(sftpClient);
+                    }
+                });
+            });
+            resolve({
+                sftp,
+                conn,
+                close: () => {
+                    if (sftp) sftp.end();
+                    if (conn) conn.end();
+                }
+            });
+        } catch (err) {
+            logger.error('❌ 过程出错:', err.message);
+            process.exit(1);
+        }
+    })
+}
+
+async function run() {
+    if (!await authProjectName(config.path)) {
+        process.exit(1);
+    }
+    try {
+        let folderNames = await getFileList();
+
+        if (!folderNames || folderNames.length === 0) {
+            process.exit(1);
+        }
+
+        // 创建交互式问题
+        const questions = [
+            {
+                type: 'list',
+                name: 'selectedOption',
+                message: '请使用上下键选择一个版本进行回滚，按回车确认:',
+                choices: folderNames,
+                // 可选：设置默认选中的索引
+                default: 0
+            }
+        ];
+
+        // 执行交互
+        inquirer.prompt(questions).then(async answers => {
+            logger.warn(`回滚版本号: ${answers.selectedOption}`);
+            if (!await authProjectName(answers.selectedOption)) {
+                process.exit(1);
+            }
+            const { sftp, close } = await getSftp();
+            // 删除目标文件夹代码
+            await deleteRemoteDirectory(sftp, config.path);
+
+            // 恢复目标日期代码
+            await resetDir(sftp, answers.selectedOption)
+            close();
+            logger.success(`🎉 ${process.env.NODE_ENV}环境：项目回滚完成!`);
+            config.cdn && config.cdn.list && await refreshCdn(config.cdn.list);
+            process.exit(0);
+        }).catch(error => {
+            if (error.isTtyError) {
+                logger.error('❌ 终端不支持交互模式');
+            } else {
+                logger.error(`❌ ${process.env.NODE_ENV}环境：回滚过程中发生错误:`);
+                logger.error(error);
+                process.exit(1);
+            }
+        });
+    } catch (err) {
+        logger.error('❌ 过程出错:', err.message);
+    }
+}
+
+run();

package/upload/resetOss.js

@@ -0,0 +1,234 @@
+const config = require('../config/config.js')[process.env.NODE_ENV];
+const OSS = require('ali-oss');
+const inquirer = require('inquirer');
+const logger = require('../utils/logger');
+const readline = require('readline');
+const refreshCdn = require('../cdn/refresh')
+
+// 初始化OSS客户端
+const client = new OSS(config);
+
+const reduceLog = () => {
+    return Math.random() * 2 > 1.98
+}
+
+/**
+ * 复制OSS中的文件夹到指定目录
+ * @param {string} sourcePrefix - 源文件夹前缀（如: 'source-folder/'）
+ * @param {string} targetBucket - 目标Bucket名称（可以与源Bucket相同）
+ * @param {string} targetPrefix - 目标文件夹前缀（如: 'target-folder/'）
+ * @param {string} [delimiter=''] - 分隔符，用于列出文件夹下的文件
+ */
+async function copyFolder(sourcePrefix, targetBucket, targetPrefix, delimiter = '') {
+    try {
+        let marker = '';
+        const maxKeys = 100; // 每次最多获取100个文件，可根据需要调整
+
+        do {
+            // 列出源文件夹下的文件
+            const result = await client.list({
+                prefix: sourcePrefix,
+                marker,
+                maxKeys,
+                delimiter
+            });
+
+            // 复制文件
+            if (result.objects && result.objects.length > 0) {
+                for (let file of result.objects) {
+                    // 构建目标文件路径
+                    const targetPath = targetPrefix + file.name.replace(sourcePrefix, '');
+
+                    try {
+                        // 复制文件
+                        await client.copy(targetPath, file.name);
+                        reduceLog() && logger.log(`✅ 已复制: ${file.name} -> ${targetPath}`);
+                    } catch (err) {
+                        logger.error(`❌ 复制失败 ${file.name}:`, err.message);
+                        throw new Error(err.message)
+                    }
+                }
+            }
+
+            // 处理子目录（如果有）
+            if (result.prefixes && result.prefixes.length > 0) {
+                for (const prefix of result.prefixes) {
+                    // 递归复制子目录
+                    await copyFolder(prefix, targetBucket, targetPrefix, delimiter);
+                }
+            }
+
+            marker = result.nextMarker;
+        } while (marker);
+
+        logger.warn('🎉  文件夹复制完成');
+        return true;
+    } catch (err) {
+        logger.error('❌ 复制文件夹时发生错误:', err);
+        return false;
+    }
+}
+
+/**
+ * 删除OSS中的文件夹及其所有内容
+ * @param {string} folderPath - 要删除的文件夹路径，例如: 'test-folder/'
+ */
+async function deleteFolder(folderPath) {
+    try {
+        let nextMarker = null;
+        let deletedCount = 0;
+
+        do {
+            // 列出文件夹下的所有文件
+            const result = await client.list({
+                prefix: folderPath, // 只列出指定前缀的文件
+                marker: nextMarker, // 分页标记
+                maxKeys: 100 // 每次最多列出100个文件
+            });
+
+            // 添加检查：确保 result.objects 存在且为数组
+            if (!result.objects || result.objects.length === 0) {
+                break;
+            }
+
+            // 准备要删除的文件列表
+            const objects = result.objects.filter(obj => obj && obj.name).map(obj => obj.name);
+
+            try {
+                // 批量删除文件
+                await client.deleteMulti(objects, { quiet: false });
+            } catch (e) {
+                throw new Error(e.message)
+            }
+
+            deletedCount += objects.length;
+            nextMarker = result.nextMarker;
+
+        } while (nextMarker);
+
+        logger.warn(`✅ 成功删除文件夹 "${folderPath}" 及其 ${deletedCount} 个文件`);
+        return true;
+
+    } catch (err) {
+        logger.error('❌ 删除文件夹失败:', err);
+        throw err;
+    }
+}
+
+const resetDir = async (resetName) => {
+    const sourceFolder = `${config.targetDir}_old/${resetName}/`;
+    // 目标Bucket（可以与源Bucket相同）
+    const targetBucket = config.bucket;
+    // 目标文件夹（注意末尾的斜杠）
+    const targetFolder = `${config.targetDir}/`;
+    logger.info(`开始回滚版本 ${sourceFolder} 到 ${targetFolder} 目录`);
+    return await copyFolder(sourceFolder, targetBucket, targetFolder);
+}
+
+const authProjectName = (name) => {
+    return new Promise((resolve) => {
+        // 创建readline接口
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        // 向用户提问
+        rl.question(`是否确认回滚 ${name || config.targetDir} 项目? (输入 y 继续) `, (answer) => {
+            // 检查用户输入是否为'y'（不区分大小写）
+            if (answer.trim().toLowerCase() === 'y') {
+                resolve(true);
+            } else {
+                logger.error('❌ 发布程序终止');
+                resolve(false);
+            }
+            // 关闭接口
+            rl.close();
+        });
+    })
+}
+
+const getDirList = async () => {
+    try {
+        const folderPath = `${config.targetDir}_old/`;
+        let nextMarker = null;
+        let folderNames = [];
+        logger.info(`查询可回滚版本中...`);
+        do {
+            // 列出文件夹下的所有文件
+            const result = await client.list({
+                prefix: folderPath, // 只列出指定前缀的文件
+                marker: nextMarker, // 分页标记
+                maxKeys: 1000 // 每次最多列出100个文件
+            });
+
+            // 添加检查：确保 result.objects 存在且为数组
+            if (!result.objects || result.objects.length === 0) {
+                break;
+            }
+
+            folderNames = [...folderNames, ...result.objects.filter(obj => obj && obj.name)
+                                                    .map(obj => obj.name.split('/')[1])];
+
+            nextMarker = result.nextMarker;
+        } while (nextMarker);
+        logger.warn(`✅ 项目可回滚目录查询成功`);
+        return [...new Set(folderNames)];
+
+    } catch (err) {
+        logger.error('❌ 项目可回滚目录查询失败:', err);
+        throw err;
+    }
+}
+
+async function run() {
+    if (!await authProjectName()) {
+        process.exit(1);
+    }
+
+    const folderNames = await getDirList();
+
+    if (!folderNames || folderNames.length === 0) {
+        process.exit(1);
+    }
+
+    // 创建交互式问题
+    const questions = [
+        {
+            type: 'list',
+            name: 'selectedOption',
+            message: '请使用上下键选择一个版本进行回滚，按回车确认:',
+            choices: folderNames,
+            // 可选：设置默认选中的索引
+            default: 0
+        }
+    ];
+
+    // 执行交互
+    inquirer.prompt(questions).then(async answers => {
+        logger.warn(`回滚版本号: ${answers.selectedOption}`);
+        if (!await authProjectName(answers.selectedOption)) {
+            process.exit(1);
+        }
+        // 删除目标文件夹代码
+        if (!await deleteFolder(`${config.targetDir}/`)) {
+            process.exit(1);
+        }
+        // 备份上一次发版的代码
+        if (!await resetDir(answers.selectedOption)) {
+            process.exit(1);
+        }
+        logger.success('🎉 生产环境：项目回滚完成!');
+        config.cdn && config.cdn.list && refreshCdn(config.cdn.list);
+    }).catch(error => {
+        if (error.isTtyError) {
+            logger.error('❌ 终端不支持交互模式');
+        } else {
+            logger.error('❌ 生产环境：回滚过程中发生错误:');
+            logger.error(error);
+            process.exit(1);
+        }
+    });
+}
+
+run();