n8n-nodes-soar 0.1.21 → 0.1.23

package/dist/common/asset.js

@@ -48,6 +48,9 @@ class MissingPropertyError extends Error {
     }
 }
 class Asset {
+    static fromPlain(plain) {
+        return (0, _classtransformer.plainToInstance)(Asset, plain);
+    }
     getDomain() {
         if (!this.basic.domain) {
             throw new MissingPropertyError("basic.domain", this);
@@ -60,6 +63,12 @@ class Asset {
         }
         return this.basic.domain || this.basic.ip || "";
     }
+    getIP() {
+        if (!this.basic.ip) {
+            throw new MissingPropertyError("basic.ip", this);
+        }
+        return this.basic.ip;
+    }
     getPort() {
         if (!this.basic.port) {
             throw new MissingPropertyError("basic.port", this);
@@ -70,75 +79,55 @@ class Asset {
         return `${this.getHost()}:${this.getPort()}`;
     }
     clone(patch) {
-        return (0, _classtransformer.plainToInstance)(Asset, Object.assign({}, this, patch));
-    }
-    splitBySubdomains() {
-        if (this.subdomains?.length) {
-            return [
-                this,
-                ...this.subdomains.map((n)=>{
-                    return (0, _classtransformer.plainToInstance)(Asset, {
-                        basic: {
-                            host: n
-                        },
-                        metadata: this.metadata,
-                        success: true
-                    });
-                })
-            ];
-        } else {
-            return [
-                this
-            ];
-        }
+        return Asset.fromPlain(Object.assign({}, this, patch));
     }
-    splitByDnsRecords() {
-        if (this.dnsRecord && Object.keys(this.dnsRecord).length) {
-            return [
-                ...this.dnsRecord?.A ?? [],
-                ...this.dnsRecord?.AAAA ?? []
-            ].map((n)=>{
-                return (0, _classtransformer.plainToInstance)(Asset, {
+    splitBySubdomains(subdomains) {
+        return [
+            this,
+            ...subdomains.map((n)=>{
+                return Asset.fromPlain({
                     basic: {
-                        domain: this.basic.domain,
-                        ip: n
+                        domain: n
                     },
-                    metadata: this.metadata,
-                    success: true
+                    metadata: this.metadata
                 });
+            })
+        ];
+    }
+    splitByDnsRecords(dnsRecord) {
+        return [
+            ...dnsRecord?.A ?? [],
+            ...dnsRecord?.AAAA ?? []
+        ].map((n)=>{
+            return Asset.fromPlain({
+                basic: {
+                    domain: this.basic.domain,
+                    ip: n
+                },
+                metadata: this.metadata
             });
-        } else {
-            return [
-                this
-            ];
-        }
+        });
     }
-    splitByPorts() {
-        if (this.ports?.length) {
-            return this.ports.map((n)=>{
-                return (0, _classtransformer.plainToInstance)(Asset, {
-                    basic: {
-                        domain: this.basic.domain,
-                        port: n.port,
-                        protocol: n.protocol
-                    },
-                    metadata: this.metadata,
-                    success: true
-                });
+    splitByPorts(ports) {
+        return ports.map((n)=>{
+            return Asset.fromPlain({
+                basic: {
+                    domain: this.basic.domain,
+                    ip: this.basic.ip,
+                    port: n.port,
+                    protocol: n.protocol
+                },
+                metadata: this.metadata
             });
-        } else {
-            return [
-                this
-            ];
-        }
+        });
+    }
+    toPlain() {
+        return (0, _classtransformer.instanceToPlain)(this);
     }
     constructor(){
         _define_property(this, "basic", new Basic());
-        _define_property(this, "subdomains", void 0);
-        _define_property(this, "dnsRecord", void 0);
-        _define_property(this, "ports", void 0);
         _define_property(this, "metadata", void 0);
         _define_property(this, "response", void 0);
-        _define_property(this, "success", false);
+        _define_property(this, "screenshot", void 0);
     }
 }

package/dist/common/connectionType.js

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "NodeConnectionType", {
 });
 var NodeConnectionType;
 (function(NodeConnectionType) {
-    NodeConnectionType["Runner"] = "runner";
-    NodeConnectionType["Executor"] = "executor";
+    NodeConnectionType["Runner"] = "soar_runner";
+    NodeConnectionType["Executor"] = "soar_executor";
+    NodeConnectionType["Memorizer"] = "soar_memorizer";
 })(NodeConnectionType || (NodeConnectionType = {}));

package/dist/common/executor/abstract.executor.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AbstractExecutor", {
+    enumerable: true,
+    get: function() {
+        return AbstractExecutor;
+    }
+});
+const _n8nworkflow = require("n8n-workflow");
+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 AbstractExecutor {
+    async readFile(path) {
+        const { stdout, stderr } = await this.run([
+            "cat",
+            path
+        ]);
+        if (stderr !== "") {
+            throw new _n8nworkflow.NodeOperationError(this.func.getNode(), new Error(stderr));
+        }
+        return stdout;
+    }
+    async writeFile(path, content) {
+        // using base64 to avoid escaping issues
+        const { stderr } = await this.run([
+            "bash",
+            "-c",
+            `echo ${Buffer.from(content).toString("base64")} | base64 -d > ${path}`
+        ]);
+        if (stderr !== "") {
+            throw new _n8nworkflow.NodeOperationError(this.func.getNode(), new Error(stderr));
+        }
+    }
+    constructor(func){
+        _define_property(this, "func", void 0);
+        this.func = func;
+    }
+}

package/dist/common/executor/docker.executor.js

@@ -11,7 +11,7 @@ Object.defineProperty(exports, "DockerExecutor", {
 const _stream = require("stream");
 const _dockerode = /*#__PURE__*/ _interop_require_default(require("dockerode"));
 const _n8nworkflow = require("n8n-workflow");
-const _executor = require("./executor");
+const _abstractexecutor = require("./abstract.executor");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -30,29 +30,36 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
-class DockerExecutor extends _executor.Executor {
-    async __run(cmd, image, env) {
-        let stdout = "";
-        let stderr = "";
-        const outStream = new _stream.Writable({
-            write (chunk, encoding, done) {
-                stdout += chunk.toString();
-                done();
-            }
-        });
-        const errStream = new _stream.Writable({
-            write (chunk, encoding, done) {
-                stderr += chunk.toString();
-                done();
-            }
-        });
-        await this.docker.pull(image);
-        let container;
-        const containers = (await this.docker.listContainers({
+class DockerExecutor extends _abstractexecutor.AbstractExecutor {
+    setContainer(container) {
+        this.container = container;
+    }
+    acquireContainer() {
+        if (!this.container) {
+            throw new _n8nworkflow.NodeOperationError(this.func.getNode(), "Container is not ready");
+        }
+        return this.container;
+    }
+    async listContainers() {
+        return (await this.docker.listContainers({
             filters: '{"label": ["managed-by=n8n-nodes-soar"]}'
-        })).filter((n)=>n.Image === image);
+        })).filter((n)=>n.Image === this.image);
+    }
+    async findContainerByID(id) {
+        const containers = await this.listContainers();
+        const r = containers.find((n)=>n.Id === id);
+        if (!r) {
+            throw new _n8nworkflow.NodeOperationError(this.func.getNode(), `Container ${id} not found`);
+        }
+        return this.docker.getContainer(r.Id);
+    }
+    async prepareContainer() {
+        const { image } = this;
+        let container;
+        const containers = await this.listContainers();
         if (containers.length === 0) {
             this.func.logger.info(`Boot new container for image ${image}`);
+            await this.docker.pull(image);
             container = await this.docker.createContainer({
                 Image: image,
                 Cmd: [
@@ -67,11 +74,28 @@ class DockerExecutor extends _executor.Executor {
         } else {
             container = this.docker.getContainer(containers[0].Id);
         }
-        this.func.logger.debug(`Running ${cmd.join(" ")}`);
+        return container;
+    }
+    async run(cmd, options) {
+        let stdout = "";
+        let stderr = "";
+        const outStream = new _stream.Writable({
+            write (chunk, encoding, done) {
+                stdout += chunk.toString();
+                done();
+            }
+        });
+        const errStream = new _stream.Writable({
+            write (chunk, encoding, done) {
+                stderr += chunk.toString();
+                done();
+            }
+        });
+        const container = await this.acquireContainer();
         const exec = await container.exec({
-            AttachStderr: true,
-            AttachStdout: true,
-            Env: Object.entries(env || {}).map(([key, value])=>`${key}=${value}`),
+            AttachStderr: !options?.ignoreStderr,
+            AttachStdout: !options?.ignoreStdout,
+            Env: options?.env,
             Tty: false,
             Cmd: cmd
         });
@@ -83,15 +107,17 @@ class DockerExecutor extends _executor.Executor {
         if (stderr !== "") {
             throw new _n8nworkflow.NodeOperationError(this.func.getNode(), new Error(stderr));
         }
-        this.func.logger.debug(`Result ${stdout}`);
-        return JSON.parse(stdout);
+        return {
+            stdout,
+            stderr
+        };
     }
-    constructor(credentials, func){
+    constructor(image, credentials, func){
         super(func);
+        _define_property(this, "image", void 0);
         _define_property(this, "docker", void 0);
-        if (credentials === undefined) {
-            throw new _n8nworkflow.NodeOperationError(func.getNode(), new Error("No credentials got returned!"));
-        }
+        _define_property(this, "container", void 0);
+        this.image = image;
         this.docker = new _dockerode.default(credentials);
     }
 }

package/dist/common/executor/jsonrpc.executor.js

@@ -0,0 +1,123 @@
+"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, {
+    JSONRPCError: function() {
+        return JSONRPCError;
+    },
+    JSONRPCExecutor: function() {
+        return JSONRPCExecutor;
+    }
+});
+const _n8nworkflow = require("n8n-workflow");
+const _ws = require("ws");
+const _abstractexecutor = require("./abstract.executor");
+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 JSONRPCError extends Error {
+    constructor(code, message, data){
+        super(`${code}: ${message} ${data ? JSON.stringify(data) : ""}`);
+        this.name = "JSONRPCError";
+    }
+}
+class JSONRPCExecutor extends _abstractexecutor.AbstractExecutor {
+    wait() {
+        if (this.ws.readyState === _ws.WebSocket.OPEN) {
+            return Promise.resolve(undefined);
+        }
+        return new Promise((resolve)=>{
+            this.ws.on("open", ()=>{
+                resolve(undefined);
+            });
+        });
+    }
+    id() {
+        return Math.floor(Math.random() * 1000000000);
+    }
+    async invoke(method, params) {
+        await this.wait();
+        return new Promise((resolve, reject)=>{
+            const id = this.id();
+            this.callbackMap.set(id, (n, e)=>{
+                if (e) {
+                    reject(e);
+                } else {
+                    resolve(n);
+                }
+            });
+            this.ws.send(JSON.stringify({
+                id,
+                method,
+                params
+            }));
+        });
+    }
+    listMethods() {
+        return this.invoke("system.ListMethods", []);
+    }
+    getMethod(method) {
+        return this.invoke("system.GetMethod", [
+            method
+        ]);
+    }
+    run(cmd, options) {
+        return this.invoke("Run", [
+            cmd,
+            options ?? {}
+        ]);
+    }
+    readFile(path) {
+        return this.invoke("ReadFile", [
+            path
+        ]);
+    }
+    writeFile(path, content) {
+        return this.invoke("WriteFile", [
+            path,
+            content
+        ]);
+    }
+    constructor(credentials, func){
+        super(func);
+        _define_property(this, "callbackMap", new Map());
+        _define_property(this, "ws", void 0);
+        const ws = new _ws.WebSocket(credentials.url + "/jsonrpc", {
+            headers: {
+                Authorization: `Basic ${Buffer.from(`${credentials.username}:${credentials.password}`).toString("base64")}`
+            }
+        });
+        ws.on("error", (e)=>{
+            throw new _n8nworkflow.NodeOperationError(this.func.getNode(), e);
+        });
+        ws.on("message", (data)=>{
+            const res = JSON.parse(data.toString());
+            const callback = this.callbackMap.get(res.id);
+            if (callback) {
+                if (res.error) {
+                    callback(res.result, new JSONRPCError(res.error.code, res.error.message, res.error.data));
+                } else {
+                    callback(res.result);
+                }
+            }
+        });
+        this.ws = ws;
+    }
+}

package/dist/common/executor/{k8s.executor.js → kubernetes.executor.js}

@@ -2,16 +2,16 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "K8sExecutor", {
+Object.defineProperty(exports, "KubernetesExecutor", {
     enumerable: true,
     get: function() {
-        return K8sExecutor;
+        return KubernetesExecutor;
     }
 });
 const _stream = require("stream");
 const _clientnode = /*#__PURE__*/ _interop_require_wildcard(require("@kubernetes/client-node"));
 const _n8nworkflow = require("n8n-workflow");
-const _executor = require("./executor");
+const _abstractexecutor = require("./abstract.executor");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -66,20 +66,37 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-class K8sExecutor extends _executor.Executor {
-    async __run(cmd, image, env) {
+class KubernetesExecutor extends _abstractexecutor.AbstractExecutor {
+    setPodName(podName) {
+        this.podName = podName;
+    }
+    acquirePodName() {
+        if (!this.podName) {
+            throw new _n8nworkflow.NodeOperationError(this.func.getNode(), "Pod name is not ready");
+        }
+        return this.podName;
+    }
+    async listNamespaces() {
         const kc = this.kubeConfig;
         const k8sCoreApi = kc.makeApiClient(_clientnode.CoreV1Api);
-        const pods = (await k8sCoreApi.listNamespacedPod("default", undefined, undefined, undefined, undefined, "managed-by=n8n-nodes-soar")).body.items.filter((n)=>(n.status?.phase === "Running" || n.status?.phase === "Pending") && n.spec?.containers[0].image === image);
-        let pod = undefined;
-        const namespace = "default";
-        if (pods.length > 0) {
-            pod = pods[0];
-        } else {
+        return (await k8sCoreApi.listNamespace()).body.items.map((n)=>n.metadata?.name ?? "");
+    }
+    async listPods() {
+        const kc = this.kubeConfig;
+        const k8sCoreApi = kc.makeApiClient(_clientnode.CoreV1Api);
+        const pods = (await k8sCoreApi.listNamespacedPod(this.namespace, undefined, undefined, undefined, undefined, "managed-by=n8n-nodes-soar")).body.items;
+        return pods.filter((n)=>(n.status?.phase === "Running" || n.status?.phase === "Pending") && n.spec?.containers[0].image === this.image).map((n)=>n.metadata?.name ?? "");
+    }
+    async preparePod() {
+        const { image, namespace } = this;
+        const pods = await this.listPods();
+        if (pods.length === 0) {
             const podName = `n8n-soar-pod-${Date.now()}`;
+            this.func.logger.info(`Boot new pod for image ${image}`);
             const podSpec = {
                 metadata: {
                     name: podName,
+                    namespace,
                     labels: {
                         "managed-by": "n8n-nodes-soar"
                     }
@@ -100,14 +117,20 @@ class K8sExecutor extends _executor.Executor {
                     ]
                 }
             };
-            this.func.logger.debug("Creating pod " + JSON.stringify(podSpec));
-            const resp = await k8sCoreApi.createNamespacedPod(namespace, podSpec);
-            pod = resp.body;
-        }
-        const name = pod.metadata?.name;
-        if (!name) {
-            throw new Error("Pod name not set!");
+            const kc = this.kubeConfig;
+            const k8sCoreApi = kc.makeApiClient(_clientnode.CoreV1Api);
+            await k8sCoreApi.createNamespacedPod(this.namespace, podSpec);
+            return podName;
+        } else {
+            return pods[0];
         }
+    }
+    async run(cmd, options) {
+        const { namespace } = this;
+        const kc = this.kubeConfig;
+        const k8sCoreApi = kc.makeApiClient(_clientnode.CoreV1Api);
+        const name = this.acquirePodName();
+        const pod = (await k8sCoreApi.readNamespacedPod(name, namespace)).body;
         // if is in initial
         if (pod.status?.phase === "Pending") {
             while(true){
@@ -132,19 +155,19 @@ class K8sExecutor extends _executor.Executor {
             stderrString += chunk.toString();
             next();
         };
-        this.func.logger.debug(`Running ${cmd.join(" ")}`);
         await new Promise(async (resolve, reject)=>{
             exec.exec(namespace, name, "main-container", [
                 "env",
-                ...Object.entries(env || {}).flatMap(([k, v])=>[
+                ...options?.env?.flatMap((v)=>[
                         "-e",
-                        `${k}=${v}`
-                    ]),
+                        v
+                    ]) ?? [],
                 ...cmd
             ], stdout, stderr, null, false, (s)=>{
                 switch(s.status){
                     case "Failure":
-                        reject(s.message);
+                        console.log(stderrString, stdoutString);
+                        reject(new Error(s.message));
                         break;
                     case "Success":
                         resolve(undefined);
@@ -152,19 +175,19 @@ class K8sExecutor extends _executor.Executor {
                 }
             }).catch(reject);
         });
-        stderrString;
-        if (stderrString !== "") {
-            throw new _n8nworkflow.NodeOperationError(this.func.getNode(), new Error(stderrString));
-        }
-        this.func.logger.debug(`Result ${stdoutString}`);
-        return JSON.parse(stdoutString);
+        return {
+            stdout: stdoutString,
+            stderr: stderrString
+        };
     }
-    constructor(credentials, func){
+    constructor(namespace, image, credentials, func){
         super(func);
+        _define_property(this, "namespace", void 0);
+        _define_property(this, "image", void 0);
+        _define_property(this, "podName", void 0);
         _define_property(this, "kubeConfig", void 0);
-        if (credentials === undefined) {
-            throw new _n8nworkflow.NodeOperationError(func.getNode(), new Error("No credentials got returned!"));
-        }
+        this.namespace = namespace;
+        this.image = image;
         const kubeConfig = new _clientnode.KubeConfig();
         switch(credentials.loadFrom){
             case "automatic":

package/dist/common/interface.js

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

package/dist/common/memorizer/abstract.memorizer.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AbstractMemorizer", {
+    enumerable: true,
+    get: function() {
+        return AbstractMemorizer;
+    }
+});
+const _n8nworkflow = require("n8n-workflow");
+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 AbstractMemorizer {
+    save(input, output) {
+        return this.storage.set(this.hash(input), output);
+    }
+    async batchSave(inputs, outputs) {
+        if (inputs.length !== outputs.length) {
+            throw new _n8nworkflow.NodeOperationError(this.func.getNode(), "Inputs and outputs must be the same length");
+        }
+        await Promise.all(inputs.map((input, index)=>this.storage.set(this.hash(input), outputs[index])));
+    }
+    load(input) {
+        return this.storage.get(this.hash(input));
+    }
+    async batchLoad(inputs) {
+        return Promise.all(inputs.map((input)=>this.storage.get(this.hash(input))));
+    }
+    constructor(func, itemIndex, storage){
+        _define_property(this, "func", void 0);
+        _define_property(this, "itemIndex", void 0);
+        _define_property(this, "storage", void 0);
+        this.func = func;
+        this.itemIndex = itemIndex;
+        this.storage = storage;
+    }
+}

package/dist/common/memorizer/asset.memorizer.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "AssetMemorizer", {
+    enumerable: true,
+    get: function() {
+        return AssetMemorizer;
+    }
+});
+const _generalmemorizer = require("./general.memorizer");
+class AssetMemorizer extends _generalmemorizer.GeneralMemorizer {
+    hash(data) {
+        return "asset:" + super.hash(data.json.basic);
+    }
+}

package/dist/common/memorizer/general.memorizer.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "GeneralMemorizer", {
+    enumerable: true,
+    get: function() {
+        return GeneralMemorizer;
+    }
+});
+const _nodecrypto = require("node:crypto");
+const _abstractmemorizer = require("./abstract.memorizer");
+class GeneralMemorizer extends _abstractmemorizer.AbstractMemorizer {
+    hash(data) {
+        return (0, _nodecrypto.createHash)("md5").update(JSON.stringify(data)).digest("hex");
+    }
+}