node-automator 1.0.0

package/commands/translate.js

@@ -0,0 +1,58 @@
+const { doRequest } = require("../utils/request_tool");
+const { BaseCommand } = require("./base");
+const crypto = require("crypto");
+const { getCache, setCache } = require("../utils/cache_tool");
+
+class TranslateCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        let q = this.content;
+        let from = data.from || "auto";
+        let to = data.to || "zh";
+        let appid = "20181030000227685";
+        let secret = "Clf6hhkAfZuXsNewanRf";
+        let salt = "tsubasa";
+        let sign = crypto.createHash("md5").update(`${appid}${q}${salt}${secret}`).digest("hex");
+        let cache = await getCache("translate") || {};
+        let ret = cache[from]?.[to]?.[q];
+        if (ret) {
+            return ret;
+        }
+        let translatedRaw = await doRequest({
+            src: "https://fanyi-api.baidu.com/api/trans/vip/translate",
+            quiet: true,
+            options: {
+                method: "POST",
+                formData: {
+                    q,
+                    from,
+                    to,
+                    appid,
+                    salt,
+                    sign,
+                }
+            }
+        });
+        try {
+            let translatedData = JSON.parse(translatedRaw);
+            let ret = translatedData?.trans_result?.[0]?.dst;
+            if (ret) {
+                cache[from] || (cache[from] = {});
+                cache[from][to] || (cache[from][to] = {});
+                cache[from][to][q] = ret;
+                setCache("translate", cache);
+            }
+            return ret || "";
+        } catch (error) {
+            return "";
+        }
+    }
+
+    getRequireContent() {
+        return true;
+    }
+}
+
+module.exports = {
+    TranslateCommand,
+};

package/commands/traversal.js

@@ -0,0 +1,38 @@
+const { eval_code } = require("./share_data");
+const { BaseCommand } = require("./base");
+
+class TraversalCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        return traversal(this.content, eval_code(data.handler), eval_code(data.sizeOf), eval_code(data.childAt), data.output, eval_code(data.filter));
+    }
+
+    getRequireContent() {
+        return true;
+    }
+
+    getRequiredParams() {
+        return  [
+            "sizeOf",
+            "childAt",
+            "handler",
+        ];
+    }
+}
+
+module.exports = {
+    TraversalCommand,
+};
+
+
+
+function traversal(root, handler, sizeOf, childAt, output, filter) {
+    if (!filter || filter(root)) {
+        handler(root, output);
+    }
+    for (let i = 0, size = sizeOf(root) || 0; i < size; ++i) {
+        let child = childAt(root, i);
+        traversal(child, handler, sizeOf, childAt, output, filter);
+    }
+    return output;
+}

package/commands/truncate.js

@@ -0,0 +1,31 @@
+const { BaseCommand } = require("./base");
+
+class TruncateCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        let content = this.content;
+        let flags = data.flags || "";
+        if (flags.indexOf("g") == -1) {
+            flags += "g";
+        }
+        let struct = data.struct;
+        let reg = new RegExp(data.pattern, flags);
+        let match = reg.exec(content);
+        match = match && match[1];
+        return match;
+    }
+
+    getRequireContent() {
+        return true;
+    }
+    
+    getRequiredParams() {
+        return [
+            "pattern"
+        ];
+    }
+}
+
+module.exports = {
+    TruncateCommand,
+};

package/commands/truncate_all.js

@@ -0,0 +1,62 @@
+const { convert } = require("../utils/transform_tool");
+const { BaseCommand } = require("./base");
+
+class TruncateAllCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        let content = this.content;
+        let flags = data.flags || "";
+        if (flags.indexOf("g") == -1) {
+            flags += "g";
+        }
+        let struct = data.struct;
+        let reg = new RegExp(data.pattern, flags);
+        let matches = [];
+        let match;
+        let full_match = data.full_match;
+        while(match = reg.exec(content)) {
+            let obj;
+            if (struct instanceof Array) {
+                obj = {};
+                // 匹配的完整字符串由 $ 表示 
+                if (struct[0] != "$") {
+                    struct.unshift("$");
+                }
+                match.forEach((v, i) => {
+                    if (!full_match && i == 0) {
+                        return;
+                    }
+                    let prop = struct[i];
+                    let name;
+                    let value = data.trim ? v.trim() : v;
+                    if (typeof prop === "object") {
+                        name = prop.name;
+                        value = convert(value, prop.type);
+                    } else {
+                        name = prop;
+                    }
+
+                    obj[name] = value;
+                });
+            } else {
+                obj = full_match ? match : match.slice(1);
+            }
+            matches.push(obj);
+        }
+        return matches;
+    }
+
+    getRequireContent() {
+        return true;
+    }
+
+    getRequiredParams() {
+        return [
+            "pattern"
+        ];
+    }
+}
+
+module.exports = {
+    TruncateAllCommand,
+};

