@kumologica/sdk 3.6.0 → 3.6.2-beta1

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-commands/signup.js

@@ -0,0 +1,425 @@
+const {
+  CognitoIdentityProviderClient,
+  SignUpCommand,
+  ConfirmSignUpCommand,
+  InitiateAuthCommand,
+  RefreshTokenCommand,
+} = require('@aws-sdk/client-cognito-identity-provider');
+const fs = require('fs').promises;
+const path = require('path');
+const axios = require('axios');
+const { prompt } = require('enquirer'); // Import enquirer for prompting
+
+// Simulated DNS-based config fetch
+async function fetchCognitoConfig(dnsName = 'config.myapp.com') {
+  try {
+    const response = await axios.get(`https://${dnsName}/cognito-config`);
+    return response.data;
+  } catch (err) {
+    console.error('Config fetch error:', err.message);
+    return {
+      region: 'YOUR_AWS_REGION',        // e.g., 'us-east-1'
+      userPoolId: 'YOUR_USER_POOL_ID',  // e.g., 'us-east-1_abc123'
+      clientId: 'YOUR_CLIENT_ID'        // e.g., '1a2b3c4d5e6f7g8h9i0j'
+    };
+  }
+}
+
+// Directory and file for storing tokens
+const tokensDir = path.join(__dirname, 'tokens');
+const tokensFile = path.join(tokensDir, 'tokens.json');
+
+// --- Initialize Cognito Client with Dynamic Config ---
+async function getCognitoClient() {
+  const config = await fetchCognitoConfig();
+  return {
+    client: new CognitoIdentityProviderClient({ region: config.region }),
+    userPoolId: config.userPoolId,
+    clientId: config.clientId,
+  };
+}
+
+// --- Signup Function with Email Verification ---
+async function signUp(email, password, client, clientId) {
+  const params = {
+    ClientId: clientId,
+    Username: email,
+    Password: password,
+    UserAttributes: [{ Name: 'email', Value: email }],
+  };
+
+  const command = new SignUpCommand(params);
+  const result = await client.send(command);
+  console.log('Signup successful! Please check your email for a verification code.', result.UserSub);
+  return result;
+}
+
+// --- Email Verification Function ---
+async function verifyEmail(email, verificationCode, client, clientId) {
+  const params = {
+    ClientId: clientId,
+    Username: email,
+    ConfirmationCode: verificationCode,
+  };
+
+  const command = new ConfirmSignUpCommand(params);
+  const result = await client.send(command);
+  console.log('Email verified successfully!');
+  return result;
+}
+
+// --- Login Function ---
+async function login(email, password, client, clientId) {
+  const params = {
+    AuthFlow: 'USER_PASSWORD_AUTH',
+    ClientId: clientId,
+    AuthParameters: { USERNAME: email, PASSWORD: password },
+  };
+
+  const command = new InitiateAuthCommand(params);
+  const result = await client.send(command);
+  const tokens = {
+    accessToken: result.AuthenticationResult.AccessToken,
+    idToken: result.AuthenticationResult.IdToken,
+    refreshToken: result.AuthenticationResult.RefreshToken,
+  };
+  console.log('Login successful!', tokens);
+
+  await fs.mkdir(tokensDir, { recursive: true });
+  await fs.writeFile(tokensFile, JSON.stringify(tokens, null, 2));
+  console.log('Tokens stored in', tokensFile);
+
+  return tokens;
+}
+
+// --- Token Validation Function ---
+function validateToken(token) {
+  try {
+    const decoded = JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString());
+    const currentTime = Math.floor(Date.now() / 1000);
+    if (decoded.exp < currentTime) {
+      console.log('Token expired');
+      return false;
+    }
+    console.log('Token is valid');
+    return true;
+  } catch (err) {
+    console.error('Token validation error:', err.message);
+    return false;
+  }
+}
+
+// --- Refresh Token Function ---
+async function refreshToken(refreshToken, client, clientId) {
+  const params = {
+    AuthFlow: 'REFRESH_TOKEN_AUTH',
+    ClientId: clientId,
+    AuthParameters: { REFRESH_TOKEN: refreshToken },
+  };
+
+  const command = new RefreshTokenCommand(params);
+  const result = await client.send(command);
+  const newTokens = {
+    accessToken: result.AuthenticationResult.AccessToken,
+    idToken: result.AuthenticationResult.IdToken,
+    refreshToken: refreshToken,
+  };
+  console.log('Token refreshed successfully!', newTokens);
+
+  await fs.writeFile(tokensFile, JSON.stringify(newTokens, null, 2));
+  console.log('Refreshed tokens updated in', tokensFile);
+
+  return newTokens;
+}
+
+// --- Check for Existing Tokens ---
+async function getStoredTokens() {
+  try {
+    const data = await fs.readFile(tokensFile, 'utf8');
+    return JSON.parse(data);
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      console.log('No stored tokens found.');
+      return null;
+    }
+    throw err;
+  }
+}
+
+// --- Updated Main Function with Enquirer Prompt ---
+async function main() {
+  const email = 'user@example.com'; // You could prompt for this too
+  const password = 'SecurePass123!'; // You could prompt for this too
+
+  try {
+    const { client, clientId } = await getCognitoClient();
+
+    const storedTokens = await getStoredTokens();
+
+    if (storedTokens) {
+      const isValid = validateToken(storedTokens.accessToken);
+      if (isValid) {
+        console.log('Using existing valid tokens:', storedTokens);
+        return storedTokens;
+      } else {
+        const refreshedTokens = await refreshToken(storedTokens.refreshToken, client, clientId);
+        console.log('Using refreshed tokens:', refreshedTokens);
+        return refreshedTokens;
+      }
+    } else {
+      // No tokens, proceed with signup
+      await signUp(email, password, client, clientId);
+
+      // Prompt user for verification code
+      const { verificationCode } = await prompt({
+        type: 'input',
+        name: 'verificationCode',
+        message: 'Enter the verification code sent to your email:',
+        validate: (value) => value.length > 0 || 'Please enter a valid code',
+      });
+
+      await verifyEmail(email, verificationCode, client, clientId);
+      const tokens = await login(email, password, client, clientId);
+      console.log('New tokens generated and stored:', tokens);
+      return tokens;
+    }
+  } catch (error) {
+    console.error('Error in process:', error.message);
+    throw error;
+  }
+}
+
+// Run the script
+main()
+  .then((tokens) => console.log('Final tokens:', tokens))
+  .catch((err) => console.error('Main execution failed:', err.message));
+
+
+
+  -----
+
+  v2
+
+  const {
+    CognitoIdentityProviderClient,
+    SignUpCommand,
+    ConfirmSignUpCommand,
+    InitiateAuthCommand,
+    RefreshTokenCommand,
+  } = require('@aws-sdk/client-cognito-identity-provider');
+  const fs = require('fs').promises;
+  const path = require('path');
+  const axios = require('axios');
+  const { prompt } = require('enquirer');
+  const jwt = require('jsonwebtoken');
+  const jwksClient = require('jwks-rsa');
+  
+  // Simulated DNS-based config fetch
+  async function fetchCognitoConfig(dnsName = 'config.myapp.com') {
+    try {
+      const response = await axios.get(`https://${dnsName}/cognito-config`);
+      return response.data;
+    } catch (err) {
+      console.error('Config fetch error:', err.message);
+      return {
+        region: 'YOUR_AWS_REGION',        // e.g., 'us-east-1'
+        userPoolId: 'YOUR_USER_POOL_ID',  // e.g., 'us-east-1_abc123'
+        clientId: 'YOUR_CLIENT_ID'        // e.g., '1a2b3c4d5e6f7g8h9i0j'
+      };
+    }
+  }
+  
+  // Directory and file for storing tokens
+  const tokensDir = path.join(__dirname, 'tokens');
+  const tokensFile = path.join(tokensDir, 'tokens.json');
+  
+  // --- Initialize Cognito Client with Dynamic Config ---
+  async function getCognitoClient() {
+    const config = await fetchCognitoConfig();
+    return {
+      client: new CognitoIdentityProviderClient({ region: config.region }),
+      userPoolId: config.userPoolId,
+      clientId: config.clientId,
+    };
+  }
+  
+  // --- Signup Function with Email Verification ---
+  async function signUp(email, password, client, clientId) {
+    const params = {
+      ClientId: clientId,
+      Username: email,
+      Password: password,
+      UserAttributes: [{ Name: 'email', Value: email }],
+    };
+  
+    const command = new SignUpCommand(params);
+    const result = await client.send(command);
+    console.log('Signup successful! Please check your email for a verification code.', result.UserSub);
+    return result;
+  }
+  
+  // --- Email Verification Function ---
+  async function verifyEmail(email, verificationCode, client, clientId) {
+    const params = {
+      ClientId: clientId,
+      Username: email,
+      ConfirmationCode: verificationCode,
+    };
+  
+    const command = new ConfirmSignUpCommand(params);
+    const result = await client.send(command);
+    console.log('Email verified successfully!');
+    return result;
+  }
+  
+  // --- Login Function ---
+  async function login(email, password, client, clientId) {
+    const params = {
+      AuthFlow: 'USER_PASSWORD_AUTH',
+      ClientId: clientId,
+      AuthParameters: { USERNAME: email, PASSWORD: password },
+    };
+  
+    const command = new InitiateAuthCommand(params);
+    const result = await client.send(command);
+    const tokens = {
+      accessToken: result.AuthenticationResult.AccessToken,
+      idToken: result.AuthenticationResult.IdToken,
+      refreshToken: result.AuthenticationResult.RefreshToken,
+    };
+    console.log('Login successful!', tokens);
+  
+    await fs.mkdir(tokensDir, { recursive: true });
+    await fs.writeFile(tokensFile, JSON.stringify(tokens, null, 2));
+    console.log('Tokens stored in', tokensFile);
+  
+    return tokens;
+  }
+  
+  // --- Full Token Validation Function for Production ---
+  async function validateToken(token, userPoolId, clientId) {
+    const jwksUri = `https://cognito-idp.${process.env.AWS_REGION || 'us-east-1'}.amazonaws.com/${userPoolId}/.well-known/jwks.json`;
+    const client = jwksClient({
+      jwksUri,
+      cache: true,
+      rateLimit: true,
+      jwksRequestsPerMinute: 5,
+    });
+  
+    function getKey(header, callback) {
+      client.getSigningKey(header.kid, (err, key) => {
+        if (err) {
+          callback(err);
+        } else {
+          const signingKey = key.getPublicKey();
+          callback(null, signingKey);
+        }
+      });
+    }
+  
+    return new Promise((resolve, reject) => {
+      jwt.verify(
+        token,
+        getKey,
+        {
+          issuer: `https://cognito-idp.${process.env.AWS_REGION || 'us-east-1'}.amazonaws.com/${userPoolId}`,
+          audience: clientId, // For access token; idToken uses 'aud' differently, adjust if validating idToken
+          algorithms: ['RS256'],
+        },
+        (err, decoded) => {
+          if (err) {
+            console.error('Token validation failed:', err.message);
+            resolve(false);
+          } else {
+            console.log('Token is valid:', decoded);
+            resolve(true);
+          }
+        }
+      );
+    });
+  }
+  
+  // --- Refresh Token Function ---
+  async function refreshToken(refreshToken, client, clientId) {
+    const params = {
+      AuthFlow: 'REFRESH_TOKEN_AUTH',
+      ClientId: clientId,
+      AuthParameters: { REFRESH_TOKEN: refreshToken },
+    };
+  
+    const command = new RefreshTokenCommand(params);
+    const result = await client.send(command);
+    const newTokens = {
+      accessToken: result.AuthenticationResult.AccessToken,
+      idToken: result.AuthenticationResult.IdToken,
+      refreshToken: refreshToken,
+    };
+    console.log('Token refreshed successfully!', newTokens);
+  
+    await fs.writeFile(tokensFile, JSON.stringify(newTokens, null, 2));
+    console.log('Refreshed tokens updated in', tokensFile);
+  
+    return newTokens;
+  }
+  
+  // --- Check for Existing Tokens ---
+  async function getStoredTokens() {
+    try {
+      const data = await fs.readFile(tokensFile, 'utf8');
+      return JSON.parse(data);
+    } catch (err) {
+      if (err.code === 'ENOENT') {
+        console.log('No stored tokens found.');
+        return null;
+      }
+      throw err;
+    }
+  }
+  
+  // --- Updated Main Function ---
+  async function main() {
+    const email = 'user@example.com';
+    const password = 'SecurePass123!';
+  
+    try {
+      const { client, userPoolId, clientId } = await getCognitoClient();
+  
+      const storedTokens = await getStoredTokens();
+  
+      if (storedTokens) {
+        const isValid = await validateToken(storedTokens.accessToken, userPoolId, clientId);
+        if (isValid) {
+          console.log('Using existing valid tokens:', storedTokens);
+          return storedTokens;
+        } else {
+          const refreshedTokens = await refreshToken(storedTokens.refreshToken, client, clientId);
+          console.log('Using refreshed tokens:', refreshedTokens);
+          return refreshedTokens;
+        }
+      } else {
+        await signUp(email, password, client, clientId);
+  
+        const { verificationCode } = await prompt({
+          type: 'input',
+          name: 'verificationCode',
+          message: 'Enter the verification code sent to your email:',
+          validate: (value) => value.length > 0 || 'Please enter a valid code',
+        });
+  
+        await verifyEmail(email, verificationCode, client, clientId);
+        const tokens = await login(email, password, client, clientId);
+        console.log('New tokens generated and stored:', tokens);
+        return tokens;
+      }
+    } catch (error) {
+      console.error('Error in process:', error.message);
+      throw error;
+    }
+  }
+  
+  // Run the script
+  main()
+    .then((tokens) => console.log('Final tokens:', tokens))
+    .catch((err) => console.error('Main execution failed:', err.message));
+
+    

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.0",
+  "version": "3.6.2-beta1",
   "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.0",
-    "@kumologica/devkit": "3.6.0",
-    "@kumologica/runtime": "3.6.0",
+    "@kumologica/builder": "3.6.2-beta1",
+    "@kumologica/devkit": "3.6.2-beta1",
+    "@kumologica/runtime": "3.6.2-beta1",
     "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'));