node-automator 1.4.24 → 1.4.26

package/biome.json

@@ -0,0 +1,63 @@
+{
+    "$schema": "https://biomejs.dev/schemas/2.2.4/schema.json",
+    "vcs": {
+        "enabled": false,
+        "clientKind": "git",
+        "useIgnoreFile": false
+    },
+    "files": {
+        "ignoreUnknown": false
+    },
+    "formatter": {
+        "enabled": true,
+        "indentStyle": "space",
+        "indentWidth": 4
+    },
+    "linter": {
+        "enabled": true,
+        "rules": {
+            "recommended": true,
+            "complexity": {
+                "noStaticOnlyClass": "off"
+            },
+            "suspicious": {
+                "noDuplicateClassMembers": "warn",
+                "useIterableCallbackReturn": "warn",
+                "noCompareNegZero": "warn",
+                "noDuplicateElseIf": "warn",
+                "noSelfCompare": "warn",
+                "noFallthroughSwitchClause": "warn",
+                "noDebugger": "warn",
+                "noShadowRestrictedNames": "warn",
+                "noImplicitAnyLet": "warn",
+                "noAssignInExpressions": "warn",
+                "noEmptyInterface": "off",
+                "noDuplicateObjectKeys": "warn",
+                "noDoubleEquals": "warn",
+                "noRedeclare": "warn"
+            },
+            "correctness": {
+                "noPrecisionLoss": "warn",
+                "noSwitchDeclarations": "warn",
+                "noConstantCondition": "warn",
+                "noUnreachable": "warn",
+                "noInvalidUseBeforeDeclaration": "warn",
+                "noInnerDeclarations": "warn",
+                "noSelfAssign": "warn"
+            }
+        }
+    },
+    "javascript": {
+        "formatter": {
+            "quoteStyle": "double"
+        }
+    },
+    "assist": {
+        "enabled": true,
+        "actions": {
+            "source": {
+                "organizeImports": "on"
+            }
+        }
+    }
+}

package/commands/abort.js

@@ -1,11 +1,11 @@
-const { BaseCommand } = require("./base");
-
-class AbortCommand extends BaseCommand {
-    async execute() {
-        throw (this.selfData && this.selfData.prompt) || "任务中止";
-    }
-}
-
-module.exports = {
-    AbortCommand,
-};
+const { BaseCommand } = require("./base");
+
+class AbortCommand extends BaseCommand {
+    async execute() {
+        throw this.selfData?.prompt || "任务中止";
+    }
+}
+
+module.exports = {
+    AbortCommand,
+};

package/commands/alert.js

@@ -1,19 +1,17 @@
-const { showAlert } = require("../utils/alert_tool");
-const { BaseCommand } = require("./base");
-
-class AlertCommand extends BaseCommand {
-    async execute() {
-        let data = this.selfData;
-        await showAlert(data.type, data.msg, data.title);
-    }
-
-    getRequiredParams() {
-        return [
-            "msg",
-        ];
-    }
-}
-
-module.exports = {
-    AlertCommand,
-};
+const { showAlert } = require("../utils/alert_tool");
+const { BaseCommand } = require("./base");
+
+class AlertCommand extends BaseCommand {
+    async execute() {
+        const data = this.selfData;
+        await showAlert(data.type, data.msg, data.title);
+    }
+
+    getRequiredParams() {
+        return ["msg"];
+    }
+}
+
+module.exports = {
+    AlertCommand,
+};

package/commands/ali_oss.js

@@ -1,41 +1,24 @@
 const {
     get_file_list,
     get_full_path,
-    format_bytes
+    format_bytes,
 } = require("../utils/file_tool");
