n8n-nodes-soar 0.1.21 → 0.1.23

package/dist/common/memorizer/storage/redis.storage.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RedisStorage", {
+    enumerable: true,
+    get: function() {
+        return RedisStorage;
+    }
+});
+const _n8nworkflow = require("n8n-workflow");
+const _redis = require("redis");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class RedisStorage {
+    async connect() {
+        await this.connectPromise;
+    }
+    async set(key, value) {
+        await this.connect();
+        if (this.ttl > 0) {
+            this.client.setEx(`${this.key}:${key}`, this.ttl, JSON.stringify(value));
+        } else {
+            this.client.set(`${this.key}:${key}`, JSON.stringify(value));
+        }
+    }
+    async get(key) {
+        await this.connect();
+        const resp = await this.client.get(`${this.key}:${key}`);
+        if (!resp) {
+            return null;
+        } else {
+            return JSON.parse(resp);
+        }
+    }
+    constructor(func, credentials, key, ttl){
+        _define_property(this, "key", void 0);
+        _define_property(this, "ttl", void 0);
+        _define_property(this, "client", void 0);
+        _define_property(this, "connectPromise", void 0);
+        this.key = key;
+        this.ttl = ttl;
+        const redisOptions = {
+            socket: {
+                host: credentials.host,
+                port: credentials.port
+            },
+            database: credentials.database
+        };
+        if (credentials.password) {
+            redisOptions.password = credentials.password;
+        }
+        this.client = (0, _redis.createClient)(redisOptions);
+        this.client.on("error", async (error)=>{
+            await this.client.quit();
+            throw new _n8nworkflow.NodeOperationError(func.getNode(), "Redis Error: " + error.message);
+        });
+        this.connectPromise = this.client.connect();
+    }
+}

package/dist/common/proxy/abstract.proxy.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/dist/common/proxy/executor.proxy.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "proxyExecutor", {
+    enumerable: true,
+    get: function() {
+        return proxyExecutor;
+    }
+});
+const _connectionType = require("../connectionType");
+const proxyExecutor = (i)=>{
+    return new Proxy(i, {
+        get: (target, prop, receiver)=>{
+            if ([
+                "run",
+                "readFile",
+                "writeFile"
+            ].includes(prop)) {
+                const f = Reflect.get(target, prop, receiver);
+                const func = Reflect.get(target, "func", receiver);
+                const itemIndex = Reflect.get(target, "itemIndex", receiver);
+                const debugMode = func.getNodeParameter("debug", itemIndex, false);
+                async function wrap(...args) {
+                    let index = 0;
+                    if (debugMode) {
+                        index = func.addInputData(_connectionType.NodeConnectionType.Executor, [
+                            func.helpers.returnJsonArray({
+                                call: prop.toString(),
+                                arguments: args
+                            })
+                        ]).index;
+                        func.logger.debug(`Input: ${index} ${prop.toString()} ${JSON.stringify(args)}`);
+                    }
+                    const resp = await f.apply(this, args);
+                    if (debugMode) {
+                        func.addOutputData(_connectionType.NodeConnectionType.Executor, index, [
+                            func.helpers.returnJsonArray(resp)
+                        ]);
+                        func.logger.debug(`Output: ${index} ${prop.toString()} ${JSON.stringify(resp)}`);
+                    }
+                    return resp;
+                }
+                return wrap.bind(target);
+            } else {
+                return Reflect.get(target, prop, receiver);
+            }
+        }
+    });
+};