package/commands/ts_sort.js

@@ -0,0 +1,18 @@
+const { get_file_list } = require("../utils/file_tool");
+const { BaseCommand } = require("./base");
+
+class TsSortCommand extends BaseCommand {
+    async execute() {
+        const ts_plus = require("typescript-plus");
+        let files = get_file_list(this.selfData.src);
+        let program = ts_plus.createProgram(files, {
+            reorderFiles: true,
+        });
+        let ret = ts_plus.reorderSourceFiles(program);
+        return ret.sortedFileNames;
+    }
+}
+
+module.exports = {
+    TsSortCommand,
+};

package/commands/unzip.js

@@ -0,0 +1,50 @@
+const { read_plain, get_fst_file, get_full_path, format_bytes } = require("../utils/file_tool");
+const { BaseCommand } = require("./base");
+const fs = require("fs");
+const il = require('iconv-lite');
+const path = require("path");
+const display_tool = require("../utils/display_tool");
+
+class UnzipCommand extends BaseCommand {
+    async execute() {
+        let src = get_fst_file(this.selfData.src);
+        let dst = get_full_path(this.selfData.dst, "FOLDER");
+        let encoding = this.selfData?.options?.encoding;
+        let totalSize = fs.statSync(src).size;
+        let unzippedSize = 0;
+        let uncompressedSize = 0;
+        // await require('extract-zip')(src, { dir: dst });
+        const AdmZip = require("adm-zip");
+        // reading archives
+        var zip = new AdmZip(src);
+        var zipEntries = zip.getEntries(); // an array of ZipEntry records
+
+        zipEntries.forEach(function (entry, index, entries) {
+            console.log(entry.toString()); // outputs zip entries information
+            const fileName = il.decode(entry.rawEntryName, encoding || "cp936"); // cp866
+            const compressedData = entry.getCompressedData();
+            const uncompressedData = entry.getData();
+            display_tool.progress(index, entries.length, {
+                desc: `Unzipping ${fileName} ${format_bytes(compressedData.length)} >>> ${format_bytes(uncompressedData.length)}`,
+                depth: 0,
+                color: "cyan",
+                align: true,
+            });
+            if (entry.isDirectory) {
+                fs.mkdirSync(path.join(dst, fileName));
+            } else {
+                fs.writeFileSync(path.join(dst, fileName), entry.getData());
+            }
+            display_tool.progress(index + 1, entries.length, {
+                desc: `Unzipping ${fileName} ${format_bytes(compressedData.length)} >>> ${format_bytes(uncompressedData.length)}`,
+                depth: 0,
+                color: "cyan",
+                align: true,
+            });
+        });
+    }
+}
+
+module.exports = {
+    UnzipCommand,
+};

package/commands/updating_revision.js

@@ -0,0 +1,28 @@
+const { parse } = require("../utils/file_tool");
+const { exec_shell } = require("../utils/shell_tool");
+const { BaseCommand } = require("./base");
+
+class UpdatingRevisionCommand extends BaseCommand {
+    async execute() {
+        let currentInfo = await parse(await exec_shell({
+            cmd: "svn info",
+            cwd: this.selfData.cwd,
+            capture_stdout: true,
+        }), 'yaml');
+        let comingUpdates = await exec_shell({
+            cmd: `svn mergeinfo --show-revs eligible ${currentInfo.URL}`,
+            cwd: this.selfData.cwd,
+            capture_stdout: true,
+        });
+        comingUpdates = comingUpdates
+            .split(/[\r\n]{1,2}/)
+            .map(v => v.substr(1))
+            .filter(v => v && v != currentInfo.Revision)
+        ;
+        return comingUpdates;
+    }
+}
+
+module.exports = {
+    UpdatingRevisionCommand,
+};

