ql-publish 0.0.1

package/upload/u.js

@@ -0,0 +1,535 @@
+const config = require('../config/config.js')[process.env.NODE_ENV];
+const scpClient = require('scp2');
+const path = require('path');
+const logger = require('../utils/logger');
+const { Client } = require('ssh2');
+const { PassThrough } = require('stream');
+const dayjs = require("dayjs");
+const refreshCdn = require("../cdn/refresh");
+const readline = require("readline");
+
+const deleteFolder = () => {
+    return new Promise(resolve => {
+        logger.warn('开始连接服务器');
+        // 创建 SSH 客户端
+        const conn = new Client();
+        conn.on('ready', () => {
+            logger.log('✅ 已成功连接到服务器');
+            // 执行清空文件夹的命令（保留文件夹本身）
+            // 命令解释：
+            // - 先检查文件夹是否存在
+            // - 再删除文件夹内所有文件和子目录
+            const clearCommand = `
+                                if [ -d "${config.path}" ]; then
+                                  find "${config.path}" -mindepth 1 -delete
+                                  echo "文件夹内容已清空"
+                                else
+                                  echo "错误：文件夹 ${config.path} 不存在"
+                                  exit 1
+                                fi
+                              `;
+
+            conn.exec(clearCommand, (err, stream) => {
+                if (err) throw err;
+
+                stream.on('close', (code) => {
+                    if (code === 0 || code === 1) {
+                        logger.info(`✅ 成功清空文件夹: ${config.path}`);
+                        resolve(true);
+                    } else {
+                        logger.error(`❌ 清空文件夹失败，退出码: ${code}`);
+                        resolve(null);
+                    }
+                    conn.end(); // 关闭连接
+                }).on('data', () => {
+                    // console.log(`输出: ${data}`);
+                }).stderr.on('data', (data) => {
+                    logger.error(`❌ 错误: ${data}`);
+                });
+            });
+        }).connect(config);
+
+        conn.on('error', (err) => {
+            logger.error('❌ 连接错误:', err);
+            resolve(null);
+        });
+        conn.on('end', () => {});
+    })
+}
+
+/**
+ * 获取文件列表
+ */
+const getFileList = (sftp) => {
+    return new Promise(async resolve => {
+        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)
+                        }
+                    });
+                });
+            })
+        }
+
+        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
+            }));
+        });
+    })
+}
+
+/**
+ * 确保目录存在，如果不存在则创建
+ * @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 = (n = 1.98) => {
+    return Math.random() * 2 > n
+}
+
+
+/**
+ * 复制单个文件
+ * @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);
+        }
+    }
+}
+
+// await readStreamByFile(sftp, `${config.path}/fileMap.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('文件内容解析成功:');
+                console.log(jsonData.deleteList);
+            } catch (parseErr) {
+                logger.error('JSON解析失败:', parseErr);
+                console.log('原始文件内容:', fileContent);
+                process.exit(1);
+            }
+        });
+
+        // 处理读取错误
+        readStream.on('error', (err) => {
+            logger.error('读取文件时发生错误:', err);
+            process.exit(1);
+        });
+    })
+}
+
+const writeStreamToFile = async (sftp, data, filePath) => {
+    return new Promise((resolve) => {
+        // 使用SFTP创建文件并写入内容
+        // 注意：如果文件已存在，会被覆盖
+        const writeStream = sftp.createWriteStream(filePath, {
+            flags: 'w',       // 写入模式，会覆盖现有文件
+            encoding: 'utf8', // 编码格式
+            mode: 0o644       // 文件权限（可读可写）
+        });
+
+        // 写入JS模块内容
+        writeStream.end(data);
+
+        // 处理写入完成事件
+        writeStream.on('finish', () => {
+            console.log(`文件 ${filePath} 已成功创建并写入数据`);
+            resolve();
+        });
+
+        // 处理写入完成事件
+        writeStream.on('close', () => {
+            logger.warn(`✅ 旧项目文件索引已成功创建并写入数据，${filePath}`);
+            resolve();
+        });
+
+        // 处理写入错误
+        writeStream.on('error', (err) => {
+            logger.error('❌ 写入文件时发生错误:', err);
+            process.exit(1);
+        });
+    })
+}
+
+let fileMapData = {
+    mtime: 0
+}
+
+const creatFileMap = async (sftp, currentSourceDir) => {
+    // 获取源目录中的所有项目
+    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 creatFileMap(sftp, sourcePath);
+        } else {
+            fileMapData.mtime = item.attrs.mtime > fileMapData.mtime ? item.attrs.mtime : fileMapData.mtime;
+            
+            // if (sourcePath.indexOf(`assets`) > -1) {
+            //     if (sourcePath.indexOf(`assets/_plugin`) === -1) {
+            //         fileMapData.deleteList.push(sourcePath)
+            //     } else {
+            //         fileMapData.unDeleteList.push(sourcePath);
+            //     }
+            // } else {
+            //     fileMapData.unDeleteList.push(sourcePath);
+            // }
+        }
+    }
+
+    if (fileMapData.mtime === 0) {
+        logger.error(`❌ 旧项目文件索引创建失败，请检查目录 ${currentSourceDir} 是否存在`);
+        process.exit(1);
+    }
+}
+
+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.info(`✅ 已删除目录: ${pathStr}`);
+    } catch (err) {
+        logger.error(`❌ 删除过程中出错: ${err.message}`);
+        throw err;
+    }
+}
+
+const removeOldDir = async (sftp) => {
+    logger.warn('正在删除过期备份');
+    let list = await getFileList(sftp);
+    list = list.filter(fName => {
+        let fileDate = fName.split('_');
+        fileDate.length = 3
+        if (!fileDate.length) return false;
+        fileDate = fileDate.join('-');
+        return dayjs().diff(dayjs(`${fileDate} 00:00:00`), 'seconds') > config.backUpSeconds;
+    })
+
+    for (const item of list) {
+        // 开始删除操作
+        await deleteRemoteDirectory(sftp, `${config.path}_old/${item}`);
+    }
+    logger.info('✅ 过期备份删除成功');
+}
+
+const isHasDir = (sftp, dirPath) => {
+    return new Promise(resolve => {
+        sftp.stat(dirPath, (err) => {
+            resolve(!err);
+        })
+    })
+}
+
+const sshAction = async () => {
+    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)) {
+            return
+        }
+        if (config.backUp) {
+            // 删除三个月之前的备份
+            await removeOldDir(sftp);
+            const oldDir = `${config.path}_old/${dayjs().format("YYYY_MM_DD_HH_mm_ss")}/`;
+            logger.warn(`正在备份项目文件到: ${oldDir}`);
+            // 备份上一次的代码
+            await recursiveCopy(sftp, `${config.path}/`, oldDir);
+            logger.info('✅ 项目备份完成！');
+        }
+        // 生成文件地址路径映像
+        await creatFileMap(sftp, `${config.path}/`);
+        await writeStreamToFile(sftp, JSON.stringify(fileMapData), `${config.path}/fileMap.json`);
+    } catch (err) {
+        logger.error('❌ 过程出错:', err.message);
+    } finally {
+        // 关闭连接
+        if (sftp) sftp.end();
+        if (conn) conn.end();
+        // console.log('连接已关闭');
+    }
+}
+
+const scpAction = async () => {
+    // 清空目标目录文件
+    // if (!await deleteFolder()) {
+    //     process.exit(1);
+    // }
+
+    logger.warn('开始上传文件到服务器...');
+
+    let timer = null;
+
+    const runTimer = () => {
+        timer && clearTimeout(timer);
+        timer = setTimeout(() => {
+            if (!timer) return;
+            logger.log('✅ 拼命上传中...');
+            runTimer();
+        }, Math.random() * 5000 + 1000);
+    }
+
+    runTimer();
+    // 上传文件
+    scpClient.scp(
+        config.localPath,
+        config,
+        async (err) => {
+            clearTimeout(timer);
+            timer = null;
+            if (err) {
+                logger.error(`❌ ${process.env.NODE_ENV}环境：上传失败:`);
+                logger.error(err);
+                process.exit(1);
+            } else {
+                logger.success(`🎉 ${process.env.NODE_ENV}环境：所有文件上传成功!`);
+                // 刷新cdn
+                config.cdn && config.cdn.list && await refreshCdn(config.cdn.list);
+                logger.warn(`接下来1分钟后，记得清理旧项目版本，请手动执行 yarn clear:${process.env.NODE_ENV}`)
+                process.exit(0);
+            }
+        }
+    );
+}
+
+const authProjectName = () => {
+    return new Promise((resolve) => {
+        // 创建readline接口
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        // 向用户提问
+        rl.question(`${process.env.NODE_ENV}环境：是否确认发布 ${config.path} 项目? (输入 y 继续) `, (answer) => {
+            // 检查用户输入是否为'y'（不区分大小写）
+            if (answer.trim().toLowerCase() === 'y') {
+                resolve(true);
+            } else {
+                logger.error('❌ 发布程序终止');
+                resolve(false);
+            }
+            // 关闭接口
+            rl.close();
+        });
+    })
+}
+
+// 上传文件到服务器
+async function run() {
+    if (!await authProjectName()) {
+        process.exit(1);
+    }
+    await sshAction();
+    await scpAction();
+}
+
+module.exports = run;

package/utils/date.js

@@ -0,0 +1,30 @@
+/**
+ * 日期格式化函数
+ * @param {Date} date - 日期对象，默认当前时间
+ * @param {string} format - 格式化字符串，例如：'yyyy-MM-dd HH:mm:ss'
+ * @returns {string} 格式化后的日期字符串
+ */
+function formatDate(date = new Date(), format = 'yyyy-MM-dd HH:mm:ss') {
+    // 补零函数
+    const pad = (num) => num.toString().padStart(2, '0');
+
+    const year = date.getFullYear();
+    const month = pad(date.getMonth() + 1); // 月份从0开始
+    const day = pad(date.getDate());
+    const hours = pad(date.getHours());
+    const minutes = pad(date.getMinutes());
+    const seconds = pad(date.getSeconds());
+    const milliseconds = date.getMilliseconds().toString().padStart(3, '0');
+
+    // 替换格式化字符串中的占位符
+    return format
+        .replace('yyyy', year)
+        .replace('MM', month)
+        .replace('dd', day)
+        .replace('HH', hours)
+        .replace('mm', minutes)
+        .replace('ss', seconds)
+        .replace('SSS', milliseconds);
+}
+
+module.exports = { formatDate };

