node-automator 1.4.27 → 1.4.29

package/commands/backup.js

@@ -5,11 +5,22 @@ const fs = require("node:fs");
 const path = require("node:path");
 const { success, error, warn } = require("../utils/log_tool");
 const { parse, stringify, processRename } = require("../utils/file_tool");
+const { eval_code, get_full_path } = require("./share_data");
+const { formatByteSize } = require("../utils/transform_tool");
+const { debounce, throttle } = require("../utils/func_tool");
 
 class BackupCommand extends BaseCommand {
     async execute() {
-        const { sourceFolder, backupFolder, backupCfgs, verbose } =
-            this.selfData;
+        let {
+            sourceFolder,
+            backupFolder,
+            backupCfgs,
+            verbose,
+            throttleDelay,
+            immediately = true,
+        } = this.selfData;
+        sourceFolder = get_full_path(sourceFolder);
+        backupFolder = get_full_path(backupFolder);
 
         async function backup(bakCfg, filename) {
             const {
@@ -18,15 +29,25 @@ class BackupCommand extends BaseCommand {
                 sourceType,
                 backupFormat,
                 backupFilename,
+                backupFilenameGenerator,
                 backupRename,
                 backupEncoding,
                 backupPrettify,
             } = bakCfg;
             const filepath = path.join(sourceFolder, filename);
-            let backupPath = path.join(
-                backupFolder,
-                backupFilename || filename,
+            const fileSize = fs.statSync(filepath).size;
+            const fileSizeFormatted = formatByteSize(fileSize).replace(
+                /\s/g,
+                "",
             );
+            const backName = backupFilenameGenerator
+                ? eval_code(backupFilenameGenerator)({
+                      filepath,
+                      fileSize,
+                      fileSizeFormatted,
+                  })
+                : backupFilename || filename;
+            let backupPath = path.join(backupFolder, backName);
             let backupData;
             if (sourceType) {
                 backupData = await parse(
@@ -71,6 +92,13 @@ class BackupCommand extends BaseCommand {
             fs.writeFileSync(backupPath, backupData, {
                 encoding: backupEncoding,
             });
+            return {
+                filepath,
+                backupPath,
+                backupData,
+                fileSize,
+                fileSizeFormatted,
+            };
         }
 
         backupCfgs.forEach((bakCfg, index) => {
@@ -80,15 +108,55 @@ class BackupCommand extends BaseCommand {
                 };
             }
         });
-        // 首次备份所有
-        backupCfgs.forEach((cfg) => {
-            const files = glob
-                .sync(path.join(sourceFolder, cfg.sourceFilename))
-                .map((v) => path.relative(sourceFolder, v));
-            files.forEach((file) => {
-                backup(cfg, file);
+        // 首次备份所有文件
+        if (immediately) {
+            backupCfgs.forEach((cfg) => {
+                const files = glob
+                    .sync(path.join(sourceFolder, cfg.sourceFilename))
+                    .map((v) => path.relative(sourceFolder, v));
+                files.forEach((file) => {
+                    backup(cfg, file);
+                });
             });
-        });
+        }
+
+        const BackupByFilename = (filename) => {
+            const bakCfg = backupCfgs.find((cfg) => {
+                const files = glob
+                    .sync(path.join(sourceFolder, cfg.sourceFilename))
+                    .map((v) => path.relative(sourceFolder, v));
+                return files.some((file) => file === filename);
+            });
+            if (bakCfg) {
+                backup(bakCfg, filename)
+                    .then((result) => {
+                        if (!result) {
+                            return;
+                        }
+                        const {
+                            filepath,
+                            backupPath,
+                            backupData,
+                            fileSize,
+                            fileSizeFormatted,
+                        } = result;
+                        (verbose || bakCfg.verbose) &&
+                            success(
+                                `${filename} (${fileSizeFormatted}) 备份成功`,
+                                undefined,
+                                undefined,
+                                true,
+                            );
+                    })
+                    .catch((err) => {
+                        error(`${filename} 备份异常 ${err}`);
+                    });
+            }
+        };
+
+        const RealBackupByFilename = throttleDelay
+            ? throttle(BackupByFilename, throttleDelay)
+            : BackupByFilename;
 
         // 监听文件夹变化
         fs.watch(
@@ -98,22 +166,7 @@ class BackupCommand extends BaseCommand {
             },
             (eventType, filename) => {
                 if (eventType === "change") {
-                    const bakCfg = backupCfgs.find((cfg) => {
-                        const files = glob
-                            .sync(path.join(sourceFolder, cfg.sourceFilename))
-                            .map((v) => path.relative(sourceFolder, v));
-                        return files.some((file) => file === filename);
-                    });
-                    if (bakCfg) {
-                        backup(bakCfg, filename)
-                            .then(() => {
-                                (verbose || bakCfg.verbose) &&
-                                    success(`${filename} 备份成功`);
-                            })
-                            .catch((err) => {
-                                error(`${filename} 备份异常 ${err}`);
-                            });
-                    }
+                    RealBackupByFilename(filename);
                 }
             },
         ).on("error", (err) => {

package/commands/compress.js

@@ -2,38 +2,42 @@ const _path = require("node:path");
 const fs = require("node:fs");
 const { get_fst_file, get_full_path, move } = require("../utils/file_tool");
 const { BaseCommand } = require("./base");
-const { default: imagemin } = require('imagemin');
-const { default: imageminPngquant } = require('imagemin-pngquant');
-const { default: imageminMozjpeg } = require('imagemin-mozjpeg');
+const { default: imagemin } = require("imagemin");
+const { default: imageminPngquant } = require("imagemin-pngquant");
+const { default: imageminMozjpeg } = require("imagemin-mozjpeg");
+const Jimp = require("jimp");
 
 class CompressCommand extends BaseCommand {
     async execute() {
         const data = this.selfData;
         const src = get_fst_file(data.src);
         const dstFile = get_full_path(data.dst, "FILE");
+        fs.copyFileSync(src, dstFile);
         const dstDir = _path.dirname(dstFile);
-        const dstName = _path.basename(dstFile);
-        const tmpFolder = _path.join(this.shareData.AUTOMATOR_SCRATCH, "comporess");
-        if (!fs.existsSync(tmpFolder)) {
-            fs.mkdirSync(tmpFolder, { recursive: true });
+        if (!fs.existsSync(dstDir)) {
+            fs.mkdirSync(dstDir, { recursive: true });
+        }
+        if (data.resize) {
+            const { w, h, scale } = data.resize;
+            const result = await Jimp.read(dstFile);
+            if (w && h) {
+                result.resize(w, h);
+            }
+            if (scale && scale != 1) {
+                result.scale(scale);
+            }
+            await result.writeAsync(dstFile);
         }
         const quality = data.options?.quality || 80;
-        await imagemin([src], {
-            destination: tmpFolder,
+        await imagemin([dstFile], {
+            destination: dstDir,
             plugins: [
                 imageminMozjpeg({ quality: quality }), // 压缩 JPG 图片
                 imageminPngquant({
-                    quality: [0.6, quality / 100],
-                })
-            ]
+                    quality: [quality / 100, quality / 100],
+                }),
+            ],
         });
-        const compressedFile = _path.join(tmpFolder, _path.basename(src));
-        fs.copyFileSync(compressedFile, _path.join(dstDir, dstName));
-        fs.unlinkSync(compressedFile);
-        // const sharp = require("sharp");
-        // const options = data.options;
-        // const fileContent = readFileSync(src);
-        // await sharp(fileContent)[format](options).toFile(dst);
     }
 }
 

package/commands/decrypt.js

@@ -0,0 +1,24 @@
+const { BaseCommand } = require("./base");
+const crypto = require('node:crypto');
+
+class DecryptCommand extends BaseCommand {
+    async execute() {
+        const content = this.content;
+        const { password, salt, algorithm = 'aes-256-cbc', keylen = 32 } = this.selfData;
+        const key = crypto.scryptSync(password, salt, keylen);
+        // 从 Buffer 中提取 IV（前 16 字节）和密文
+        const iv = content.slice(0, 16);
+        const decipher = crypto.createDecipheriv(algorithm, key, iv);
+        let decrypted = decipher.update(content.slice(16)); // Buffer
+        decrypted = Buffer.concat([decrypted, decipher.final()]);
+        return decrypted;
+    }
+
+    getRequireContent() {
+        return true;
+    }
+}
+
+module.exports = {
+    DecryptCommand,
+};

package/commands/encrypt.js

@@ -0,0 +1,27 @@
+const { BaseCommand } = require("./base");
+const crypto = require('node:crypto');
+
+class EncryptCommand extends BaseCommand {
+    async execute() {
+        const content = this.content;
+        const { password, salt, algorithm = 'aes-256-cbc', keylen = 32 } = this.selfData;
+        const key = crypto.scryptSync(password, salt, keylen);
+        const iv = crypto.randomBytes(16);
+        const cipher = crypto.createCipheriv(algorithm, key, iv);
+        // 直接输出二进制 Buffer
+        const encrypted = Buffer.concat([
+            iv, // 将 IV 放在密文前面，方便解密时使用
+            cipher.update(content), // 不指定输出编码 = 返回 Buffer
+            cipher.final() // 返回 Buffer
+        ]);
+        return encrypted;
+    }
+
+    getRequireContent() {
+        return true;
+    }
+}
+
+module.exports = {
+    EncryptCommand,
+};

package/commands/mgr.js

@@ -135,6 +135,9 @@ const { ObfuscateCommand } = require("./obfuscate");
 const { SplitFileCommand } = require("./split_file");
 const { MergeFileCommand } = require("./merge_file");
 const { ZipFolderCommand } = require("./zip_folder");
+const { EncryptCommand } = require('./encrypt');
+const { DecryptCommand } = require('./decrypt');
+const { TinifyCommand } = require('./tinify');
 
 const globalData = {
     executed_cfg: [], // 执行过的配置文件
@@ -521,6 +524,9 @@ function init() {
     register("split_file", SplitFileCommand, false);
     register("merge_file", MergeFileCommand, false);
     register("zip_folder", ZipFolderCommand, false);
+    register("encrypt", EncryptCommand, false);
+    register("decrypt", DecryptCommand, false);
+    register("tinify", TinifyCommand, false);
 }
 
 module.exports = {

package/commands/tinify.js

@@ -0,0 +1,45 @@
+const { BaseCommand } = require("./base");
+const tinify = require("tinify");
+const Jimp = require("jimp");
+const { get_fst_file, get_full_path } = require('../utils/file_tool');
+const { dirname } = require('node:path');
+const fs = require('node:fs');
+
+class TinifyCommand extends BaseCommand {
+    async execute() {
+        const data = this.selfData;
+        tinify.key = data.api_key;
+        const src = get_fst_file(data.src);
+        const dstFile = get_full_path(data.dst, "FILE");
+        fs.copyFileSync(src, dstFile);
+        const dstDir = dirname(dstFile);
+        if (!fs.existsSync(dstDir)) {
+            fs.mkdirSync(dstDir, { recursive: true });
+        }
+        let tinifyData = tinify.fromFile(src);
+        if (data.resize) {
+            const { w, h, scale } = data.resize;
+            if (w && h) {
+                tinifyData = tinifyData.resize({
+                    method: "fit",
+                    width: w,
+                    height: h,
+                });
+            }
+            if (scale && scale != 1) {
+                const result = await Jimp.read(dstFile);
+                const width = result.getWidth();
+                tinifyData = tinifyData.scale({
+                    method: "scale",
+                    width: width * scale,
+                });
+            }
+        }
+        await tinifyData.toFile(dstFile);
+    }
+
+}
+
+module.exports = {
+    TinifyCommand,
+};

package/index.js

@@ -94,6 +94,7 @@ async function MainProcess() {
                 progress(elapsedTime, estimateTime, {
                     desc: "预计耗时",
                     format_time: true,
+                    color: _estimateLeft > 0 ? "reset" : "red",
                 });
             }
         }, timerInterval);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-automator",
-    "version": "1.4.27",
+    "version": "1.4.29",
     "description": "Execute automation with yaml configuration(compatible with json)",
     "main": "index.js",
     "repository": {
@@ -65,6 +65,7 @@
         "spreadsheet-column": "^1.1.1",
         "strip-json-comments": "^3.1.1",
         "temp": "^0.9.4",
+        "tinify": "^1.8.2",
         "typescript-plus": "^3.1.5",
         "websocket": "^1.0.34",
         "xlsx": "^0.17.0",

package/utils/func_tool.js

@@ -99,7 +99,30 @@ function queueAsync(tasks, limit, onProgress) {
     });
 }
 
+function debounce(fn, delay) {
+    let timer = null;
+    return function (...args) {
+        if (timer) clearTimeout(timer);
+        timer = setTimeout(() => {
+            fn.apply(this, args);
+        }, delay);
+    };
+}
+
+function throttle(fn, delay) {
+    let timer = null;
+    return function (...args) {
+        if (timer) return;
+        timer = setTimeout(() => {
+            fn.apply(this, args);
+            timer = null;
+        }, delay);
+    };
+}
+
 module.exports = {
     queue,
     queueAsync,
+    debounce,
+    throttle,
 };

package/utils/transform_tool.js

@@ -505,7 +505,10 @@ function formatByteSize(bytes) {
     if (bytes >= MB) {
         return `${(bytes / MB).toFixed(2)} MB`;
     }
-    return `${(bytes / KB).toFixed(2)} KB`;
+    if (bytes >= KB) {
+        return `${(bytes / KB).toFixed(2)} KB`;
+    }
+    return `${bytes} B`;
 }
 
 function getByteSize(formatedStr) {