package/dist/common/proxy/memorizer.proxy.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "proxyMemorizer", {
+    enumerable: true,
+    get: function() {
+        return proxyMemorizer;
+    }
+});
+const _connectionType = require("../connectionType");
+const proxyMemorizer = (i)=>{
+    return new Proxy(i, {
+        get: (target, prop, receiver)=>{
+            if ([
+                "load",
+                "save",
+                "batchLoad",
+                "batchSave"
+            ].includes(prop.toString())) {
+                const f = Reflect.get(target, prop, receiver);
+                const func = Reflect.get(target, "func", receiver);
+                const itemIndex = Reflect.get(target, "itemIndex", receiver);
+                const debugMode = func.getNodeParameter("debug", itemIndex, false);
+                async function wrap(...args) {
+                    let index = 0;
+                    if (debugMode) {
+                        index = func.addInputData(_connectionType.NodeConnectionType.Executor, [
+                            func.helpers.returnJsonArray({
+                                call: prop.toString(),
+                                arguments: args
+                            })
+                        ]).index;
+                        func.logger.debug(`Input: ${index} ${prop.toString()} ${JSON.stringify(args)}`);
+                    }
+                    const resp = await f.apply(target, args);
+                    if (debugMode) {
+                        func.addOutputData(_connectionType.NodeConnectionType.Executor, index, [
+                            func.helpers.returnJsonArray(resp)
+                        ]);
+                        func.logger.debug(`Output: ${index} ${prop.toString()} ${JSON.stringify(resp)}`);
+                    }
+                    return resp;
+                }
+                return wrap.bind(target);
+            } else {
+                return Reflect.get(target, prop, receiver);
+            }
+        }
+    });
+};

package/dist/common/proxy/runner.proxy.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "proxyRunner", {
+    enumerable: true,
+    get: function() {
+        return proxyRunner;
+    }
+});
+const _classtransformer = require("class-transformer");
+const _asset = require("../asset");
+const _connectionType = require("../connectionType");
+const _decorator = require("../runner/decorator");
+const proxyRunner = (i)=>{
+    return new Proxy(i, {
+        get: (target, prop, receiver)=>{
+            if (prop === "run") {
+                const f = Reflect.get(target, prop, receiver);
+                const func = Reflect.get(target, "func", receiver);
+                const itemIndex = Reflect.get(target, "itemIndex", receiver);
+                const onlySuccess = func.getNodeParameter("onlySuccess", itemIndex, false);
+                const debugMode = func.getNodeParameter("debug", itemIndex, false);
+                async function wrap(collector, inputs) {
+                    let index = 0;
+                    if (debugMode) {
+                        index = func.addInputData(_connectionType.NodeConnectionType.Runner, [
+                            func.helpers.returnJsonArray((0, _classtransformer.instanceToPlain)(inputs))
+                        ]).index;
+                        func.logger.debug(`Input: ${index} ${JSON.stringify(inputs.map((n)=>n.json))}`);
+                    }
+                    if ((0, _decorator.getAssetRunner)(this)) {
+                        inputs.forEach((n)=>{
+                            n.json = _asset.Asset.fromPlain(n.json);
+                        });
+                    }
+                    if ((0, _decorator.getOnlySuccess)(this.constructor) && onlySuccess) {
+                        inputs.forEach((a)=>{
+                            a.success = false;
+                        });
+                    }
+                    let resp = await f.call(this, collector, inputs);
+                    if ((0, _decorator.getOnlySuccess)(this.constructor) && onlySuccess) {
+                        resp = resp.filter((a)=>a.success);
+                    }
+                    if (debugMode) {
+                        func.addOutputData(_connectionType.NodeConnectionType.Runner, index, [
+                            resp
+                        ]);
+                        func.logger.debug(`Output: ${index} ${JSON.stringify(resp.map((n)=>n.json))}`);
+                    }
+                    return resp;
+                }
+                return wrap.bind(target);
+            } else {
+                return Reflect.get(target, prop, receiver);
+            }
+        }
+    });
+};

package/dist/common/runner/container.runner.js

