@kumologica/sdk 3.6.1 → 3.6.2-beta2

package/cli/commands/create-commands/OpenApiBuilder.js

@@ -0,0 +1,608 @@
+class OpenApiBuilder {
+    constructor(api) {
+        this.api = api;
+        this.shiftx = 100;
+        this.shifty = 80;
+    }
+
+    S4() {
+        return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
+    };
+
+    getId() {
+        return this.S4() + "." + this.S4();
+    }
+
+    getEventListenerEnd(id, tabId, x, y, status, response, notes, headers) {
+
+        return {
+            "id": id,
+            "type": "EventListener-End",
+            "z": tabId,
+            "name": status,
+            "statusCode": status === "default" ? "200" : status,
+            "responseType": "http",
+            "headers": headers,
+            "payload": response || "msg.payload",
+            "eventPayload": "",
+            "eventType": "success",
+            "x": x,
+            "y": y,
+            "wires": [],
+            "caname": "eventlistenerend",
+            "category": "general",
+            "info": notes || ""
+        }
+    }
+
+    getLog(id, nextId, tabId, x, y, logName, logMessage, logType) {
+
+        return {
+            "id": id,
+            "type": "Logger",
+            "z": tabId,
+            "name": logName || "Log",
+            "level": logType || "INFO",
+            "message": logMessage,
+            "x": x,
+            "y": y,
+            "wires": [[nextId]],
+            "caname": "logger",
+            "category": "logging"
+        }
+    }
+
+    getSchema(id, nextId, tabId, x, y, schema, notes) {
+
+        return {
+            "id": id,
+            "type": "json-schema-validator",
+            "z": tabId,
+            "name": "Validate Request",
+            "Property": "msg.payload",
+            "query": schema,
+            "x": x,
+            "y": y,
+            "wires": [
+                [nextId]
+            ],
+            "caname": "JSONSchemaVal",
+            "category": "validation",
+            "info": notes || ""
+        }
+    }
+
+    getError(id, nextId, tabId, x, y, errorCode, notes) {
+
+        return {
+            "id": id,
+            "type": "catch",
+            "z": tabId,
+            "name": "Catch " + (errorCode || "Error"),
+            "scope": [],
+            "uncaught": false,
+            "x": x,
+            "y": y,
+            "wires": [[nextId]],
+            "caname": "catch",
+            "category": "exception",
+            "info": notes || ""
+        };
+
+    }
+
+    getLogicCall(id, nextId, tabId, x, y, logicInId) {
+
+        return {
+            "id": id,
+            "type": "Subflow",
+            "z": tabId,
+            "untilproptype": "num",
+            "proptype": "msg",
+            "name": "Business Logic Call",
+            "prop": "loop",
+            "untilprop": 0,
+            "until": "gt",
+            "loop": "none",
+            "scope": "global",
+            "perf": false,
+            "seq": false,
+            "selectedTargetNode": logicInId,
+            "targetNode": logicInId,
+            "initialLoad": "false",
+            "x": x,
+            "y": y,
+            "wires": [[nextId]],
+            "caname": "subflow",
+            "category": "routing"
+        };
+    }
+
+    getLogicSubflow(id, tabId, y) {
+        const subflowOutId = this.getId();
+        const logId = this.getId();
+        return [
+            {
+                "id": id,
+                "type": "Subflow_in",
+                "z": tabId,
+                "name": "Business Logic In",
+                "priority": "50",
+                "links": [],
+                "scope": "global",
+                "x": 50,
+                "y": y,
+                "wires": [[ logId]],
+                "caname": "subflow",
+                "category": "routing"
+            },
+            {
+                "id": subflowOutId,
+                "type": "Subflow_out",
+                "z": tabId,
+                "name": "Business Logic Out",
+                "links":[],
+                "x": 50 + 2 * this.shiftx,
+                "y": y,
+                "wires":[],
+                "caname": "subflow",
+                "category": "routing"
+            },
+            {
+                "id": logId,
+                "type":"Logger",
+                "z": tabId,
+                "name": "Replace with logic",
+                "level": "INFO",
+                "message": "replace this node with business logic implementation",
+                "format": "string",
+                "headers": {},
+                "x": 50 + this.shiftx,
+                "y": y,
+                "wires":[[ subflowOutId ]],
+                "caname":"logger",
+                "category":"logging"
+            }
+        ]
+    }
+
+    getTab(tabName) {
+
+        return {
+
+            "id": this.getId(),
+
+            "type": "tab",
+
+            "label": tabName,
+
+            "disabled": false,
+
+            "info": ""
+
+        }
+
+    }
+
+    getEventListener(id, nextId, tabId, x, y, provider, verb, resource, notes) {
+        return {
+            "id": id,
+            "type": "EventListener",
+            "z": tabId,
+            "name": verb.toUpperCase() + " " + resource,
+            "provider": provider,
+            "eventSource": "api",
+            "dynamodbOperation": "",
+            "apiUrl": provider === "aws" ? resource : "",
+            "apiMethod": provider === "aws" ? verb : "",
+            "albMethod": "any",
+            "albUrl": "",
+            "bucketName": "",
+            "event": "",
+            "kapiUrl": "",
+            "kcronexpression": "",
+            "zapiUrl": provider === "azure" ? resource : "",
+            "zapiMethod": provider === "azure" ? verb : "",
+            "gapiUrl": provider === "gcp" ? resource : "",
+            "gapiMethod": provider === "gcp" ? verb : "",
+            "napiUrl": provider === "nodejs" ? resource : "",
+            "napiMethod": provider === "nodejs" ? verb : "",
+            "x": x,
+            "y": y,
+            "wires": [
+                [nextId]
+            ],
+            "caname": "event-handler",
+            "category": "general",
+            "info": notes || ""
+        }
+    }
+
+    getTest(tabId, x, y, verb, resource, statusCode) {
+
+        const idEnd = this.getId();
+        const idStart = this.getId();
+        const idAssert = this.getId();
+
+        return [{
+
+            "id": idAssert,
+            "type": "Assertion",
+            "z": tabId,
+            "name": "check status",
+            "selector": "statusCode",
+            "property": "hello",
+            "comparison": "equals",
+            "value": statusCode,
+            "valueType": "str",
+            "x": x + this.shiftx * 2,
+            "y": y,
+            "wires": [[idEnd]],
+            "caname": "test-assertion",
+            "category": "testing"
+        },
+        {
+            "id": idEnd,
+            "type": "TestCaseEnd",
+            "z": tabId,
+            "name": "TestCaseEnd",
+            "x": x + this.shiftx * 3,
+            "y": y,
+            "wires": [],
+            "caname": "test-case-end",
+            "category": "testing"
+        },
+        {
+            "id": idStart,
+            "type": "HTTPTestCase",
+            "z": tabId,
+            "name": "HTTP Test " + verb + " " + resource,
+            "method": verb.toUpperCase(),
+            "path": resource,
+            "headers": {
+                "Accept": "application/json"
+            },
+            "authtype": "none",
+            "secUser": "",
+            "secPassword": "",
+            "secToken": "",
+            "payload": "",
+            "x": x + this.shiftx,
+            "y": y,
+            "wires": [[idAssert]],
+            "caname": "http-test-case",
+            "category": "testing"
+        }];
+    }
+    
+    getXML(id, nextId, tabId, x, y) {
+        return {
+            "id": id, 
+            "type":"XML",
+            "z": tabId,
+            "name":"XML",
+            "property":"msg.payload",
+            "attr":"",
+            "chr":"",
+            "x":x,
+            "y":y,
+            "wires":[ [nextId] ],
+            "caname":"XML",
+            "category":"transformation"
+        }
+    }
+
+    getForm(id, nextId, tabId, x, y) {
+      return {
+        "id":id,
+        "type":"Form Data",
+        "z":tabId,
+        "name":"Form Data",
+        "attr":"",
+        "chr":"",
+        "x":x,
+        "y":y,
+        "wires":[[nextId]],
+        "caname":"Form2Json",
+        "category":"transformation"}
+    }
+
+    getSetProperty(id, nextId, tabId, x, y) {
+        return {
+            "id":id,
+            "type":"Set-Property",
+            "z":tabId,
+            "name":"Set Content Type",
+            "rules":[
+                {
+                    "t":"set",
+                    "p":"contentType",
+                    "pt":"camsg",
+                    "to":"$exists(msg.header.event.Records[0].headers.'Content-Type') ? msg.header.event.Records[0].headers.'Content-Type' : msg.header.event.Records[0].headers.'content-type'",
+                    "tot":"jsonata"
+                }
+            ],
+            "action":"",
+            "property":"",
+            "from":"",
+            "to":"",
+            "reg":false,
+            "x":x,
+            "y":y,
+            "wires":[[ nextId ]],
+            "caname":"setproperty",
+            "category":"transformation"
+        };
+    }
+
+    getSwitch(id, tabId, x, y, label) {
+
+        let s = {
+            "id":id,
+            "type":"Switch",
+            "z":tabId,
+            "name": label,
+            "property":"msg.contentType",
+            "propertyType":"",
+            "rules":[],
+            "repair":false,
+            "outputs":0,
+            "x":x,
+            "y":y,
+            "wires":[],
+            "caname":"switch",
+            "category":"routing"
+        }
+
+        return s;
+    }
+
+    handleApi(projectName, provider = "aws") {
+
+        const flowFileName = projectName + "-flow.json";
+
+        const { codegen } = require('@kumologica/builder');
+        const packageInfo = require('../../../package.json');
+        
+		let pc = codegen.genPackageJson(
+            projectName, 
+            "lambda.js",
+            flowFileName, 
+            packageInfo.version,
+            this.api?.info?.title,  
+            this.api?.info?.version, 
+            this.api?.info?.description,
+            this.api?.info?.contact ? this.api?.info?.contact?.email: "",
+            this.api?.info?.license ? this.api?.info?.license?.name: "MIT");
+
+        const paths = this.api.paths;
+
+        let flow = [];
+
+        Object.keys(paths).forEach(path => {
+
+            const svc = paths[path];
+            flow = flow.concat(this.handleResource(path, svc, provider));
+
+        })
+
+        return { pck: pc, flow: flow };
+    }
+
+    generateTabName(path, v) {
+
+        return v.toUpperCase() + ":" + path;
+
+    }
+
+    updateIdsAndPosition(id, nextId, x) {
+        id = nextId;
+        nextId = this.getId();
+        x += this.shiftx;
+        return { id, nextId, x };
+    }
+
+    handleVerb(path, v, verb, provider) {
+
+        const resource = path.replace(/{/g, ":").replace(/}/g, "");
+        const tabName = this.generateTabName(resource, v);
+
+        console.log(`  ${v}: ${path}`);
+
+        let x = 50;
+        let y = 50;
+        let listenerEndY = 50; // to align listeners end
+        let listenerEndX = 50; // to align listeners end
+        let flow = [];
+
+        // create tab for verb - resource
+        const tab = this.getTab(tabName);
+        flow.push(tab);
+               
+        let id = this.getId();
+        let nextId = this.getId();
+        let logicId = this.getId();     
+
+        flow.push(this.getEventListener(id, nextId, tab.id, x, y, provider, v, resource, verb.summary + "\n" + verb.description));
+        ({ id, nextId, x } = this.updateIdsAndPosition(id, nextId, x));        
+
+        flow.push(this.getLog(id,  nextId, tab.id, x, y, "Log Request", "received: " + v + " " + resource, "INFO"));
+        ({ id, nextId, x } = this.updateIdsAndPosition(id, nextId, x));
+                       
+
+        // Handle requestBody content
+        if (verb.requestBody && verb.requestBody.content) {
+ 
+            const requestBodyContentTypes = Object.keys(verb.requestBody.content);
+            
+            let switchNode;
+          
+
+            if (requestBodyContentTypes.length > 1) {
+                // set content type
+                flow.push(this.getSetProperty(id, nextId, tab.id, x, y));
+                ({ id, nextId, x } = this.updateIdsAndPosition(id, nextId, x));
+
+                // switch
+                switchNode = this.getSwitch(id, tab.id, x, y, "Request Content Type"); // add switch node with no wires (no nextId)
+                flow.push(switchNode);
+                ({ id, nextId, x } = this.updateIdsAndPosition(id, nextId, x));
+            }
+
+            const requestX = x;
+            requestBodyContentTypes.forEach((contentType, i) => {
+                const content = verb.requestBody.content[contentType];
+                
+                let schemaId = content.schema? id: logicId;
+        
+                let currId = null;     
+
+                // for application/json there is no need for conversion, just pass through to validation
+                if (contentType === 'application/xml') {
+                    currId = this.getId();
+                    flow.push(this.getXML(currId, schemaId, tab.id, requestX, y + (i * this.shifty)));
+
+                } else if (contentType === 'application/x-www-form-urlencoded') {
+                    currId = this.getId();
+                    flow.push(this.getForm(currId, schemaId, tab.id, requestX, y + (i * this.shifty)));
+            
+                } else {
+                    // link switch to schema or logic node
+                   // currId = logicId;
+                }
+
+                // attach schema to current content type and point to the logic node,
+                if (content.schema) {
+                    const schema = this.getSchema(schemaId, logicId, tab.id, requestX + this.shiftx, y + (i * this.shifty), JSON.stringify(content.schema, null, 2));
+                    x = requestX + this.shiftx;
+                    ({ id, nextId, x } = this.updateIdsAndPosition(id, nextId, x));
+                
+                    flow.push(schema);
+                   // logicNode.x = schema.x + this.shiftx; // adjust logic node x position
+                    
+                }
+
+                if (switchNode) {
+                    if (!currId) {
+                        currId = schemaId;
+                    }
+                    switchNode.rules.push({t: "eq", v: contentType, vt: "str"});
+                    switchNode.outputs++;
+                    switchNode.wires.push([ currId ]);
+                }
+
+            });
+        } else {
+             logicId = id;
+        }
+
+        // set logic node, x will be updated
+        const logicInId = this.getId(); // this is for business logic subflow in
+        let logicNode = this.getLogicCall(logicId, nextId, tab.id, x, y, logicInId);
+
+        //let logicNode = this.getLog(logicId, nextId, tab.id, x , y, "Log Logic", "logic for: " + v + " " + resource, "INFO");
+        ({ id, nextId, x } = this.updateIdsAndPosition(id, nextId, x));
+
+        flow.push(logicNode);
+        x = logicNode.x + this.shiftx;
+        listenerEndX = x;
+
+        //sort by code
+        const sortedResponses = Object.keys(verb.responses).sort((a, b) => a.localeCompare(b));
+ 
+        let currId = null;
+        // 200, 201, 400, 500, ...
+        sortedResponses.forEach((r, i) => {
+            const res = verb.responses[r];
+            // Transform headers into key-value pair with empty string values
+            const transformedHeaders = Object.keys(res.headers || {}).reduce((acc, headerKey) => {
+                acc[headerKey] = "";
+                return acc;
+            }, {});
+
+            //console.log(" processing " + r);
+
+            // for each content type
+            let responseSwitchNode = null;
+
+            //console.log((JSON.stringify(verb.responses[r])));
+            if ( res.content) {
+                
+                if (Object.keys(res.content).length > 1) {
+
+                    responseSwitchNode = this.getSwitch(id, tab.id, x, y, "Response Content Type"); // add switch node with no wires (no nextId)
+                    flow.push(responseSwitchNode);
+                    listenerEndX += this.shiftx;
+
+                    ({ id, nextId, x } = this.updateIdsAndPosition(id, nextId, x));
+                    logicNode.wires.push([ responseSwitchNode.id ]);
+                }
+
+                Object.keys(res.content).sort((a, b) => b.localeCompare(a)).forEach((c) => {
+
+                    currId = null;
+                    if (c === 'application/xml') {
+                        currId = id;
+                        flow.push(this.getXML(currId, nextId, tab.id, x, y + (i * this.shifty)));
+                        ({ id, nextId, x } = this.updateIdsAndPosition(id, nextId, x));
+                        listenerEndX += this.shiftx;
+                    }
+                    const endId = id;
+                    flow.push(this.getLog(id, nextId, tab.id, listenerEndX, listenerEndY, "Log Response " + r, `msg.payload`, "INFO"));
+                    ({ id, nextId, x } = this.updateIdsAndPosition(id, nextId, x));
+         
+                    flow.push(this.getEventListenerEnd(id, tab.id, listenerEndX+this.shiftx, listenerEndY, r, null, res.description, { ...transformedHeaders, "Content-Type": c }));
+                    listenerEndY += this.shifty;
+                    ({ id, nextId, x } = this.updateIdsAndPosition(id, nextId, x));
+
+                    if (responseSwitchNode) {
+                        responseSwitchNode.rules.push({t: "eq", v: c, vt: "str"});
+                        responseSwitchNode.outputs++;
+                        responseSwitchNode.wires.push([ currId? currId: endId ]);
+                    }
+
+                });
+            } else {
+
+                // just end or exception
+                if (i == 0) {
+                    flow.push(this.getLog(id, nextId, tab.id, listenerEndX, listenerEndY, "Log Response " + r, "msg.payload", "INFO"));
+                    ({ id, nextId, x } = this.updateIdsAndPosition(id, nextId, x));
+
+                } else if ((r.startsWith("4") || r.startsWith("5")) ) {
+                    flow.push(this.getError(this.getId(), nextId, tab.id, listenerEndX-this.shiftx, listenerEndY, r, res.description));;
+                    ({ id, nextId, x } = this.updateIdsAndPosition(id, nextId, x));
+                   
+                    flow.push(this.getLog(id, nextId, tab.id, listenerEndX, listenerEndY, "Log Error " + r, `msg.error = null? "Error: ${r}": msg.error`, "ERROR"));
+                    ({ id, nextId, x } = this.updateIdsAndPosition(id, nextId, x));
+        
+                }
+                flow.push(this.getEventListenerEnd(id, tab.id, listenerEndX+this.shiftx, listenerEndY, r, null, res.description, { ...transformedHeaders, "Content-Type": "application/json" }));
+               
+                //flow = [...flow, ...this.getTest(tab.id, listenerEndX + this.shiftx, listenerEndY, v, resource, r)];
+  
+                listenerEndY += this.shifty;
+            }
+        });
+
+        flow = [...flow, ...this.getLogicSubflow(logicInId, tab.id, listenerEndY)]; 
+        
+        return flow;
+    }
+
+    handleResource(path, svc, provider) {
+
+        let flow = [];
+
+        Object.keys(svc).forEach(v => {
+            const verb = svc[v];
+            flow = flow.concat(this.handleVerb(path, v, verb, provider));
+        })
+
+        return flow;
+    }
+}
+
+module.exports = {
+    OpenApiBuilder
+}

