node-automator 1.0.0

package/commands/loop_forever.js

@@ -0,0 +1,66 @@
+const transform_tool = require("../utils/transform_tool");
+const { progress } = require("../utils/display_tool");
+const { getLastError, resetError, log } = require("../utils/log_tool");
+const { BaseCommand, PROCESS_STATE } = require("./base");
+const { formatData } = require("./share_data");
+
+class LoopForeverCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        let show_progress = this.selfCfg.show_progress;
+        for (let loop_index = 0; true; loop_index++) {
+            if (this.globalData.process_state === PROCESS_STATE.BREAK) {
+                this.resetProcessState();
+                break;
+            } else if (this.globalData.process_state === PROCESS_STATE.CONTINUE) {
+                this.resetProcessState();
+            }
+            let loop_key = loop_index;
+            // 键索引值映射
+            if (data.index_mapping) {
+                this.shareData[data.index_mapping] = loop_index;
+            } else {
+                this.shareData['loop_index'] = loop_index;
+            }
+            // 键映射
+            if (data.key_mapping) {
+                this.shareData[data.key_mapping] = loop_key;
+            } else {
+                this.shareData['loop_key'] = loop_key;
+            }
+            if (show_progress) {
+                log("");
+                progress(loop_index, 0, { desc: `> ${this.selfCfg.title || this.selfCfg.type}`, color: "white"});
+                log("");
+            }
+            let commandCfgs = data.commands;
+            // 特殊处理字符的情况
+            if (typeof commandCfgs === "string") {
+                commandCfgs = formatData(commandCfgs);
+            }
+            // 默认从循环开始执行，增加深度
+            await this.exec(commandCfgs, this.depth + 1);
+            if (show_progress) {
+                if (!getLastError()) {
+                    progress(loop_index + 1, 0, {desc: `✔ ${this.selfCfg.title || this.selfCfg.type}`, color: "cyan"});
+                } else {
+                    progress(loop_index + 1, 0, {desc: `✖ ${this.selfCfg.title || this.selfCfg.type}`, color: "red"});
+                }
+                log("");
+            }
+            if (getLastError()) {
+                if (this.selfCfg.ignore_error) {
+                    resetError(this.selfCfg.ignore_error);
+                } else {
+                    throw getLastError();
+                }
+            }
+        }
+        // 最后一个循环结束后，需要重置掉执行状态
+        this.resetProcessState();
+    }
+}
+
+module.exports = {
+    LoopForeverCommand,
+};

package/commands/merge_files.js

@@ -0,0 +1,39 @@
+const path = require("path");
+const fs = require("fs");
+const { get_file_list, read_cfg, write_with_type, get_fst_file } = require("../utils/file_tool");
+const { BaseCommand } = require("./base");
+
+class MergeFilesCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        let src_files = get_file_list(data.src);
+        if (!fs.existsSync(data.dst) || !fs.lstatSync(data.dst).isDirectory()) {
+            try {
+                fs.mkdirSync(data.dst, {
+                    recursive: true
+                });
+            } catch (err) {
+                throw (err);
+            }
+        }
+        for (let i = 0; i < src_files.length; i++) {
+            let src_file = src_files[i];
+            let src_data = await read_cfg(src_file);
+            let dst_data;
+            let dst_file = path.join(get_fst_file(data.dst), path.relative(get_fst_file(data.base), src_file));
+            if (fs.existsSync(dst_file)) {
+                dst_data = await read_cfg(dst_file);
+            } else {
+                dst_data = {};
+            }
+            for (let k in src_data) {
+                dst_data[k] = src_data[k];
+            }
+            await write_with_type(dst_data, dst_file, undefined, data.options);
+        }
+    }
+}
+
+module.exports = {
+    MergeFilesCommand,
+};

package/commands/mgr.js