-const {
-    success,
-    getPrint,
-    info,
-    warn,
-    whisper
-} = require("../utils/log_tool");
-const {
-    BaseCommand
-} = require("./base");
-const path = require("path");
-const {
-    progress
-} = require("../utils/display_tool");
-const {
-    createWriteStream, readFileSync
-} = require("fs");
-const {
-    getCache,
-    setCache
-} = require("../utils/cache_tool");
-const crypto = require("crypto");
-const { queueAsync } = require('../utils/func_tool');
-
+const { success, getPrint, info, warn, whisper } = require("../utils/log_tool");
+const { BaseCommand } = require("./base");
+const path = require("node:path");
+const { progress } = require("../utils/display_tool");
+const { createWriteStream, readFileSync } = require("node:fs");
+const { getCache, setCache } = require("../utils/cache_tool");
+const crypto = require("node:crypto");
+const { queueAsync } = require("../utils/func_tool");
 
 class AliOssCommand extends BaseCommand {
     async execute() {
-
-        let config = this.selfData.config;
-        let mode = this.selfData.mode;
+        const config = this.selfData.config;
+        const mode = this.selfData.mode;
 
         return await new Promise((resolve, reject) => {
-            const OSS = require('ali-oss');
+            const OSS = require("ali-oss");
             // 初始化OSS客户端。请将以下参数替换为您自己的配置信息。
             const client = new OSS({
                 region: config.region, // 示例：'oss-cn-hangzhou'，填写Bucket所在地域。
@@ -45,148 +28,228 @@ class AliOssCommand extends BaseCommand {
             });
             switch (mode) {
                 case "DOWNLOAD": {
-                    let src = this.selfData.src;
-                    let dst = get_full_path(this.selfData.dst);
-                    let timeout = this.selfData.options && this.selfData.options.timeout || 1000 * 60 * 2;
-                    client.get(src, dst, {
-                        timeout,
-                    }).then((result) => {
-                        resolve(result);
-                    }).catch((err) => {
-                        reject(err);
-                    });
+                    const src = this.selfData.src;
+                    const dst = get_full_path(this.selfData.dst);
+                    const timeout =
+                        this.selfData.options?.timeout || 1000 * 60 * 2;
+                    client
+                        .get(src, dst, {
+                            timeout,
+                        })
+                        .then((result) => {
+                            resolve(result);
+                        })
+                        .catch((err) => {
+                            reject(err);
+                        });
                     break;
                 }
                 case "UPLOAD_FILE":
                 case "UPLOAD": {
-                    let dst = this.selfData.dst;
-                    let src = get_full_path(this.selfData.src);
-                    let timeout = this.selfData.options && this.selfData.options.timeout || 1000 * 60 * 2;
+                    const dst = this.selfData.dst;
+                    const src = get_full_path(this.selfData.src);
+                    const timeout =
+                        this.selfData.options?.timeout || 1000 * 60 * 2;
                     info("");
                     info(`开始上传 ${path.basename(src)} 到 ${dst}`);
-                    client.put(dst, src, {
-                        timeout,
-                    }).then((result) => {
-                        resolve(result);
-                    })
-                    .catch((err) => {
-                        reject(err);
-                    });
+                    client
+                        .put(dst, src, {
+                            timeout,
+                        })
+                        .then((result) => {
+                            resolve(result);
+                        })
+                        .catch((err) => {
+                            reject(err);
+                        });
                     break;
                 }
                 case "UPLOAD_FILES": {
-                    let dst_folder = this.selfData.dst;
-                    let concurrency = this.selfData.options && this.selfData.options.concurrency || 5;
-                    let timeout = this.selfData.options && this.selfData.options.timeout || 1000 * 60 * 5;
-                    let strategy = this.selfData.options && this.selfData.options.strategy || "hash";
-                    let base = this.selfData.base;
-                    whisper(`在 ${base} 中收集要上传的文件...`, undefined, true);
-                    let srcs = get_file_list(this.selfData.src, undefined, true);
+                    const dst_folder = this.selfData.dst;
+                    const concurrency = this.selfData.options?.concurrency || 5;
+                    const timeout =
+                        this.selfData.options?.timeout || 1000 * 60 * 5;
+                    const strategy = this.selfData.options?.strategy || "hash";
+                    const base = this.selfData.base;
+                    whisper(
+                        `在 ${base} 中收集要上传的文件...`,
+                        undefined,
+                        true,
+                    );
+                    const srcs = get_file_list(
+                        this.selfData.src,
+                        undefined,
+                        true,
+                    );
                     let retryTimes = 0;
-                    let maxRetryTimes = 3;
-                    let cacheKey = `ali_oss/${config.bucket}/${dst_folder}`.replace(/\//g, ".");
-                    let cacheType = this.selfData.cache_type;
-                    let cacheParam = this.selfData.cache_param;
+                    const maxRetryTimes = 3;
+                    const cacheKey =
+                        `ali_oss/${config.bucket}/${dst_folder}`.replace(
+                            /\//g,
+                            ".",
+                        );
+                    const cacheType = this.selfData.cache_type;
+                    const cacheParam = this.selfData.cache_param;
                     let cachedFiles = null;
-                    getCache(cacheKey, cacheType, cacheParam).then((_cachedFiles) => {
-                        cachedFiles = _cachedFiles;
-                        info(`cacheKey=${cacheKey}, cacheType=${cacheType}, cacheParam=${cacheParam},cachedFiles=${JSON.stringify(cachedFiles).substring(0, 20)}`);
-                        if (!cachedFiles || !Object.keys(cachedFiles).length) {
-                            let marker = null; 
-                            var objs = [];
-                            async function list () {
-                                do {
-                                    const result = await client.list({
-                                        prefix: dst_folder + "/",
-                                        marker: marker,
+                    getCache(cacheKey, cacheType, cacheParam).then(
+                        (_cachedFiles) => {
+                            cachedFiles = _cachedFiles;
+                            info(
+                                `cacheKey=${cacheKey}, cacheType=${cacheType}, cacheParam=${cacheParam},cachedFiles=${JSON.stringify(cachedFiles).substring(0, 20)}`,
+                            );
+                            if (
+                                !cachedFiles ||
+                                !Object.keys(cachedFiles).length
+                            ) {
+                                let marker = null;
+                                var objs = [];
+                                async function list() {
+                                    do {
+                                        const result = await client.list({
+                                            prefix: `${dst_folder}/`,
+                                            marker: marker,
+                                        });
+                                        marker = result.nextMarker;
+                                        objs.push.apply(objs, result.objects);
+                                    } while (marker);
+                                    return objs;
+                                }
+                                list().then((objs) => {
+                                    cachedFiles = {};
+                                    objs.forEach((obj) => {
+                                        cachedFiles[obj.name] = obj.etag
+                                            .replaceAll('"', "")
+                                            .toLowerCase();
                                     });
-                                    marker = result.nextMarker;
-                                    objs.push.apply(objs, result.objects);
-                                } while (marker);
-                                return objs;
-                            }
-                            list().then(objs => {
-                                cachedFiles = {};
-                                objs.forEach(obj => {
-                                    cachedFiles[obj.name] = obj.etag.replaceAll("\"", "").toLowerCase();
+                                    setCache(
+                                        cacheKey,
+                                        cachedFiles,
+                                        cacheType,
+                                        cacheParam,
+                                    );
+                                    uploadFiles(srcs);
                                 });
-                                setCache(cacheKey, cachedFiles, cacheType, cacheParam);
+                            } else {
                                 uploadFiles(srcs);
-                            });
-                        } else {
-                            uploadFiles(srcs);
-                        }
-                        function uploadFiles(srcs) {
-                            let rawLength = srcs.length;
-                            // 过滤文件
-                            srcs = srcs.filter(src => {
-                                let cachedValue = cachedFiles[path.join(dst_folder, path.relative(base, src)).replace(/\\/g, "/")];
-                                switch(strategy) {
-                                    case "lazy": {
-                                        if (cachedValue) {
-                                            return false;
+                            }
+                            function uploadFiles(srcs) {
+                                const rawLength = srcs.length;
+                                // 过滤文件
+                                srcs = srcs.filter((src) => {
+                                    const cachedValue =
+                                        cachedFiles[
+                                            path
+                                                .join(
+                                                    dst_folder,
+                                                    path.relative(base, src),
+                                                )
+                                                .replace(/\\/g, "/")
+                                        ];
+                                    switch (strategy) {
+                                        case "lazy": {
+                                            if (cachedValue) {
+                                                return false;
+                                            }
+                                            break;
                                         }
-                                        break;
-                                    }
-                                    case "hash": {
-                                        let hash = crypto.createHash("md5").update(readFileSync(src)).digest("hex");
-                                        if (cachedValue == hash) {
-                                            return false;
+                                        case "hash": {
+                                            const hash = crypto
+                                                .createHash("md5")
+                                                .update(readFileSync(src))
+                                                .digest("hex");
+                                            if (cachedValue === hash) {
+                                                return false;
+                                            }
+                                            break;
+                                        }
+                                        case "force": {
+                                            break;
+                                        }
+                                        default: {
+                                            throw `Unkown Strategy ${strategy}`;
+                                            break;
                                         }
-                                        break;
-                                    }
-                                    case "force": {
-                                        
-                                        break;
-                                    }
-                                    default: {
-                                        throw `Unkown Strategy ${strategy}`;
-                                        break;
                                     }
-                                }
-                                return true;
-                            });
-                            info(`预处理完成!`, "\r");
-                            info(`实际 ${srcs.length}, 忽略 ${rawLength - srcs.length}, 共计 ${rawLength}`);
-
-                            let tasks = srcs.map((src) => {
-                                let dst = path.join(dst_folder, path.relative(base, src)).replace(/\\/g, "/")
-                                return client.put.bind(client, dst, src, {
-                                    timeout,
+                                    return true;
                                 });
-                            });
-                            queueAsync(tasks, concurrency, (done, total, index, ret) => {
-                                progress(done, total, {
-                                    desc: path.relative(base, srcs[index]) + " " + (ret ? (ret.err ? "上传失败!" : "上传成功!") : "上传中..."),
-                                    depth: 0,
+                                info(`预处理完成!`, "\r");
+                                info(
+                                    `实际 ${srcs.length}, 忽略 ${rawLength - srcs.length}, 共计 ${rawLength}`,
+                                );
+
+                                const tasks = srcs.map((src) => {
+                                    const dst = path
+                                        .join(
+                                            dst_folder,
+                                            path.relative(base, src),
+                                        )
+                                        .replace(/\\/g, "/");
+                                    return client.put.bind(client, dst, src, {
+                                        timeout,
+                                    });
                                 });
-                            }).then((result) => {
-                                var retrySrcs = [];
-                                for(var i = 0; i < result.length; i++) {
-                                    if (result[i].err) {
-                                        retrySrcs.push(srcs[i]);
-                                        warn(`上传文件 ${path.relative(base, srcs[i])} 失败: ${result[i].err}`);
-                                    } else {
-                                        // 当前上传的，存储为 hash
-                                        let dst = path.join(dst_folder, path.relative(base, srcs[i])).replace(/\\/g, "/")
-                                        cachedFiles[dst] = crypto.createHash("md5").update(readFileSync(srcs[i])).digest("hex");
+                                queueAsync(
+                                    tasks,
+                                    concurrency,
+                                    (done, total, index, ret) => {
+                                        progress(done, total, {
+                                            desc: `${path.relative(base, srcs[index])} ${ret ? (ret.err ? "上传失败!" : "上传成功!") : "上传中..."}`,
+                                            depth: 0,
+                                        });
+                                    },
+                                ).then((result) => {
+                                    var retrySrcs = [];
+                                    for (var i = 0; i < result.length; i++) {
+                                        if (result[i].err) {
+                                            retrySrcs.push(srcs[i]);
+                                            warn(
+                                                `上传文件 ${path.relative(base, srcs[i])} 失败: ${result[i].err}`,
+                                            );
+                                        } else {
+                                            // 当前上传的，存储为 hash
+                                            const dst = path
+                                                .join(
+                                                    dst_folder,
+                                                    path.relative(
+                                                        base,
+                                                        srcs[i],
+                                                    ),
+                                                )
+                                                .replace(/\\/g, "/");
+                                            cachedFiles[dst] = crypto
+                                                .createHash("md5")
+                                                .update(readFileSync(srcs[i]))
+                                                .digest("hex");
+                                        }
                                     }
-                                }
-                                if (retrySrcs.length > 0) {
-                                    retryTimes++;
-                                    if (retryTimes > maxRetryTimes) {
-                                        setCache(cacheKey, cachedFiles, cacheType, cacheParam);
-                                        reject(`上传文件失败，重试次数超过 ${maxRetryTimes} 次。`);
-                                        return;
+                                    if (retrySrcs.length > 0) {
+                                        retryTimes++;
+                                        if (retryTimes > maxRetryTimes) {
+                                            setCache(
+                                                cacheKey,
+                                                cachedFiles,
+                                                cacheType,
+                                                cacheParam,
+                                            );
+                                            reject(
+                                                `上传文件失败，重试次数超过 ${maxRetryTimes} 次。`,
+                                            );
+                                            return;
+                                        }
+                                        uploadFiles(retrySrcs);
+                                    } else {
+                                        setCache(
+                                            cacheKey,
+                                            cachedFiles,
+                                            cacheType,
+                                            cacheParam,
+                                        );
+                                        resolve(true);
                                     }
-                                    uploadFiles(retrySrcs);
-                                } else {
-                                    setCache(cacheKey, cachedFiles, cacheType, cacheParam);
-                                    resolve(true);
-                                }
-                            });
-                        }
-                    })
+                                });
+                            }
+                        },
+                    );
                     break;
                 }
                 default: {
@@ -200,4 +263,4 @@ class AliOssCommand extends BaseCommand {
 
 module.exports = {
     AliOssCommand,
-};
+};

package/commands/assemble.js

@@ -1,56 +1,54 @@
-const {
-    BaseCommand
-} = require("./base");
-
-/**
- * 把数组(content)中的元素使用指定符号(delimiter)分割，组合得到指定属性名(props)的对象数组(ret)
- * @example
- * content = ["Key1,Key2,Key3", "Value1,Value2,Value3"];
- * delimiter = ",";
- * props = "k,v"
- * // 得到结果
- * ret = [ 
- *   {k: "Key1", v: "Value1"}, 
- *   {k: "Key2", v: "Value2"}, 
- *   {k: "Key3", v: "Value3"}, 
- * ]
- */
-class AssembleCommand extends BaseCommand {
-    async execute() {
-        let delimiter = this.selfData.delimiter;
-        if (delimiter) {
-            delimiter = new RegExp(delimiter);
-        }
-        let props = this.selfData.props;
-        if (delimiter && typeof props === "string") {
-            props = props.split(delimiter);
-        }
-        let arrays = this.content.map(v => delimiter && typeof v === "string" ? v.split(delimiter) : v);
-        let num_item = arrays.reduce((prev, curr) => {
-            return Math.max(prev, curr.length);
-        }, 0);
-        let ret = [];
-        for (let idx_item = 0; idx_item < num_item; ++idx_item) {
-            let tmp = {};
-            props.forEach((v, prop_idx) => {
-                tmp[v] = arrays[prop_idx][idx_item];
-            });
-            ret.push(tmp);
-        }
-        return ret;
-    }
-
-    getRequiredParams() {
-        return [
-            'props'
-        ];
-    }
-
-    getRequireContent() {
-        return true;
-    }
-}
-
-module.exports = {
-    AssembleCommand,
-};
+const { BaseCommand } = require("./base");
+
+/**
+ * 把数组(content)中的元素使用指定符号(delimiter)分割，组合得到指定属性名(props)的对象数组(ret)
+ * @example
+ * content = ["Key1,Key2,Key3", "Value1,Value2,Value3"];
+ * delimiter = ",";
+ * props = "k,v"
+ * // 得到结果
+ * ret = [
+ *   {k: "Key1", v: "Value1"},
+ *   {k: "Key2", v: "Value2"},
+ *   {k: "Key3", v: "Value3"},
+ * ]
+ */
+class AssembleCommand extends BaseCommand {
+    async execute() {
+        let delimiter = this.selfData.delimiter;
+        if (delimiter) {
+            delimiter = new RegExp(delimiter);
+        }
+        let props = this.selfData.props;
+        if (delimiter && typeof props === "string") {
+            props = props.split(delimiter);
+        }
+        const arrays = this.content.map((v) =>
+            delimiter && typeof v === "string" ? v.split(delimiter) : v,
+        );
+        const num_item = arrays.reduce((prev, curr) => {
+            return Math.max(prev, curr.length);
+        }, 0);
+        const ret = [];
+        for (let idx_item = 0; idx_item < num_item; ++idx_item) {
+            const tmp = {};
+            props.forEach((v, prop_idx) => {
+                tmp[v] = arrays[prop_idx][idx_item];
+            });
+            ret.push(tmp);
+        }
+        return ret;
+    }
+
+    getRequiredParams() {
+        return ["props"];
+    }
+
+    getRequireContent() {
+        return true;
+    }
+}
+
+module.exports = {
+    AssembleCommand,
+};