@@ -12,85 +12,75 @@ _export(exports, {
     ContainerRunner: function() {
         return ContainerRunner;
     },
-    IMAGE: function() {
-        return IMAGE;
-    },
-    injectCommonProperties: function() {
-        return injectCommonProperties;
+    advancedOptions: function() {
+        return advancedOptions;
     }
 });
 const _n8nworkflow = require("n8n-workflow");
 const _runner = require("./runner");
-const IMAGE = {
-    DEFAULT: "registry.yoshino-s.xyz/yoshino-s/soar-image:dev",
-    SCRIPT: "registry.yoshino-s.xyz/yoshino-s/soar-image/script:dev"
-};
-const injectCommonProperties = (p)=>{
-    return [
-        ...p,
-        {
-            displayName: "Advanced Config",
-            name: "advanced",
-            type: "fixedCollection",
-            default: {},
-            typeOptions: {
-                multipleValues: true
+const advancedOptions = [
+    {
+        displayName: "Advanced Config",
+        name: "advanced",
+        type: "fixedCollection",
+        default: {},
+        typeOptions: {
+            multipleValues: true
+        },
+        options: [
+            {
+                name: "envs",
+                displayName: "Envs",
+                values: [
+                    {
+                        displayName: "Key",
+                        name: "key",
+                        type: "string",
+                        default: ""
+                    },
+                    {
+                        displayName: "Value",
+                        name: "value",
+                        type: "string",
+                        default: ""
+                    }
+                ]
             },
-            options: [
-                {
-                    name: "envs",
-                    displayName: "Envs",
-                    values: [
-                        {
-                            displayName: "Key",
-                            name: "key",
-                            type: "string",
-                            default: ""
-                        },
-                        {
-                            displayName: "Value",
-                            name: "value",
-                            type: "string",
-                            default: ""
-                        }
-                    ]
-                },
-                {
-                    name: "Files",
-                    displayName: "Files",
-                    values: [
-                        {
-                            displayName: "Name",
-                            name: "name",
-                            type: "string",
-                            default: ""
-                        },
-                        {
-                            displayName: "Content",
-                            name: "content",
-                            type: "string",
-                            default: ""
-                        }
-                    ]
-                },
-                {
-                    displayName: "Collect Files",
-                    name: "collectFiles",
-                    values: [
-                        {
-                            displayName: "Name",
-                            name: "name",
-                            type: "string",
-                            default: ""
-                        }
-                    ]
-                }
-            ]
-        }
-    ];
-};
-class ContainerRunner extends _runner.Runner {
-    collectGeneratedOptions(extraArgParameters) {
+            {
+                name: "Files",
+                displayName: "Files",
+                values: [
+                    {
+                        displayName: "Name",
+                        name: "name",
+                        type: "string",
+                        default: ""
+                    },
+                    {
+                        displayName: "Content",
+                        name: "content",
+                        type: "string",
+                        default: ""
+                    }
+                ]
+            },
+            {
+                displayName: "Collect Files",
+                name: "collectFiles",
+                values: [
+                    {
+                        displayName: "Name",
+                        name: "name",
+                        type: "string",
+                        default: ""
+                    }
+                ]
+            }
+        ]
+    }
+];
+class ContainerRunner extends _runner.AbstractRunner {
+    collectGeneratedCmdOptions(extraArgParameters) {
         const cmdline = [];
         for (const parameter of extraArgParameters){
             const value = this.func.getNodeParameter(parameter, this.itemIndex, null);
@@ -114,8 +104,7 @@ class ContainerRunner extends _runner.Runner {
         }
         return cmdline;
     }
-    options(assets) {
-        assets;
+    getOptions() {
         const options = {
             envs: {},
             files: {},
@@ -135,40 +124,36 @@ class ContainerRunner extends _runner.Runner {
         options.collectFiles = _collectFiles.map(({ name })=>name);
         return options;
     }
-    async __run(collector, assets) {
-        if (collector.executor === undefined) {
-            throw new _n8nworkflow.NodeOperationError(this.func.getNode(), "Executor is not set");
-        }
-        const options = this.options(assets);
-        const cmd = this.cmd(assets);
-        let cmdline = [
-            "/usr/local/bin/runner"
-        ];
-        if (options.files) {
-            for (const [key, value] of Object.entries(options.files)){
-                cmdline.push("--files", `${key}:${value}`);
-            }
-        }
-        if (options.collectFiles) {
-            for (const key of options.collectFiles){
-                cmdline.push("--collect-files", key);
-            }
-        }
-        if (options.ignoreStdout) {
-            cmdline.push("--ignore-stdout");
-        }
-        if (options.ignoreStderr) {
-            cmdline.push("--ignore-stderr");
-        }
-        cmdline.push("--");
-        cmdline = cmdline.concat(cmd);
-        const { stdout, stderr, error, files: resultFiles } = await collector.executor.run(cmdline, options.image ?? IMAGE.DEFAULT, options.envs);
-        if (error) {
-            throw new _n8nworkflow.NodeOperationError(this.func.getNode(), new Error(error));
+    async runCmd(collector, cmd, options) {
+        const executor = collector.executor;
+        if (executor === undefined) {
+            throw new _n8nworkflow.NodeOperationError(this.func.getNode(), new Error("Executor is not set"));
         }
+        await Promise.all(Object.entries(options.files).map(([k, v])=>{
+            return executor.writeFile(k, v);
+        }));
+        const { stdout, stderr } = await executor.run(cmd, {
+            env: Object.entries(options.envs).map(([k, v])=>`${k}=${v}`),
+            ignoreStderr: options.ignoreStderr,
+            ignoreStdout: options.ignoreStdout
+        });
         if (stderr) {
-            this.func.logger.warn(stderr);
+            throw new _n8nworkflow.NodeOperationError(this.func.getNode(), new Error(`stderr: ${stderr}`));
         }
-        return this.process(assets, stdout, resultFiles ?? {});
+        const resultFiles = (await Promise.all(options.collectFiles.map(async (n)=>{
+            const content = await executor.readFile(n);
+            return [
+                n,
+                content
+            ];
+        }))).reduce((acc, [k, v])=>{
+            acc[k] = v;
+            return acc;
+        }, {});
+        return {
+            stdout,
+            stderr,
+            files: resultFiles
+        };
     }
 }

package/dist/common/runner/decorator/assetRunner.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    AssetRunner: function() {
+        return AssetRunner;
+    },
+    getAssetRunner: function() {
+        return getAssetRunner;
+    }
+});
+const _onlySuccess = require("./onlySuccess");
+const _decorator = require("../../../utils/decorator");
+const [_AssetRunner, _getAssetRunner] = (0, _decorator.declareClassDecorator)("assetRunner", false);
+const AssetRunner = (t)=>{
+    _AssetRunner(true)(t);
+    (0, _onlySuccess.OnlySuccess)(true)(t);
+};
+const getAssetRunner = _getAssetRunner;

package/dist/common/runner/decorator/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./assetRunner"), exports);
+_export_star(require("./onlySuccess"), exports);
+_export_star(require("./priority"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/dist/common/runner/decorator/onlySuccess.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    OnlySuccess: function() {
+        return OnlySuccess;
+    },
+    getOnlySuccess: function() {
+        return getOnlySuccess;
+    }
+});
+const _decorator = require("../../../utils/decorator");
+const [OnlySuccess, getOnlySuccess] = (0, _decorator.declareClassDecorator)("onlySuccess", false);

package/dist/common/runner/{priority.js → decorator/priority.js}

@@ -32,13 +32,21 @@ _export(exports, {
     },
     PORT_RUNNER_PRIORITY: function() {
         return PORT_RUNNER_PRIORITY;
+    },
+    Priority: function() {
+        return Priority;
+    },
+    getPriority: function() {
+        return getPriority;
     }
 });
-const DEFAULT_PRIORITY = 100;
-const DOMAIN_RUNNER_PRIORITY = 10;
-const DNS_RUNNER_PRIORITY = 20;
-const IP_RUNNER_PRIORITY = 30;
-const PORT_RUNNER_PRIORITY = 40;
-const BANNER_RUNNER_PRIORITY = 50;
-const APP_RUNNER_PRIORITY = 60;
-const EXPLOIT_RUNNER_PRIORITY = 70;
+const _decorator = require("../../../utils/decorator");
+const DEFAULT_PRIORITY = 0;
+const DOMAIN_RUNNER_PRIORITY = 100;
+const DNS_RUNNER_PRIORITY = 90;
+const IP_RUNNER_PRIORITY = 80;
+const PORT_RUNNER_PRIORITY = 70;
+const BANNER_RUNNER_PRIORITY = 60;
+const APP_RUNNER_PRIORITY = 50;
+const EXPLOIT_RUNNER_PRIORITY = 40;
+const [Priority, getPriority] = (0, _decorator.declareClassDecorator)("priority", DEFAULT_PRIORITY);

package/dist/common/runner/priority.runner.js

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "PriorityRunner", {
         return PriorityRunner;
     }
 });
+const _decorator = require("./decorator");
 const _runner = require("./runner");
 function _define_property(obj, key, value) {
     if (key in obj) {
@@ -22,17 +23,15 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
-class PriorityRunner extends _runner.Runner {
-    __run(collector, assets) {
-        return assets;
-    }
-    run(collector, assets) {
+class PriorityRunner extends _runner.AbstractRunner {
+    async run(collector, inputs) {
         // bypass set input/output in priority runner node
-        return this.parentRunner.run(collector, assets);
+        return this.parentRunner.run(collector, inputs);
     }
     constructor(parentRunner, priority){
-        super(parentRunner.name, priority, parentRunner.func, parentRunner.itemIndex);
+        super(parentRunner.func, parentRunner.itemIndex);
         _define_property(this, "parentRunner", void 0);
         this.parentRunner = parentRunner;
+        (0, _decorator.Priority)(priority)(this.constructor);
     }
 }

package/dist/common/runner/runner.js

@@ -2,15 +2,12 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "Runner", {
+Object.defineProperty(exports, "AbstractRunner", {
     enumerable: true,
     get: function() {
-        return Runner;
+        return AbstractRunner;
     }
 });
-const _classtransformer = require("class-transformer");
-const _connectionType = require("../connectionType");
-const _priority = require("./priority");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -24,33 +21,17 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
-class Runner {
-    async run(collector, assets) {
-        assets.forEach((a)=>a.success = false);
-        const { index } = this.func.addInputData(_connectionType.NodeConnectionType.Runner, [
-            assets.map((a)=>({
-                    json: (0, _classtransformer.instanceToPlain)(a)
-                }))
-        ]);
-        let resp = await this.__run(collector, assets);
-        const onlySuccess = this.func.getNodeParameter("onlySuccess", index, true);
-        if (onlySuccess) {
-            resp = resp.filter((a)=>a.success);
-        }
-        this.func.addOutputData(_connectionType.NodeConnectionType.Runner, index, [
-            resp.map((a)=>({
-                    json: (0, _classtransformer.instanceToPlain)(a)
-                }))
-        ]);
-        return resp;
+class AbstractRunner {
+    constructData(sourceInputIndex, d, success = false) {
+        return d.map((a)=>({
+                json: a,
+                success,
+                sourceInputIndex
+            }));
     }
-    constructor(name, priority = _priority.DEFAULT_PRIORITY, func, itemIndex){
-        _define_property(this, "name", void 0);
-        _define_property(this, "priority", void 0);
+    constructor(func, itemIndex){
         _define_property(this, "func", void 0);
         _define_property(this, "itemIndex", void 0);
-        this.name = name;
-        this.priority = priority;
         this.func = func;
         this.itemIndex = itemIndex;
     }

package/dist/constants/image.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "IMAGE", {
+    enumerable: true,
+    get: function() {
+        return IMAGE;
+    }
+});
+const IMAGE = "registry.yoshino-s.xyz/yoshino-s/soar-image:dev";