@@ -0,0 +1,476 @@
+const { progress } = require("../utils/display_tool");
+const { eval_code } = require("./share_data");
+const { read_plain } = require("../utils/file_tool");
+const { pause } = require("../utils/interaction_tool");
+const { whisper, getPrint, resetError, getLastError, warn, log, error, setLastError } = require("../utils/log_tool");
+const { AbortCommand } = require("./abort");
+const { BaseCommand, PROCESS_STATE } = require("./base");
+const { BreakCommand } = require("./break");
+const { CommitCommand } = require("./commit");
+const { ConfirmCommand } = require("./confirm");
+const { ContinueCommand } = require("./continue");
+const { CopyCommand } = require("./copy");
+const { WriteClipboard } = require("./write_clipboard");
+const { ReadClipboard } = require("./read_clipboard");
+const { DateCommand } = require("./date");
+const { DebuggerCommand } = require("./debugger");
+const { EvalCommand } = require("./eval");
+const { ExecFromFileCommand } = require("./exec_from_file");
+const { ExportDiffHeadCommand } = require("./export_diff_head");
+const { FilesCommand } = require("./files");
+const { FirstExistCommand } = require("./first_exist");
+const { FlattenCommand } = require("./flatten");
+const { GitCommitCommand } = require("./git_commit");
+const { GitExportDiffHeadCommand } = require("./git_export_diff_head");
+const { GitIsDirtyCommand } = require("./git_is_dirty");
+const { HTTPRequestCommand } = require("./http_request");
+const { InputCommand } = require("./input");
+const { IsDirtyCommand } = require("./is_dirty");
+const { List2DictCommand } = require("./list2dict");
+const { LoopCommand } = require("./loop");
+const { LoopForeverCommand } = require("./loop_forever");
+const { ModifyCommand } = require("./modify");
+const { MoveCommand } = require("./move");
+const { MultiSelectCommand } = require("./multi_select");
+const { OpenCommand } = require("./open");
+const { ParseCommand } = require("./parse");
+const { PauseCommand } = require("./pause");
+const { PrintCommand } = require("./print");
+const { ReadCfgCommand } = require("./read_cfg");
+const { ReadPlainCommand } = require("./read_plain");
+const { RemoveCommand } = require("./remove");
+const { RetrieveCommand } = require("./retrieve");
+const { RevealCommand } = require("./reveal");
+const { SelectCommand } = require("./select");
+const { ShellCommand } = require("./shell");
+const { SleepCommand } = require("./sleep");
+const { StoreCommand } = require("./store");
+const { StringifyCommand } = require("./stringify");
+const { SvnCommitCommand } = require("./svn_commit");
+const { SVNExportDiffHeadCommand } = require("./svn_export_diff_head");
+const { SvnIsDirtyCommand } = require("./svn_is_dirty");
+const { SvnUpdateCommand } = require("./svn_update");
+const { TestCommand } = require("./test");
+const { TruncateCommand } = require("./truncate");
+const { TruncateAllCommand } = require("./truncate_all");
+const { ValidRequiredCommand } = require("./valid_required");
+const { VoidCommand } = require("./void");
+const { WhichCommand } = require("./which");
+const { WriteCfgCommand } = require("./write_cfg");
+const { WritePlainCommand } = require("./write_plain");
+const { ZipCommand } = require("./zip");
+const { MoveLocalCommand } = require("./move_local");
+const { EditCommand } = require("./edit");
+const { ScheduleCommand } = require("./schedule");
+const { AlertCommand } = require("./alert");
+const { IntervalCommand } = require("./interval");
+const { TraversalCommand } = require("./traversal");
+const { NotifyCommand } = require("./notify");
+const { LogCommand } = require("./log");
+const { formatData, shareData } = require("./share_data");
+const { FileInfoCommand } = require("./file_info");
+const { ReadOnlyExcelCommand } = require("./read_only_excel");
+const { WebSocketCommand } = require("./web_socket");
+const { TsSortCommand } = require("./ts_sort");
+const { DivinationCommand } = require("./divination");
+const { FileSizeCommand } = require("./file_size");
+const { TmpdirCommand } = require("./tmpdir");
+const { HashCommand } = require("./hash");
+const { StoreOptionalCommand } = require("./store_optional");
+const { UpdatingRevisionCommand } = require("./updating_revision");
+const { RevisionInfoCommand } = require("./revision_info");
+const { UnzipCommand } = require("./unzip");
+const { DownloadCommand } = require("./download");
+const { ReadExcelCommand } = require("./read_excel");
+const { WriteExcelCommand } = require("./write_excel");
+const { EditExcelCommand } = require("./edit_excel");
+const { MysqlConnectCommand } = require("./mysql_connect");
+const { MysqlEndCommand } = require("./mysql_end");
+const { MysqlQueryCommand } = require("./mysql_query");
+const { FtpCommand } = require("./ftp");
+const { StreamCommand } = require("./stream");
+const { TencentCosCommand } = require("./tencent_cos");
+const { WriteCacheCommand } = require("./write_cache");
+const { ReadCacheCommand } = require("./read_cache");
+const { AssembleCommand } = require("./Assemble");
+const { DisassembleCommand } = require("./disassemble");
+const { DingtalkCommand } = require("./dingtalk");
+const { WatchMailCommand } = require("./watch_mail");
+const { TranslateCommand } = require("./translate");
+const { ChangeFilterCommand } = require("./change_filter");
+const { TempCommand } = require("./temp");
+const { CheerioCommand } = require("./cheerio");
+const { SwitchCommand } = require("./switch");
+const { MergeFilesCommand } = require("./merge_files");
+const { JwtDecodeCommand } = require("./jwt_decode");
+const { ClearScreenCommand } = require("./clear_screen");
+const { TitleCommand } = require("./title");
+const { CompareCommand } = require('./compare');
+const { ZipDataCommand } = require('./zip_data');
+const { EnvOptionalCommand } = require('./env_optional');
+const { SendEmailCommand } = require("./send_email");
+const { AssertCommand } = require('./assert');
+const { SvnAddCommand } = require('./svn_add');
+const { ImageCropCommand } = require('./image_crop');
+const { CursorUpCommand } = require('./cursor_up');
+
+const globalData = {
+    "executed_cfg": [], // 执行过的配置文件
+    "process_state": PROCESS_STATE.NONE, // 当前执行状态
+};
+
+/**
+ * @type { { [commandType: string]: BaseCommand[] } }
+ */
+const commandMap = {};
+
+/**
+ * @type { { [commandType: string]: BaseCommand[] } }
+ */
+const commandPool = {};
+const showLogs = {
+    
+};
+
+
+function register(type, commandCls, showLog) {
+    commandMap[type] = commandCls;
+    showLogs[type] = showLog;
+}
+
+/**
+ * 获取命令
+ * @param {string} type 
+ * @returns {BaseCommand}
+ */
+function getCommand(type) {
+    let commandCls = commandMap[type];
+    if (!commandCls) {
+        return;
+    }
+    let commands = commandPool[type];
+    if (!commands) {
+        commands = commandPool[type] = [];
+    }
+    let command = commands.pop();
+    if (!command) {
+        command = new commandCls(type, globalData, execSingle, exec);
+    }
+    return command;
+}
+
+/**
+ * 回收命令
+ * @param {BaseCommand} command 
+ */
+function recyleCommand(command) {
+    if (!command) {
+        warn("回收命令异常");
+        return;
+    }
+    let type = command.type;
+    let commands = commandPool[type];
+    if (!commands) {
+        commands = commandPool[type] = [];
+    }
+    commands.push(command);
+}
+
+/**
+ * 
+ * @param {{type: string, title?: string, when:?: string, data: any, ignore_error: boolean}[]} commandCfgs 
+ */
+async function exec(commandCfgs, depth = 0) {
+    for (let i = 0, len = commandCfgs && commandCfgs.length; i < len; ++i) {
+        const commandCfg = commandCfgs[i];
+        await execSingle(commandCfg, depth, {
+            curr: i,
+            total: len,
+        });
+        if (globalData.process_state === PROCESS_STATE.BREAK) {
+            break;
+        } else if (globalData.process_state === PROCESS_STATE.CONTINUE) {
+            break;
+        }
+    }
+}
+
+/**
+ * 
+ * @param {*} depth 
+ */
+async function execSingle(commandCfg) {
+    let totalRetryTimes = commandCfg.retry || 0;
+    let retryTimes = 0;
+    let ret = null;
+    while(true) {
+        if (retryTimes > 0) { // 仅在重试时，重置错误
+            setLastError(null);
+        }
+        try {
+            if (commandCfg.async) {
+                _execSingle.apply(this, arguments);
+            } else {
+                ret = await _execSingle.apply(this, arguments);
+            }
+        } catch (e) {
+            setLastError(e);
+        }
+        if (getLastError()) {
+            if (++retryTimes <= totalRetryTimes) {
+                error("\n" + getLastError());
+                warn(`重新执行 (${retryTimes}/${totalRetryTimes})...`);
+                await new Promise(resolve => {
+                    setTimeout(() => {
+                        resolve();
+                    }, 1000 * retryTimes);
+                });
+                continue;
+            }
+            throw getLastError();
+        }
+        break;
+    }
+    return ret;
+}
+
+/**
+ * 
+ * @param {*} depth 
+ */
+async function _execSingle(commandCfg, depth, progressData) {
+    if (typeof commandCfg === "string") {
+        commandCfg = {
+            type: commandCfg,
+        };
+    }
+    let rawCfg = JSON.stringify(commandCfg, undefined, 4);
+    // 深度拷贝
+    commandCfg = JSON.parse(rawCfg);
+    // 提前format
+    if (!commandCfg.raw) {
+        formatData(commandCfg);
+    }
+    if (commandCfg.side_effect && shareData.DRY_RUN) {
+        warn(`[DRY_RUN] ${commandCfg.title || commandCfg.type}`);
+        return;
+    }
+    let type = commandCfg.type;
+    let data = commandCfg.data;
+    let command = getCommand(type);
+    if (!command) {
+        log("");
+        whisper(`${getPrint(commandCfg, true)}`);
+        throw (`未注册的命令 ${type}`);
+    }
+    // 判断是否步进执行
+    if (command.shareData.STEP_BY_STEP) {
+        await pause(`即将执行 ${rawCfg}`);
+    }
+    if (commandCfg.debugger) {
+        if (typeof commandCfg.debugger === "boolean") {
+            debugger;
+        } else {
+            try {
+                if (eval_code(commandCfg.debugger)) {
+                    debugger;
+                }
+            } catch (err) {
+                debugger;
+                warn(err);
+            }
+        }
+    }
+
+    if (!(await command.checkValid(commandCfg))) {
+        return;
+    }
+    if (commandCfg.show_progress /* !== false */ && progressData && shareData.$COMPRESS_PROGERSS <= 0) {
+        progress(progressData.curr, progressData.total, {depth: depth, desc: `> ${commandCfg.title || commandCfg.type}`, color: "white"});
+    }
+    
+    if (showLogs[commandCfg.type]) {
+        log("");
+    }
+
+
+    let content;
+    if (command.getRequireContent()) {
+        if (data.content != null) {
+            content = data.content;
+        } else if (data.key) {
+            let keys = data.key.split(".");
+            content = command.shareData;
+            for (let i = 0; i < keys.length; i++) {
+                const key = keys[i];
+                content = content[key];
+                if (!content) {
+                    break;
+                }
+            }
+        } else if (data.src) {
+            content = read_plain(data.src);
+        } else if (data.code) {
+            content = eval_code(data.code);
+        }
+        if (content == null) {
+            if (!commandCfg.ignore_error) {
+                throw `无content可供使用 ${rawCfg}`;
+            }
+        }
+    }
+    let ret;
+    let is_first = true;
+    do {
+        if (!is_first) {
+            warn(`结果不合法,请检查...`);
+        }
+        ret = await command.handle(commandCfg, content, depth);
+        is_first = false;
+    } while (!ret && commandCfg.required);
+    recyleCommand(command);
+    
+    if (!getLastError()) {
+        if (commandCfg.show_progress /* !== false */ && progressData && shareData.$COMPRESS_PROGERSS <= 0) {
+            progress(progressData.curr + 1, progressData.total, {depth: depth, desc: `✔ ${commandCfg.title || commandCfg.type}`['cyan']});
+        }
+    } else {
+        if (commandCfg.show_progress /* !== false */ && progressData && shareData.$COMPRESS_PROGERSS <= 0) {
+            progress(progressData.curr + 1, progressData.total, {depth: depth, desc: `✖ ${commandCfg.title || commandCfg.type}`['red']});
+        }
+        if (commandCfg.ignore_error) {
+            resetError(commandCfg.ignore_error);
+        } else {
+            throw getLastError() + " " + rawCfg;
+        }
+    }
+    if (commandCfg.newline) {
+        log("");
+    }
+
+    return ret;
+}
+
+
+function init() {
+    register("abort", AbortCommand, false);
+    register("base", BaseCommand, false);
+    register("confirm", ConfirmCommand, false);
+    register("copy", CopyCommand, false);
+    register("write_clipboard", WriteClipboard, false);
+    register("read_clipboard", ReadClipboard, false);
+    register("date", DateCommand, false);
+    register("debugger", DebuggerCommand, false);
+    register("eval", EvalCommand, false);
+    register("exec_from_file", ExecFromFileCommand, true);
+    register("exec_shell", ShellCommand, false);
+    register("files", FilesCommand, false);
+    register("first_exist", FirstExistCommand, false);
+    register("flatten", FlattenCommand, false);
+    register("git_commit", GitCommitCommand, false);
+    register("git_export_diff_head", GitExportDiffHeadCommand, false);
+    register("git_is_dirty", GitIsDirtyCommand, false);
+    register("http_request", HTTPRequestCommand, false);
+    register("input", InputCommand, true);
+    register("list2dict", List2DictCommand, false);
+    register("loop", LoopCommand, false);
+    register("loop_forever", LoopForeverCommand, false);
+    register("move", MoveCommand, false);
+    register("multi_select", MultiSelectCommand, false);
+    register("modify", ModifyCommand, false);
+    register("open", OpenCommand, false);
+    register("parse", ParseCommand, false);
+    register("pause", PauseCommand, false);
+    register("print", PrintCommand, false);
+    register("read_cfg", ReadCfgCommand, false);
+    register("read_plain", ReadPlainCommand, false);
+    register("remove", RemoveCommand, false);
+    register("request", HTTPRequestCommand, false);
+    register("retrieve", RetrieveCommand, false);
+    register("reveal", RevealCommand, false);
+    register("select", SelectCommand, false);
+    register("shell", ShellCommand, false);
+    register("sleep", SleepCommand, false);
+    register("storage", StoreCommand, false);
+    register("store", StoreCommand, false);
+    register("storage_optional", StoreOptionalCommand, false);
+    register("store_optional", StoreOptionalCommand, false);
+    register("svn_commit", SvnCommitCommand, false);
+    register("svn_is_dirty", SvnIsDirtyCommand, false);
+    register("svn_update", SvnUpdateCommand, false);
+    register("svn_export_diff_head", SVNExportDiffHeadCommand, false);
+    register("test", TestCommand, false);
+    register("truncate", TruncateCommand, false);
+    register("truncate_all", TruncateAllCommand, false);
+    register("void", VoidCommand, false);
+    register("write_cfg", WriteCfgCommand, false);
+    register("write_plain", WritePlainCommand, false);
+    register("zip", ZipCommand, false);
+    register("valid_required", ValidRequiredCommand, false);
+    register("continue", ContinueCommand, false);
+    register("break", BreakCommand, false);
+    register("stringify", StringifyCommand, false);
+    register("commit", CommitCommand, false);
+    register("export_diff_head", ExportDiffHeadCommand, false);
+    register("is_dirty", IsDirtyCommand, false);
+    register("which", WhichCommand, false);
+    register("move_local", MoveLocalCommand, false);
+    register("edit", EditCommand, false);
+    register("schedule", ScheduleCommand, false);
+    register("alert", AlertCommand, false);
+    register("interval", IntervalCommand, false);
+    register("traversal", TraversalCommand, false);
+    register("notify", NotifyCommand, false);
+    register("log", LogCommand, false);
+    register("file_info", FileInfoCommand, false);
+    register("read_only_excel", ReadOnlyExcelCommand, false);
+    register("web_socket", WebSocketCommand, false);
+    register("ts_sort", TsSortCommand, false);
+    register("suan_gua", DivinationCommand, false);
+    register("divination", DivinationCommand, false);
+    register("file_size", FileSizeCommand, false);
+    register("tmpdir", TmpdirCommand, false);
+    register("hash", HashCommand, false);
+    register("updating_revision", UpdatingRevisionCommand, false);
+    register("revision_info", RevisionInfoCommand, false);
+    register("unzip", UnzipCommand, false);
+    register("download", DownloadCommand, false);
+    register("read_excel", ReadExcelCommand, false);
+    register("write_excel", WriteExcelCommand, false);
+    register("edit_excel", EditExcelCommand, false);
+    register("mysql_connect", MysqlConnectCommand, false);
+    register("mysql_end", MysqlEndCommand, false);
+    register("mysql_query", MysqlQueryCommand, false);
+    register("ftp", FtpCommand, false);
+    register("stream", StreamCommand, false);
+    register("tencent_cos", TencentCosCommand, false);
+    register("read_cache", ReadCacheCommand, false);
+    register("write_cache", WriteCacheCommand, false);
+    register("assemble", AssembleCommand, false);
+    register("disassemble", DisassembleCommand, false);
+    register("dingtalk", DingtalkCommand, false);
+    register("watch_mail", WatchMailCommand, false);
+    register("translate", TranslateCommand, false);
+    register("change_filter", ChangeFilterCommand, false);
+    register("temp", TempCommand, false);
+    register("cheerio", CheerioCommand, false);
+    register("switch", SwitchCommand, false);
+    register("merge_files", MergeFilesCommand, false);
+    register("jwt_decode", JwtDecodeCommand, false);
+    register("clear_screen", ClearScreenCommand, false);
+    register("title", TitleCommand, false);
+    register("compare", CompareCommand, false);
+    register("zip_data", ZipDataCommand, false);
+    register("env_optional", EnvOptionalCommand, false);
+    register("send_email", SendEmailCommand, false);
+    register("assert", AssertCommand, false);
+    register("svn_add", SvnAddCommand, false);
+    register("image_crop", ImageCropCommand, false);
+    register("cursor_up", CursorUpCommand, false);
+}
+
+module.exports = {
+    init,
+    exec,
+    execSingle,
+};