package/commands/valid_required.js

@@ -0,0 +1,31 @@
+const { vital, success, error, info, getPrint, warn, log } = require("../utils/log_tool");
+const { toArray } = require("../utils/transform_tool");
+const { BaseCommand } = require("./base");
+
+class ValidRequiredCommand extends BaseCommand {
+    async execute() {
+        let data = this.selfData;
+        const keys = toArray(data.key);
+        let failed = false;
+        log("");
+        for (let index = 0; index < keys.length; index++) {
+            const key = keys[index];
+            let ret = this.getDataByKey(key);
+            if (ret == null) {
+                failed = true;
+                warn(`${key} => ${getPrint(ret)}`);
+            } else {
+                info(`${key} => ${getPrint(ret)}`);
+            }
+        }
+        if (failed) {
+            throw (`参数校验失败,请检查环境变量或者启动参数`);
+        } else {
+            success(`参数校验成功`);
+        }
+    }
+}
+
+module.exports = {
+    ValidRequiredCommand,
+};

package/commands/void.js

@@ -0,0 +1,10 @@
+const { BaseCommand } = require("./base");
+
+class VoidCommand extends BaseCommand {
+    async execute() {
+    }
+}
+
+module.exports = {
+    VoidCommand,
+};

package/commands/watch_mail.js

@@ -0,0 +1,94 @@
+const { setLastError, success, warn, getPrint } = require("../utils/log_tool");
+const {
+    BaseCommand
+} = require("./base");
+const {
+    formatData
+} = require("./share_data");
+
+class WatchMailCommand extends BaseCommand {
+    async execute() {
+        const data = this.selfData;
+        await new Promise((resolve, reject) => {
+            const MailWatcher = require('mail-watcher');
+            // IMAP： 默认端口：143 （ssl安全链接端口：993）
+            // SMTP： 默认端口：25 （ssl安全链接端口：994）
+            // POP3： 默认端口：110 （ssl安全链接端口：995）
+            const imap = {
+                user: data.user,
+                password: data.password,
+                host: data.host,
+                port: data.port || (data.tls ? 993 : 143), // imap port
+                tls: data.tls, // use secure connection
+                // search: ['ALL'],
+                // search: ['UNSEEN'],
+                search: data.search || ["UNSEEN"],
+                tlsOptions: {
+                    rejectUnauthorized: false
+                }
+            };
+            const mailWatcher = MailWatcher(imap);
+            const cache_mail_ids = [];
+            // const fs = require("fs");
+            mailWatcher.on('end', () => {
+                    warn(`restart ...`);
+                    mailWatcher.start();
+                })
+                .on('connected', () => {
+                    resolve();
+                })
+                .on('error', (err) => {
+                    setLastError(err);
+                    resolve();
+                })
+                .on('mail',
+                    /**
+                     * 
+                     * @param {import('../lib').ParsedMail} mail 
+                     */
+                    async (mail) => {
+                        const subject = mail.subject;
+                        const text = mail.text || require('html-to-text').convert(mail.html);
+                        const id = mail.messageId;
+                        // 值映射
+                        let value_mapping = data.value_mapping;
+                        let index = cache_mail_ids.indexOf(id);
+                        if (index == -1) {
+                            index = cache_mail_ids.length;
+                            cache_mail_ids.push(id);
+                        }
+                        let mailData = {
+                            index: index,
+                            id,
+                            subject,
+                            text,
+                        };
+                        if (value_mapping) {
+                            if (typeof value_mapping === "string") {
+                                this.shareData[value_mapping] = mailData;
+                            }
+                        } else {
+                            this.shareData['mail_data'] = mailData;
+                        }
+                        if (!data.quiet) {
+                            success("");
+                            success(getPrint(mailData));
+                        }
+                        let commandCfgs = data.commands;
+                        if (commandCfgs) {
+                            // 特殊处理字符的情况
+                            if (typeof commandCfgs === "string") {
+                                commandCfgs = formatData(commandCfgs);
+                            }
+                            // 默认从循环开始执行，增加深度
+                            await this.exec(commandCfgs, this.depth + 1);
+                        }
+                    })
+                .start();
+        });
+    }
+}
+
+module.exports = {
+    WatchMailCommand,
+};