package/utils/logger.js

@@ -0,0 +1,81 @@
+const { formatDate } = require('./date');
+
+// 定义 ANSI 颜色代码
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    dim: '\x1b[2m',
+    underscore: '\x1b[4m',
+    blink: '\x1b[5m',
+    reverse: '\x1b[7m',
+    hidden: '\x1b[8m',
+
+    // 文本颜色
+    black: '\x1b[30m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+
+    // 背景颜色
+    bgBlack: '\x1b[40m',
+    bgRed: '\x1b[41m',
+    bgGreen: '\x1b[42m',
+    bgYellow: '\x1b[43m',
+    bgBlue: '\x1b[44m',
+    bgMagenta: '\x1b[45m',
+    bgCyan: '\x1b[46m',
+    bgWhite: '\x1b[47m'
+};
+
+// 格式化时间
+function getFormattedTime() {
+    return formatDate()
+}
+
+// 日志工具
+const logger = {
+    // 普通日志 - 白色
+    log: (...args) => {
+        console.log(`${colors.white}[${getFormattedTime()}]`, ...args, colors.reset);
+    },
+
+    // 信息日志 - 蓝色
+    info: (...args) => {
+        console.log(`${colors.blue}[${getFormattedTime()}] [INFO]`, ...args, colors.reset);
+    },
+
+    // 成功日志 - 绿色
+    success: (...args) => {
+        console.log(`${colors.green}[${getFormattedTime()}] [SUCCESS]`, ...args, colors.reset);
+    },
+
+    // 警告日志 - 黄色
+    warn: (...args) => {
+        console.log(`${colors.yellow}[${getFormattedTime()}] [WARN]`, ...args, colors.reset);
+    },
+
+    // 错误日志 - 红色
+    error: (...args) => {
+        console.error(`${colors.red}[${getFormattedTime()}] [ERROR]`, ...args, colors.reset);
+    },
+
+    // 调试日志 - 品红
+    debug: (...args) => {
+        console.log(`${colors.magenta}[${getFormattedTime()}] [DEBUG]`, ...args, colors.reset);
+    },
+
+    // 自定义颜色日志
+    custom: (color, ...args) => {
+        if (colors[color]) {
+            console.log(`${colors[color]}[${getFormattedTime()}]`, ...args, colors.reset);
+        } else {
+            console.log(`[${getFormattedTime()}]`, ...args);
+        }
+    }
+};
+
+module.exports = logger;