package/commands/modify.js

@@ -0,0 +1,44 @@
+const { eval_code } = require("./share_data");
+const { format, toArray } = require("../utils/transform_tool");
+const { BaseCommand } = require("./base");
+
+class ModifyCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        let flags = data.flags || "";
+        if (flags.indexOf("g") == -1) {
+            flags += "g";
+        }
+        let reg = new RegExp(data.pattern, flags);
+        let idx = 0;
+        let replacers = toArray(data.replacer);
+        let converters = toArray(data.converter);
+        let ret = this.content.replace(reg, (...args) => {
+            let replacer = replacers[idx] || data.default_replacer;
+            let converter = converters[idx];
+            if (replacer == null) {
+                return args[0];
+            }
+            if (converter) {
+                args[1] = eval_code(converter)(args[1]);
+            }
+            ++idx;
+            return format(replacer, args);
+        });
+        return ret;
+    }
+
+    getRequireContent() {
+        return true;
+    }
+
+    getRequiredParams() {
+        return [
+            "pattern",
+        ];
+    }
+}
+
+module.exports = {
+    ModifyCommand,
+};

package/commands/move.js

@@ -0,0 +1,14 @@
+const { move } = require("../utils/file_tool");
+const { log } = require("../utils/log_tool");
+const { BaseCommand } = require("./base");
+
+class MoveCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        await move(data.src, data.dst, data.base, data.options);
+    }
+}
+
+module.exports = {
+    MoveCommand,
+};

package/commands/move_local.js

@@ -0,0 +1,14 @@
+const { move_local } = require("../utils/file_tool");
+const { log } = require("../utils/log_tool");
+const { BaseCommand } = require("./base");
+
+class MoveLocalCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        await move_local(data.src, data.dst, data.base, data.options);
+    }
+}
+
+module.exports = {
+    MoveLocalCommand,
+};

package/commands/multi_select.js

@@ -0,0 +1,16 @@
+const { multiSelect } = require('../utils/selection_tool');
+const { BaseCommand } = require("./base");
+
+class MultiSelectCommand extends BaseCommand {
+    async execute() {
+        return multiSelect(this.content, this.selfData);
+    }
+
+    getRequireContent() {
+        return true;
+    }
+}
+
+module.exports = {
+    MultiSelectCommand,
+};