package/commands/web_socket.js

@@ -0,0 +1,233 @@
+const {
+    warn,
+    info,
+    success,
+    whisper,
+    getPrint,
+    setLastError,
+    getLastError
+} = require("../utils/log_tool");
+const {
+    format, formatTimeInMillisec
+} = require("../utils/transform_tool");
+const {
+    BaseCommand
+} = require("./base");
+
+const CODE2DESC = {
+    0: "🟢 已连接",
+    ETIMEDOUT: "⏰ 已超时",
+    ECONNREFUSED: "⛔️ 被拒绝",
+    ENOTFOUND: "🛑 未找到",
+};
+
+class WebSocketCommand extends BaseCommand {
+    async execute() {
+        const WebSocketClient = require('websocket').client;
+        let url = this.selfData.url;
+        let name = this.selfData.name || "";
+        let name_postfix = name ? `(${name})` : '';
+        let protocols = this.selfData.protocols; // || 'echo-protocol';
+        // 字节顺序为 bigEndian（最高有效字节位于最前）或 littleEndian（最低有效字节位于最前）
+        let little_endian = this.selfData.little_endian;
+        /** @type {{type: string, name: string, bits: number}[]} */
+        let headers = this.selfData.headers;
+        /** @type {string[]} */
+        let body_retrieval = this.selfData.body_retrieval;
+        /** 生命周期，如果有设置，会在达到生命周期时，自动断开连接 */
+        let lifetime = this.selfData.lifetime;
+        let bodies = this.selfData.bodies;
+        let receivedBytesTotal = 0;
+        let receivedUTF8Total = 0;
+        let receivedIndex = 0;
+        let timeout = this.selfData.timeout || 0;
+        let quiet = this.selfData.quiet || false;
+        let endianSuffix = little_endian ? "LE" : "BE";
+
+        let rl;
+        let ok = true;
+        let msg = "";
+        await new Promise((resolve, reject) => {
+            let startTime = Date.now();
+            function resolveCode(code) {
+                let elapsedTime = Date.now() - startTime;
+                if (code) {
+                    msg = `${CODE2DESC[code] || code} ${url} ${name_postfix} ${elapsedTime / 1000}s`;
+                    setLastError(msg);
+                } else {
+                    msg = `${CODE2DESC[code]} ${url} ${name_postfix} ${elapsedTime / 1000}s`;
+                    success(msg);
+                }
+            }
+            var client = new WebSocketClient();
+            let timer = timeout ? setTimeout(() => {
+                client.removeAllListeners('connect');
+                client.removeAllListeners('connectFailed');
+                client.abort();
+                resolveCode('ETIMEDOUT');
+                reject();
+            }, timeout) : 0;
+
+            client.on('connectFailed', (err) => {
+                if (timer) clearTimeout(timer);
+                resolveCode(err.code);
+                reject();
+            });
+            client.on('connect', (connection) => {
+                if (timer) clearTimeout(timer);
+                resolveCode(0);
+                if (lifetime) {
+                    setTimeout(() => {
+                        !quiet && warn(`End of life cycle (${lifetime} ms)`);
+                        connection.close(1000);
+                    }, lifetime);
+                }
+                connection.on('error', (err) => {
+                    msg = err;
+                    setLastError(err);
+                    reject();
+                });
+                connection.on('close', () => {
+                    !quiet && warn('echo-protocol Connection Closed');
+                    resolve();
+                });
+                connection.on('message', (message) => {
+                    if (message.type === 'utf8') {
+                        receivedUTF8Total += message.utf8Data.length;
+                        !quiet && whisper(`[${receivedIndex++}] size=${message.utf8Data.length} total=${receivedUTF8Total}`, " ", true);
+                        !quiet && info(message.utf8Data);
+                    } else {
+                        receivedBytesTotal += message.binaryData.length;
+                        !quiet && whisper(`[${receivedIndex++}] size=${message.binaryData.length}B total=${+(receivedBytesTotal / 1024).toFixed(2)}kB`, " ", true);
+                        // info("[hex]" + message.binaryData.toString("hex"));
+                        let unpacked = {};
+                        let offset = 0;
+                        offset = this.readStruct(unpacked, headers, message.binaryData, little_endian, offset);
+                        let body = bodies;
+                        if (body_retrieval) {
+                            for (const v of body_retrieval) {
+                                if (!body) {
+                                    break;
+                                }
+                                body = body[unpacked[v]];
+                            }
+                        }
+                        if (body) {
+                            body.title && info(body.title);
+                            offset = this.readStruct(unpacked, body.struct, message.binaryData, little_endian, offset);
+                        }
+                        !quiet && info(getPrint(unpacked, true));
+                    }
+                });
+                /** @type {any[]} */
+                let sends = this.selfData.sends;
+                sends && sends.forEach(v => {
+                    this.send(connection, v);
+                });
+
+                this.readInput(v => {
+                    this.send(connection, v);
+                }, (v) => {
+                    rl = v;
+                });
+            });
+            !quiet && warn(`Connecting websocket url=${url} protocols=${protocols}`);
+            let options = Object.assign({
+                rejectUnauthorized: false,
+            }, this.selfData.options);
+            client.connect(url, protocols, undefined, undefined, Object.assign(options));
+        })
+        .catch(reason => {
+            ok = false;
+        });
+        if (rl) {
+            rl.close();
+        }
+        return [msg, ok];
+    }
+
+    /**
+     * 
+     * @param {connection} connection
+     * @param {string} v 
+     */
+    send(connection, v) {
+        let encodingIdx = v.indexOf(":");
+        let encoding = v.substring(0, encodingIdx) || "utf8";
+        let content = v.substring(encodingIdx + 1);
+        info(`[send] ${content} encoding=${encoding}`);
+        connection.sendBytes(Buffer.from(content, encoding));
+    }
+
+    /**
+     * 
+     * @param {(v: string)=>any} resolve 
+     */
+    readInput(resolve, retrieve) {
+        const readline = require("readline");
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: null,
+        });
+        rl.question("", (input) => {
+            resolve(input);
+            rl.close();
+            this.readInput(resolve, retrieve);
+        });
+
+        rl.on("close", () => {
+
+        });
+        retrieve && retrieve(rl);
+    }
+
+    /**
+     * 
+     * @param {object} unpacked 
+     * @param {{type: string, name: string, bits: number, loop?: { name: string, struct: {type: string, name: string, bits: number}[] }}[]} structs
+     * @param {Buffer} buffer 
+     * @param {boolean} little_endian 
+     * @param {number} offset 
+     * @returns 
+     */
+    readStruct(unpacked, structs, buffer, little_endian, offset = 0) {
+        let endianSuffix = little_endian ? "LE" : "BE";
+        // let dataView = new DataView(new Uint8Array(buffer).buffer);
+        structs && structs.forEach(struct => {
+            // let v = dataView[`get${struct.type}${struct.bits}`](offset, little_endian);
+            let v;
+            let bytes = struct.bits >> 3;
+            if (struct.type == "String") {
+                let end = offset + bytes;
+                if (struct.trim) {
+                    let idx = buffer.indexOf(0, offset);
+                    if (idx > offset) {
+                        end = idx;
+                    }
+                }
+                v = buffer.toString(struct.encoding, offset, end);
+            } else {
+                v = buffer[`read${struct.type}${struct.bits}${struct.bits > 8 ? endianSuffix : ""}`](offset);
+            }
+            offset += bytes;
+            if (struct.name) {
+                unpacked[struct.name] = v;
+            }
+            if (struct.loop) {
+                let loopv = [];
+                for (let i = 0; i < v; ++i) {
+                    let t = {};
+                    offset = this.readStruct(t, struct.loop.struct, buffer, little_endian, offset);
+                    loopv.push(t);
+                }
+                unpacked[struct.loop.name] = loopv;
+            }
+        });
+        return offset;
+    }
+
+}
+
+module.exports = {
+    WebSocketCommand,
+};