package/cli/commands/create-commands/index.js

@@ -1,5 +1,7 @@
 const createProjectIteratively  = require('./create-project-iteratively');
+const createOpenApiProject = require('./openapi');
 
 module.exports = {
-    createProjectIteratively
+    createProjectIteratively,
+    createOpenApiProject
 }

package/cli/commands/create-commands/openapi.js

@@ -1,42 +1,65 @@
-const pathlib = require('path');
-const { prompt, Select } = require('enquirer');
-const { logNotice, logError } = require('../../utils/logger');
-const { downloadTemplateFromRepo, listAvailableTemplates } = require('../../utils/download-template-from-repo');
-
-async function createProjectIteratively(){
-    const availableTemplates = await listAvailableTemplates();
-    // Project name
-    const projectNameResponse = await prompt({
-        type: 'input',
-        name: 'projectName',
-        message: 'Enter the name for the project'
-    });
-    let aProjectName = projectNameResponse.projectName;
-
-    // Target Path
-    const directoryResponse = await prompt({
-        type: 'input',
-        name: 'directory',
-        message: 'Enter the path where the project will be created '
-    });
-    let aProjectPath = directoryResponse.directory;
-
-    // Template name
-    const promptTemplate = new Select({
-        name: 'template',
-        message: 'Pick one of the available templates',
-        choices: availableTemplates
-      });
-
-    let aTemplateName = await promptTemplate.run();
-
-    try{
-        await downloadTemplateFromRepo(undefined, aTemplateName, aProjectPath, aProjectName);
-        logNotice(`Successfully created project: ${pathlib.join(aProjectPath, aProjectName)}`)
-    } catch (err){
-        logError(`Error found while creating project due to: ${err.message}`)
+const { logNotice, logError, logInfo } = require('../../utils/logger');
+const SwaggerParser = require('@apidevtools/swagger-parser');
+const { OpenApiBuilder } = require('./OpenApiBuilder');
+const path = require('path');
+const fs = require('fs-extra');
+const { URL } = require('url');
+
+function getFileName(fullPath) {
+    let fileName;
+
+    try {
+        // Check if the path is a URL
+        const url = new URL(fullPath);
+        fileName = path.basename(url.pathname);
+    } catch (e) {
+        // If it's not a valid URL, treat it as a filesystem path
+        fileName = path.basename(fullPath);
     }
+
+    // Remove the file extension
+    return fileName.replace(path.extname(fileName), '');
 }
+
+function createProject(p, projectName, pck, flow) {
+
+    // create project directory
+    const rootDir = path.join(p || process.cwd(), projectName);
+
+   // logInfo(rootDir);
+    fs.ensureDir(rootDir);
     
+    fs.outputFileSync(path.join(rootDir, projectName + "-flow.json"), JSON.stringify(flow, null, 2), 'utf-8');
+    fs.outputFileSync(path.join(rootDir, "package.json"), pck, 'utf-8');
+
+    return rootDir;
+}
+
+async function createOpenApiProject(p, apiSpec) {
 
-module.exports = createProjectIteratively;
+    try {
+      const api = await SwaggerParser.validate(apiSpec);
+
+      // Print some basic API info.
+       logInfo(`Successfully parsed API: ${api?.info?.title}`);
+       logInfo(`Version: ${api?.info?.version}`);
+       const projectName = getFileName(apiSpec);
+    
+       const builder = new OpenApiBuilder(api);
+       const response = builder.handleApi(projectName);
+
+       const rootDir = createProject(p, projectName, response.pck, response.flow);
+
+       logInfo(" ");
+       logInfo("Project created successfully.");
+       logInfo("To open project in kumologica designer run the following command:");
+       logInfo("kl open " + rootDir);
+
+    } catch (error) {
+        logError("Error parsing OpenAPI specification:", error.message);
+        logError(error);
+        return;
+    }
+}
+    
+module.exports = createOpenApiProject;

package/cli/commands/create.js

@@ -3,7 +3,8 @@ const { codegen } = require('@kumologica/builder');
 
 const { logNotice, logError } = require('../utils/logger');
 const { downloadTemplateFromRepo, isPlainGitURL } = require('../utils/download-template-from-repo');
-const { createProjectIteratively } = require('./create-commands');
+const { createProjectIteratively, 
+    createOpenApiProject } = require('./create-commands');
 
 exports.command = 'create [options]'
 exports.builder = (yargs) => {
@@ -33,6 +34,11 @@ exports.desc = 'Create a kumologica project. Do not pass any options to create i
 exports.handler = async ({ path, template, api }) => {
     const { version } = require('../../package.json');
 
+    if (api) {
+        createOpenApiProject(path, api);
+        return;
+    }
+
     if (!path && !template && !api) {
         await createProjectIteratively();
         

package/cli/commands/run.js

@@ -100,23 +100,24 @@ exports.handler = async ({ project_directory, loglevel, port, taskName, args })
       },
       body: JSON.stringify({args: args})
     };
-    const url = `http://127.0.0.1:${port||1880}/__task__/${tName}`;
-    
-    const response = await fetch(url, req);
-    const data = await response.text();
-    
-    logInfo("Status:  " + response.status);
-    logInfo("Message: " + data);
-
-    await server.stop();
-    
-    exitCode = response.status >= 200 && response.status < 300 ? 0 : 1;
 
+    if (tName) {
+      const url = `http://127.0.0.1:${port||1880}/__task__/${tName}`;
+      
+      const response = await fetch(url, req);
+      const data = await response.text();
+      
+      logInfo("Status:  " + response.status);
+      logInfo("Message: " + data);
+
+      await server.stop();
+      
+      exitCode = response.status >= 200 && response.status < 300 ? 0 : 1;
+      process.exit(exitCode);  // this is task, terminate after completion
+    } 
   } catch (e) {
     logFatal(e.message);
   }
-
-  process.exit(exitCode);
 };
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kumologica/sdk",
-  "version": "3.6.1",
+  "version": "3.6.2-beta2",
   "productName": "Kumologica Designer",
   "copyright": "Copyright 2020 Kumologica Pty Ltd, All Rights Reserved.",
   "author": "Kumologica Pty Ltd <contact@kumologica.com>",
@@ -63,6 +63,7 @@
   },
   "license": "Proprietary",
   "dependencies": {
+    "@apidevtools/swagger-parser": "^10.1.1",
     "@aws-sdk/client-api-gateway": "^3.556.0",
     "@aws-sdk/client-cloudformation": "^3.556.0",
     "@aws-sdk/client-cloudwatch-events": "^3.556.0",
@@ -82,9 +83,9 @@
     "@aws-sdk/credential-providers": "^3.556.0",
     "@aws-sdk/lib-dynamodb": "^3.549.0",
     "@electron/remote": "^2.0.8",
-    "@kumologica/builder": "3.6.1",
-    "@kumologica/devkit": "3.6.1",
-    "@kumologica/runtime": "3.6.1",
+    "@kumologica/builder": "3.6.2-beta2",
+    "@kumologica/devkit": "3.6.2-beta2",
+    "@kumologica/runtime": "3.6.2-beta2",
     "adm-zip": "0.4.13",
     "ajv": "8.10.0",
     "archive-type": "^4.0.0",
@@ -148,7 +149,7 @@
     "when": "3.7.8",
     "wide-align": "^1.1.5",
     "wildcard-match": "^5.1.2",
-    "ws": "7.5.9",
+    "ws": "8.18.1",
     "xterm": "4.1.0",
     "xterm-addon-fit": "0.2.1",
     "yargs": "17.3.1"

package/src/app/main-process/modal-home.js

@@ -39,6 +39,7 @@ class ModalHome {
     };
 
     this.window = new BrowserWindow(windowOptions);
+    require('@electron/remote/main').enable(this.window.webContents);
 
     this.window.on('focus', () => this.window.webContents.send('focus'));
     this.window.on('blur', () => this.window.webContents.send('blur'));

package/src/app/main-process/modal-welcome.js

@@ -38,6 +38,8 @@ class ModalWelcome {
 
     this.window = new BrowserWindow(windowOptions);
 
+    require('@electron/remote/main').enable(this.window.webContents);
+
     this.window.on('focus', () => this.window.webContents.send('focus'));
     this.window.on('blur', () => this.window.webContents.send('blur'));