hotstaq 0.5.24

package/build/src/cli.js

@@ -0,0 +1,935 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var ppath = __importStar(require("path"));
+var fs = __importStar(require("fs"));
+var commander = __importStar(require("commander"));
+var HotStaq_1 = require("./HotStaq");
+var HotHTTPServer_1 = require("./HotHTTPServer");
+var HotLog_1 = require("./HotLog");
+var Hot_1 = require("./Hot");
+var HotTesterServer_1 = require("./HotTesterServer");
+var HotBuilder_1 = require("./HotBuilder");
+var HotCreator_1 = require("./HotCreator");
+var HotTesterMochaSelenium_1 = require("./HotTesterMochaSelenium");
+var HotDBMySQL_1 = require("./schemas/HotDBMySQL");
+var HotIO_1 = require("./HotIO");
+var HotAgentAPI_1 = require("./HotAgentAPI");
+var HotTesterMocha_1 = require("./HotTesterMocha");
+HotStaq_1.HotStaq.isWeb = false;
+var VERSION = "";
+var processor = new HotStaq_1.HotStaq();
+processor.logger.logLevel = HotLog_1.HotLogLevel.All;
+var hotsitePath = "";
+var globalLogLevel = null;
+/**
+ * Start the API server.
+ */
+function startAPIServer(server, loadedAPI, baseAPIUrl, dbinfo, isAPIOnly) {
+    return __awaiter(this, void 0, void 0, function () {
+        var foundModulePath, apiJS, apiClass, api, dbClass;
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    process.chdir(process.cwd());
+                    foundModulePath = require.resolve(loadedAPI.path, { paths: [process.cwd()] });
+                    apiJS = require(foundModulePath);
+                    apiClass = apiJS[loadedAPI.exportedClassName];
+                    api = new apiClass(baseAPIUrl, server);
+                    server.logger.info("Loaded API class: ".concat(loadedAPI.exportedClassName));
+                    server.processor.api = api;
+                    server.api = api;
+                    if (isAPIOnly === true) {
+                        server.addRoute("/", function (req, res) { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                res.json({ "status": "ok" });
+                                return [2 /*return*/];
+                            });
+                        }); });
+                    }
+                    if (!(dbinfo != null)) return [3 /*break*/, 3];
+                    dbClass = null;
+                    if (dbinfo.type === "mysql")
+                        dbClass = HotDBMySQL_1.HotDBMySQL;
+                    api.db = new dbClass();
+                    return [4 /*yield*/, server.setAPI(api)];
+                case 1:
+                    _a.sent();
+                    if (dbinfo.username === "")
+                        throw new Error("No database username provided!");
+                    if (dbinfo.password === "")
+                        throw new Error("No database password provided!");
+                    return [4 /*yield*/, api.db.connect(dbinfo)];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3: return [2 /*return*/, (api)];
+            }
+        });
+    });
+}
+/**
+ * Get a key/value pair from a string.
+ */
+function getKeyValuePair(str) {
+    var pos = str.indexOf("=");
+    var key = "";
+    var value = "";
+    if (pos > -1) {
+        key = str.substr(0, pos);
+        value = str.substr(pos + 1);
+    }
+    return ({ key: key, value: value });
+}
+/**
+ * Handle any build commands.
+ */
+function handleBuildCommands() {
+    return __awaiter(this, void 0, void 0, function () {
+        var builder, createHotBuilder, buildCmd;
+        var _this = this;
+        return __generator(this, function (_a) {
+            builder = null;
+            createHotBuilder = function () {
+                if (builder == null)
+                    builder = new HotBuilder_1.HotBuilder();
+            };
+            buildCmd = new commander.Command("build");
+            buildCmd.description("Build commands.");
+            buildCmd.action(function () { return __awaiter(_this, void 0, void 0, function () {
+                var tempHotsitePath;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            createHotBuilder();
+                            if (!(hotsitePath === "")) return [3 /*break*/, 2];
+                            tempHotsitePath = ppath.normalize("".concat(process.cwd(), "/HotSite.json"));
+                            return [4 /*yield*/, HotIO_1.HotIO.exists(tempHotsitePath)];
+                        case 1:
+                            /// @fixme Do this check without caps sensitivity.
+                            if ((_a.sent()) === true)
+                                hotsitePath = tempHotsitePath;
+                            _a.label = 2;
+                        case 2:
+                            if (hotsitePath === "")
+                                throw new Error("When building, you must specify a HotSite.json!");
+                            if (!(hotsitePath !== "")) return [3 /*break*/, 4];
+                            return [4 /*yield*/, processor.loadHotSite(hotsitePath)];
+                        case 3:
+                            _a.sent();
+                            _a.label = 4;
+                        case 4: return [4 /*yield*/, builder.build([processor.hotSite])];
+                        case 5:
+                            _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            /*buildCmd.option ("--watch, -w", "Watch the associated files and rebuild when changes are detected.",
+                (arg: string, previous: any) =>
+                {
+                    createHotBuilder ();
+                    builder.api = true;
+                });*/
+            /*buildCmd.option ("--api", "Build the web client to be used in a web browser.",
+                (arg: string, previous: any) =>
+                {
+                    createHotBuilder ();
+                    builder.api = true;
+                });*/
+            buildCmd.option("--docker", "Build Dockerfiles from the given HotSite.json. This will be the default option.", function (arg, previous) {
+                createHotBuilder();
+                builder.dockerFiles = true;
+            });
+            buildCmd.option("--dont-get-hard", "Do not use the default security hardening when generating the docker image.", function (arg, previous) {
+                createHotBuilder();
+                builder.dockerHardenSecurity = true;
+            });
+            buildCmd.option("--dont-append-readme", "Do not add the additional docker documentation to the existing README.md.", function (arg, previous) {
+                createHotBuilder();
+                builder.appendReadMe = true;
+            });
+            /*buildCmd.option ("--docker-compose", "Build the docker compose file from the given HotSite.json.",
+                (arg: string, previous: any) =>
+                {
+                    createHotBuilder ();
+                    builder.dockerCompose = true;
+                });
+            buildCmd.option ("--kubernetes", "Build a Kubernetes cluster from the given HotSite.json.",
+                (arg: string, previous: any) =>
+                {
+                    createHotBuilder ();
+                    builder.kubernetes = true;
+                });*/
+            buildCmd.option("--output", "The directory path to place all files.", function (arg, previous) {
+                createHotBuilder();
+                builder.outputDir = arg;
+            });
+            return [2 /*return*/, (buildCmd)];
+        });
+    });
+}
+/**
+ * Handle create commands.
+ */
+function handleCreateCommands() {
+    return __awaiter(this, void 0, void 0, function () {
+        var creator, createHotCreator, copyLibrariesPath, createCmd;
+        var _this = this;
+        return __generator(this, function (_a) {
+            creator = null;
+            createHotCreator = function () {
+                if (creator == null)
+                    creator = new HotCreator_1.HotCreator();
+            };
+            copyLibrariesPath = "";
+            createCmd = new commander.Command("create");
+            createCmd.description("Create a new project.");
+            createCmd.action(function (cmdr, args) { return __awaiter(_this, void 0, void 0, function () {
+                var name;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            createHotCreator();
+                            if (!(copyLibrariesPath !== "")) return [3 /*break*/, 2];
+                            return [4 /*yield*/, creator.copyLibraries(copyLibrariesPath)];
+                        case 1:
+                            _a.sent();
+                            return [2 /*return*/];
+                        case 2:
+                            if (args == null)
+                                throw new Error("You must supply an npm compatible project name!");
+                            if (args.length < 1)
+                                throw new Error("You must supply an npm compatible project name!");
+                            name = args[0];
+                            creator.name = name;
+                            creator.outputDir = ppath.normalize("".concat(process.cwd(), "/").concat(name, "/"));
+                            return [4 /*yield*/, creator.create()];
+                        case 3:
+                            _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            createCmd.option("--copy-libraries-to-location <path>", "Copy the latest HotStaq libraries to a specified location. This will not generate any projects.", function (path, previous) {
+                createHotCreator();
+                copyLibrariesPath = path;
+            }, "");
+            createCmd.option("--type <type>", "The type of app to create. Can be (web, web-api, api)", function (type, previous) {
+                createHotCreator();
+                creator.type = type;
+            }, "web-api");
+            createCmd.option("--code <language>", "Set the type of code output. Can be (ts, js) Default: ts", function (language, previous) {
+                createHotCreator();
+                creator.language = language;
+            }, "ts");
+            createCmd.option("--output <path>", "The directory path to place all the files.", function (path, previous) {
+                createHotCreator();
+                creator.outputDir = path;
+            }, "");
+            createCmd.option("--overwrite-cmd-create-init <value>", "Overwrite the create command for initalizing an app.", function (value, previous) {
+                createHotCreator();
+                creator.createCommands.init = value;
+            }, "");
+            createCmd.option("--overwrite-cmd-create-transpile <value>", "Overwrite the create command for transpiling.", function (value, previous) {
+                createHotCreator();
+                creator.createCommands.transpileTS = value;
+            }, "");
+            createCmd.option("--overwrite-cmd-npm-build-web-api <value>", "Overwrite the npm command for building the web api.", function (value, previous) {
+                createHotCreator();
+                creator.npmCommands.buildWebAPI = value;
+            }, "");
+            createCmd.option("--overwrite-cmd-npm-build-web-api-debug <value>", "Overwrite the npm command for building the debug script for web api.", function (value, previous) {
+                createHotCreator();
+                creator.npmCommands.buildWebAPIDebug = value;
+            }, "");
+            createCmd.option("--overwrite-cmd-npm-dev <value>", "Overwrite the npm command for building the development script.", function (value, previous) {
+                createHotCreator();
+                creator.npmCommands.dev = value;
+            }, "");
+            createCmd.option("--overwrite-cmd-npm-start <value>", "Overwrite the npm command for the start script.", function (value, previous) {
+                createHotCreator();
+                creator.npmCommands.start = value;
+            }, "");
+            createCmd.option("--overwrite-cmd-npm-test <value>", "Overwrite the npm command for the test script.", function (value, previous) {
+                createHotCreator();
+                creator.npmCommands.test = value;
+            }, "");
+            return [2 /*return*/, (createCmd)];
+        });
+    });
+}
+/**
+ * Handle run commands.
+ */
+function handleRunCommands() {
+    return __awaiter(this, void 0, void 0, function () {
+        var webServer, apiServer, testerSettings, apis, dbinfo, setupDB, serverType, baseWebUrl, baseAPIUrl, runWebTestMap, runAPITestMap, runCmd, serverTypes, _loop_1, iIdx;
+        var _this = this;
+        return __generator(this, function (_a) {
+            webServer = new HotHTTPServer_1.HotHTTPServer(processor);
+            apiServer = new HotHTTPServer_1.HotHTTPServer(processor);
+            testerSettings = {
+                tester: "HotTesterMochaSelenium",
+                address: "127.0.0.1",
+                browser: "chrome",
+                openDevTools: false,
+                headless: false,
+                remoteServer: "",
+                http: 8183,
+                https: 4143
+            };
+            apis = [];
+            dbinfo = null;
+            setupDB = function () {
+                if (dbinfo != null)
+                    return;
+                dbinfo = {
+                    "type": process.env["DATABASE_TYPE"] || "mysql",
+                    "server": process.env["DATABASE_SERVER"] || "127.0.0.1",
+                    "username": process.env["DATABASE_USERNAME"] || "",
+                    "password": process.env["DATABASE_PASSWORD"] || "",
+                    "org": process.env["DATABASE_ORG"] || "",
+                    "token": process.env["DATABASE_TOKEN"] || "",
+                    "port": 3306,
+                    "database": process.env["DATABASE_SCHEMA"] || ""
+                };
+                if (process.env["DATABASE_PORT"] != null) {
+                    try {
+                        dbinfo.port = parseInt(process.env["DATABASE_PORT"]);
+                    }
+                    catch (ex) {
+                        throw new Error("Unable to parse db port ".concat(process.env["DATABASE_PORT"]));
+                    }
+                }
+            };
+            serverType = "web";
+            baseWebUrl = "";
+            baseAPIUrl = "";
+            runWebTestMap = false;
+            runAPITestMap = false;
+            runCmd = new commander.Command("run");
+            runCmd.description("Run commands.");
+            runCmd.action(function () { return __awaiter(_this, void 0, void 0, function () {
+                var runWebServer, runAPIServer, testerServer, serverStarter, tester, mochaTester, mochaSeleniumTester, key, tempapi, path, apiToLoad, foundBaseUrl, loadAPI, getBaseUrlFromHotSite;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            runWebServer = false;
+                            runAPIServer = false;
+                            testerServer = null;
+                            if (!(processor.mode === Hot_1.DeveloperMode.Development)) return [3 /*break*/, 2];
+                            return [4 /*yield*/, HotTesterServer_1.HotTesterServer.startServer("http://".concat(testerSettings.address, ":").concat(testerSettings.http), testerSettings.http, testerSettings.https, processor)];
+                        case 1:
+                            serverStarter = _a.sent();
+                            testerServer = serverStarter.server;
+                            tester = null;
+                            if (testerSettings.tester === "HotTesterMocha") {
+                                mochaTester = new HotTesterMocha_1.HotTesterMocha(processor, "HotTesterMocha", baseWebUrl, null);
+                                tester = mochaTester;
+                            }
+                            if (testerSettings.tester === "HotTesterMochaSelenium") {
+                                mochaSeleniumTester = new HotTesterMochaSelenium_1.HotTesterMochaSelenium(processor, "HotTesterMochaSelenium", baseWebUrl);
+                                mochaSeleniumTester.driver.browser = testerSettings.browser;
+                                mochaSeleniumTester.driver.openDevTools = testerSettings.openDevTools;
+                                mochaSeleniumTester.driver.headless = testerSettings.headless;
+                                mochaSeleniumTester.driver.remoteServer = testerSettings.remoteServer;
+                                tester = mochaSeleniumTester;
+                            }
+                            testerServer.addTester(tester);
+                            _a.label = 2;
+                        case 2:
+                            if (!(hotsitePath !== "")) return [3 /*break*/, 4];
+                            return [4 /*yield*/, processor.loadHotSite(hotsitePath)];
+                        case 3:
+                            _a.sent();
+                            if (processor.hotSite != null) {
+                                if (processor.hotSite.apis != null) {
+                                    for (key in processor.hotSite.apis) {
+                                        tempapi = processor.hotSite.apis[key];
+                                        if (tempapi.libraryName != null) {
+                                            path = tempapi.filepath;
+                                            apiToLoad = {
+                                                exportedClassName: tempapi.apiName,
+                                                path: path
+                                            };
+                                            apis.push(apiToLoad);
+                                        }
+                                    }
+                                }
+                            }
+                            _a.label = 4;
+                        case 4:
+                            // Setup the DB if it hasn't already been setup.
+                            if (process.env["DATABASE_TYPE"] != null) {
+                                setupDB();
+                                dbinfo.type = process.env["DATABASE_TYPE"];
+                            }
+                            if (process.env["DATABASE_SERVER"] != null) {
+                                setupDB();
+                                dbinfo.server = process.env["DATABASE_SERVER"];
+                            }
+                            if (process.env["DATABASE_USERNAME"] != null) {
+                                setupDB();
+                                dbinfo.username = process.env["DATABASE_USERNAME"];
+                            }
+                            if (process.env["DATABASE_PASSWORD"] != null) {
+                                setupDB();
+                                dbinfo.password = process.env["DATABASE_PASSWORD"];
+                            }
+                            if (process.env["DATABASE_ORG"] != null) {
+                                setupDB();
+                                dbinfo.org = process.env["DATABASE_ORG"];
+                            }
+                            if (process.env["DATABASE_TOKEN"] != null) {
+                                setupDB();
+                                dbinfo.token = process.env["DATABASE_TOKEN"];
+                            }
+                            if (process.env["DATABASE_PORT"] != null) {
+                                setupDB();
+                                try {
+                                    dbinfo.port = parseInt(process.env["DATABASE_PORT"]);
+                                }
+                                catch (ex) {
+                                    throw new Error("Unable to parse db port ".concat(process.env["DATABASE_PORT"]));
+                                }
+                            }
+                            if (process.env["DATABASE_SCHEMA"] != null) {
+                                setupDB();
+                                dbinfo.database = process.env["DATABASE_SCHEMA"];
+                            }
+                            if (baseWebUrl === "") {
+                                foundBaseUrl = HotStaq_1.HotStaq.getValueFromHotSiteObj(processor.hotSite, ["server", "url"]);
+                                if (foundBaseUrl != null)
+                                    baseWebUrl = foundBaseUrl;
+                            }
+                            if (baseWebUrl === "")
+                                baseWebUrl = "http://127.0.0.1:".concat(webServer.ports.http);
+                            if ((serverType === "web") || (serverType === "web-api")) {
+                                if (processor.hotSite != null) {
+                                    if (processor.hotSite.server != null)
+                                        processor.hotSite.server.url = baseWebUrl;
+                                }
+                                runWebServer = true;
+                            }
+                            if ((serverType === "api") || (serverType === "web-api"))
+                                runAPIServer = true;
+                            loadAPI = apis[0];
+                            getBaseUrlFromHotSite = function () {
+                                var foundAPIUrl = null;
+                                // Attempt to find the base url from the HotSite's API.
+                                if (processor.hotSite != null) {
+                                    if (processor.hotSite.apis != null) {
+                                        for (var key in processor.hotSite.apis) {
+                                            var tempAPI = processor.hotSite.apis[key];
+                                            if (tempAPI.apiName != null) {
+                                                if (tempAPI.apiName === loadAPI.exportedClassName) {
+                                                    if (tempAPI.url != null)
+                                                        foundAPIUrl = tempAPI.url;
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                if (foundAPIUrl != null)
+                                    baseAPIUrl = foundAPIUrl;
+                            };
+                            if (!(serverType === "api")) return [3 /*break*/, 7];
+                            if (apis.length < 1)
+                                throw new Error("No APIs are loaded! Try using --api-load");
+                            if (baseAPIUrl === "")
+                                getBaseUrlFromHotSite();
+                            if (baseAPIUrl === "")
+                                baseAPIUrl = "http://127.0.0.1:".concat(apiServer.ports.http);
+                            // Only run the api server.
+                            return [4 /*yield*/, startAPIServer(apiServer, loadAPI, baseAPIUrl, dbinfo, true)];
+                        case 5:
+                            // Only run the api server.
+                            _a.sent();
+                            if (globalLogLevel != null)
+                                apiServer.logger.logLevel = globalLogLevel;
+                            apiServer.serverType = "API Server";
+                            return [4 /*yield*/, apiServer.listen()];
+                        case 6:
+                            _a.sent();
+                            _a.label = 7;
+                        case 7:
+                            if (!(runWebServer === true)) return [3 /*break*/, 12];
+                            if (!(runAPIServer === true)) return [3 /*break*/, 9];
+                            if (apis.length < 1)
+                                throw new Error("No APIs are loaded! Try using --api-load");
+                            if (baseAPIUrl === "")
+                                getBaseUrlFromHotSite();
+                            if (baseAPIUrl === "")
+                                baseAPIUrl = "http://127.0.0.1:".concat(webServer.ports.http);
+                            return [4 /*yield*/, startAPIServer(webServer, loadAPI, baseAPIUrl, dbinfo, false)];
+                        case 8:
+                            _a.sent();
+                            webServer.serverType = "Web-API Server";
+                            return [3 /*break*/, 10];
+                        case 9:
+                            webServer.serverType = "Web Server";
+                            _a.label = 10;
+                        case 10:
+                            if (globalLogLevel != null)
+                                webServer.logger.logLevel = globalLogLevel;
+                            return [4 /*yield*/, webServer.listen()];
+                        case 11:
+                            _a.sent();
+                            _a.label = 12;
+                        case 12:
+                            if (!(runWebTestMap === true)) return [3 /*break*/, 14];
+                            if (testerServer == null)
+                                throw new Error("Unable to execute tests! Is --development-mode missing?");
+                            return [4 /*yield*/, testerServer.executeAllWebTests(testerSettings.tester)];
+                        case 13:
+                            _a.sent();
+                            _a.label = 14;
+                        case 14:
+                            if (!(runAPITestMap === true)) return [3 /*break*/, 16];
+                            if (testerServer == null)
+                                throw new Error("Unable to execute tests! Is --development-mode missing?");
+                            return [4 /*yield*/, testerServer.executeAllAPITests(testerSettings.tester)];
+                        case 15:
+                            _a.sent();
+                            _a.label = 16;
+                        case 16: return [2 /*return*/];
+                    }
+                });
+            }); });
+            runCmd.option("--tester-http-port <port>", "Set the tester HTTP port", function (port, previous) {
+                try {
+                    var tempPort = parseInt(port);
+                    testerSettings.http = tempPort;
+                }
+                catch (ex) {
+                    processor.logger.error("Unable to parse tester http port ".concat(port));
+                }
+            }, testerSettings.http);
+            runCmd.option("--tester-https-port <port>", "Set the tester HTTPS port", function (port, previous) {
+                if (port == null)
+                    return;
+                if (port === "")
+                    return;
+                try {
+                    var tempPort = parseInt(port);
+                    testerSettings.https = tempPort;
+                }
+                catch (ex) {
+                    processor.logger.error("Unable to parse tester https port ".concat(port));
+                }
+            }, testerSettings.https);
+            runCmd.option("--tester-type <tester>", "Set the tester to use. Can be: HotTesterMocha,HotTesterMochaSelenium", function (tester, previous) {
+                testerSettings.tester = tester;
+            }, "HotTesterMochaSelenium");
+            runCmd.option("--tester-address <address>", "Set the tester address to listen on.", function (address, previous) {
+                testerSettings.address = address;
+            }, "127.0.0.1");
+            runCmd.option("--tester-browser <browser>", "Set the tester browser to use. Can only be used with tester type: HotTesterMochaSelenium", function (browser, previous) {
+                testerSettings.browser = browser;
+            }, "chrome");
+            runCmd.option("--tester-open-dev-tools", "Open the browsers dev tools on start. Can only be used with tester type: HotTesterMochaSelenium", function (value, previous) {
+                testerSettings.openDevTools = true;
+            }, "false");
+            runCmd.option("--tester-headless", "Make the browser headless. Can only be used with tester type: HotTesterMochaSelenium", function (value, previous) {
+                testerSettings.headless = true;
+            }, "false");
+            runCmd.option("--tester-remote-server <remote_server>", "Set the remote Selenium server to use for testing. Can only be used with tester type: HotTesterMochaSelenium", function (remoteServer, previous) {
+                testerSettings.remoteServer = remoteServer;
+            }, "");
+            serverTypes = ["web", "api"];
+            _loop_1 = function (iIdx) {
+                var currentServerType = serverTypes[iIdx];
+                var httpPort = 80;
+                var httpsPort = 443;
+                if (currentServerType === "api") {
+                    httpPort = 81;
+                    httpsPort = 444;
+                }
+                runCmd.option("--".concat(currentServerType, "-base-url <url>"), "Set the base ".concat(currentServerType, " server url."), function (url, previous) {
+                    if (currentServerType === "web")
+                        baseWebUrl = url;
+                    else
+                        baseAPIUrl = url;
+                }, "");
+                runCmd.option("--".concat(currentServerType, "-http-port <port>"), "Set the ".concat(currentServerType, " HTTP port"), function (port, previous) {
+                    try {
+                        var tempPort = parseInt(port);
+                        if (currentServerType === "web")
+                            webServer.ports.http = tempPort;
+                        else
+                            apiServer.ports.http = tempPort;
+                    }
+                    catch (ex) {
+                        processor.logger.error("Unable to parse ".concat(currentServerType, " http port ").concat(port));
+                    }
+                }, httpPort);
+                runCmd.option("--".concat(currentServerType, "-https-port [port]"), "Set the ".concat(currentServerType, " HTTPS port"), function (port, previous) {
+                    if (port == null)
+                        return;
+                    if (port === "")
+                        return;
+                    try {
+                        var tempPort = parseInt(port);
+                        if (currentServerType === "web")
+                            webServer.ports.https = tempPort;
+                        else
+                            apiServer.ports.https = tempPort;
+                    }
+                    catch (ex) {
+                        processor.logger.error("Unable to parse ".concat(currentServerType, " https port ").concat(port));
+                    }
+                }, httpsPort);
+                runCmd.option("--".concat(currentServerType, "-dont-redirect-http-to-https"), "Do not redirect ".concat(currentServerType, " HTTP traffic to HTTPS"), function (port, previous) {
+                    if (currentServerType === "web")
+                        webServer.redirectHTTPtoHTTPS = false;
+                    else
+                        apiServer.redirectHTTPtoHTTPS = false;
+                });
+                runCmd.option("--".concat(currentServerType, "-listen-address <address>"), "Set the ".concat(currentServerType, " listen address"), function (address, previous) {
+                    if (currentServerType === "web")
+                        webServer.listenAddress = address;
+                    else
+                        apiServer.listenAddress = address;
+                }, "0.0.0.0");
+                runCmd.option("--".concat(currentServerType, "-ssl-cert <path>"), "Set the path to the SSL cert for the ".concat(currentServerType, " server"), function (cert, previous) {
+                    if (currentServerType === "web")
+                        webServer.ssl.cert = cert;
+                    else
+                        apiServer.ssl.cert = cert;
+                }, "");
+                runCmd.option("--".concat(currentServerType, "-ssl-key <path>"), "Set the path to the SSL key for the ".concat(currentServerType, " server"), function (key, previous) {
+                    if (currentServerType === "web")
+                        webServer.ssl.key = key;
+                    else
+                        apiServer.ssl.key = key;
+                }, "");
+                runCmd.option("--".concat(currentServerType, "-ssl-ca <path>"), "Set the path to the SSL CA for the ".concat(currentServerType, " server"), function (ca, previous) {
+                    if (currentServerType === "web")
+                        webServer.ssl.ca = ca;
+                    else
+                        apiServer.ssl.ca = ca;
+                }, "");
+                runCmd.option("--".concat(currentServerType, "-log-level <level>"), "Set the logging level for the ".concat(currentServerType, " server. Can be (info,warning,error,all,none)"), function (logLevel, previous) {
+                    var tempServer = null;
+                    if (logLevel === "")
+                        return;
+                    if (currentServerType === "web")
+                        tempServer = webServer;
+                    else
+                        tempServer = apiServer;
+                    if (logLevel === "info")
+                        tempServer.logger.logLevel = HotLog_1.HotLogLevel.Info;
+                    if (logLevel === "warning")
+                        tempServer.logger.logLevel = HotLog_1.HotLogLevel.Warning;
+                    if (logLevel === "error")
+                        tempServer.logger.logLevel = HotLog_1.HotLogLevel.Error;
+                    if (logLevel === "verbose")
+                        tempServer.logger.logLevel = HotLog_1.HotLogLevel.Verbose;
+                    if (logLevel === "all")
+                        tempServer.logger.logLevel = HotLog_1.HotLogLevel.All;
+                    if (logLevel === "none")
+                        tempServer.logger.logLevel = HotLog_1.HotLogLevel.None;
+                }, "");
+                runCmd.option("--".concat(currentServerType, "-test"), "Execute all tests specified in HotSite.json. Must be used with --development-mode.", function (map, previous) {
+                    if (currentServerType === "web")
+                        runWebTestMap = true;
+                    else
+                        runAPITestMap = true;
+                });
+                if (currentServerType === "web") {
+                    runCmd.option("--".concat(currentServerType, "-route <route_and_path>"), "Add a static route in \"key=path\" format. Example: --".concat(currentServerType, "-route \"/=/var/www\""), function (routeAndPath, previous) {
+                        var keyValuePair = getKeyValuePair(routeAndPath);
+                        var route = keyValuePair.key;
+                        var path = keyValuePair.value;
+                        webServer.addStaticRoute(route, path);
+                    });
+                    runCmd.option("--".concat(currentServerType, "-serve-hott-files"), "Serve Hott files", function (port, previous) {
+                        webServer.serveHottFiles = true;
+                    });
+                    runCmd.option("--".concat(currentServerType, "-js-url <url>"), "The url to the HotStaq JS", function (url, previous) {
+                        webServer.hottFilesAssociatedInfo.jsSrcPath = url;
+                    });
+                }
+                if (currentServerType === "api") {
+                    runCmd.option("--".concat(currentServerType, "-load <exported_name_and_path>"), "Load an API for use in \"exported_name=path_to_js_file\" format. Example: --".concat(currentServerType, "-load \"FreeLightAPI=/app/FreeLight/build/src/FreeLightAPI.js\""), function (exported_name_and_path, previous) {
+                        var keyValuePair = getKeyValuePair(exported_name_and_path);
+                        var exportedClassName = keyValuePair.key;
+                        var path = keyValuePair.value;
+                        apis.push({ exportedClassName: exportedClassName, path: path });
+                    });
+                }
+            };
+            for (iIdx = 0; iIdx < serverTypes.length; iIdx++) {
+                _loop_1(iIdx);
+            }
+            runCmd.option("--server-type <type>", "Set the type of server. Can be (web, api, web-api)", function (type, previous) {
+                serverType = type;
+            }, "web");
+            runCmd.option("--db-type <type>", "The type of database to use. Can be (mysql, influx)", function (type, previous) {
+                setupDB();
+                dbinfo.type = type;
+            }, "mysql");
+            runCmd.option("--db-server <address>", "The address to the database", function (address, previous) {
+                setupDB();
+                dbinfo.server = address;
+            }, "127.0.0.1");
+            runCmd.option("--db-username <username>", "The database's username", function (username, previous) {
+                setupDB();
+                dbinfo.username = username;
+            });
+            runCmd.option("--db-password <password>", "The database's password. This is insecure to use on the command line!", function (password, previous) {
+                setupDB();
+                dbinfo.password = password;
+            });
+            runCmd.option("--db-port <port>", "The database's port", function (port, previous) {
+                setupDB();
+                try {
+                    dbinfo.port = parseInt(port);
+                }
+                catch (ex) {
+                    processor.logger.error("Unable to parse db port ".concat(port));
+                }
+            }, "3306");
+            runCmd.option("--db-database <schema>", "The database's schema to select", function (schema, previous) {
+                setupDB();
+                dbinfo.database = schema;
+            });
+            return [2 /*return*/, (runCmd)];
+        });
+    });
+}
+/**
+ * Handle any agent commands.
+ */
+function handleAgentCommands() {
+    return __awaiter(this, void 0, void 0, function () {
+        var baseAPIUrl, agentKey, agentSecret, commands, listenAddr, port, agentCmd;
+        var _this = this;
+        return __generator(this, function (_a) {
+            baseAPIUrl = "";
+            agentKey = "";
+            agentSecret = "";
+            commands = {};
+            listenAddr = "0.0.0.0";
+            port = 5468;
+            agentCmd = new commander.Command("agent");
+            agentCmd.description("Listen for commands on a port.");
+            agentCmd.action(function () { return __awaiter(_this, void 0, void 0, function () {
+                var processor, apiServer, api;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            processor = new HotStaq_1.HotStaq();
+                            processor.logger.logLevel = HotLog_1.HotLogLevel.Verbose;
+                            apiServer = new HotHTTPServer_1.HotHTTPServer(processor);
+                            api = new HotAgentAPI_1.HotAgentAPI(baseAPIUrl, apiServer);
+                            api.key = agentKey;
+                            api.secret = agentSecret;
+                            apiServer.listenAddress = listenAddr;
+                            apiServer.ports.http = port;
+                            apiServer.processor.api = api;
+                            apiServer.api = api;
+                            return [4 /*yield*/, apiServer.setAPI(api)];
+                        case 1:
+                            _a.sent();
+                            return [4 /*yield*/, apiServer.listen()];
+                        case 2:
+                            _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            }); });
+            agentCmd.option("--base_api_url <value>", "The key that must be given in order to execute the commands.", function (value, previous) {
+                baseAPIUrl = value;
+            });
+            agentCmd.option("--key <key>", "The key that must be given in order to execute the commands.", function (value, previous) {
+                agentKey = value;
+            });
+            agentCmd.option("--secret <secret>", "The secret key that must be given in order to execute the commands.", function (value, previous) {
+                agentSecret = value;
+            });
+            agentCmd.option("--file <key_filepath>", "The key and the associated NodeJS file to execute (key=path).", function (value, previous) {
+                var key = "";
+                var filepath = "";
+                var pos = key.indexOf("=");
+                if (pos < 0)
+                    throw new Error("key_filepath must be in the format (key=path)");
+                key = value.substr(0, pos);
+                filepath = value.substr(pos + 1);
+                commands[key] = filepath;
+            });
+            agentCmd.option("--listen-addr <addr>", "The address to listen on.", function (value, previous) {
+                listenAddr = value;
+            });
+            agentCmd.option("--listen-port <port>", "The port to listen on.", function (value, previous) {
+                try {
+                    port = parseInt(value);
+                }
+                catch (ex) {
+                    throw new Error("Unable to parse port ".concat(value));
+                }
+            });
+            return [2 /*return*/, (agentCmd)];
+        });
+    });
+}
+/**
+ * Check if the path exists.
+ */
+function checkIfPathExists(path) {
+    if (fs.existsSync(path) === true)
+        return (true);
+    return (false);
+}
+/**
+ * Start the CLI app.
+ */
+function start() {
+    return __awaiter(this, void 0, void 0, function () {
+        var packagePath, packageJSON, program, command, hotsiteExists, foundHotsitePath, createCmd, runCmd, buildCmd, agentCmd, ex_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 5, , 6]);
+                    packagePath = ppath.normalize("".concat(__dirname, "/../../package.json"));
+                    if (checkIfPathExists(packagePath) === false) {
+                        packagePath = ppath.normalize("".concat(process.cwd(), "/package.json"));
+                        if (checkIfPathExists(packagePath) === false) {
+                            console.error("Unable to find path to HotStaq!");
+                            return [2 /*return*/];
+                        }
+                    }
+                    packageJSON = JSON.parse(fs.readFileSync(packagePath).toString());
+                    VERSION = packageJSON.version;
+                    program = new commander.Command("hotstaq");
+                    program.description("Copyright(c) 2021, FreeLight, Inc. Under the MIT License.");
+                    command = program.version(VERSION);
+                    hotsiteExists = false;
+                    foundHotsitePath = "";
+                    if (checkIfPathExists("./HotSite.json") === true) {
+                        hotsiteExists = true;
+                        foundHotsitePath = ppath.normalize("./HotSite.json");
+                    }
+                    if (checkIfPathExists("./hotsite.json") === true) {
+                        hotsiteExists = true;
+                        foundHotsitePath = ppath.normalize("./HotSite.json");
+                    }
+                    if (hotsiteExists === true)
+                        hotsitePath = foundHotsitePath;
+                    command.option("--cwd <path>", "Set the current working directory to use.", function (path, previous) {
+                        process.chdir(path);
+                    });
+                    command.option("-o, --hotsite <path>", "Specify the HotSite.json to use. This will look in the current directory to find one first.", function (path, previous) {
+                        hotsitePath = path;
+                    }, foundHotsitePath);
+                    command.option("--not-hot", "Do not use a HotSite.json.", function (path, previous) {
+                        hotsitePath = "";
+                    });
+                    command.option("--verbose", "Set the logging level to verbose.", function (logLevel, previous) {
+                        if (logLevel === "verbose")
+                            globalLogLevel = HotLog_1.HotLogLevel.Verbose;
+                    });
+                    command.option("-l, --log-level <level>", "Set the logging level. Can be (info,warning,error,all,none)", function (logLevel, previous) {
+                        if (logLevel === "info")
+                            globalLogLevel = HotLog_1.HotLogLevel.Info;
+                        if (logLevel === "warning")
+                            globalLogLevel = HotLog_1.HotLogLevel.Warning;
+                        if (logLevel === "error")
+                            globalLogLevel = HotLog_1.HotLogLevel.Error;
+                        if (logLevel === "verbose")
+                            globalLogLevel = HotLog_1.HotLogLevel.Verbose;
+                        if (logLevel === "all")
+                            globalLogLevel = HotLog_1.HotLogLevel.All;
+                        if (logLevel === "none")
+                            globalLogLevel = HotLog_1.HotLogLevel.None;
+                    }, "");
+                    command.option("--dev, --development-mode", "Set to execute in development mode. This will allow for testing data to be collected and executed", function (value, previous) {
+                        processor.mode = Hot_1.DeveloperMode.Development;
+                    });
+                    return [4 /*yield*/, handleCreateCommands()];
+                case 1:
+                    createCmd = _a.sent();
+                    command.addCommand(createCmd);
+                    return [4 /*yield*/, handleRunCommands()];
+                case 2:
+                    runCmd = _a.sent();
+                    command.addCommand(runCmd);
+                    return [4 /*yield*/, handleBuildCommands()];
+                case 3:
+                    buildCmd = _a.sent();
+                    command.addCommand(buildCmd);
+                    return [4 /*yield*/, handleAgentCommands()];
+                case 4:
+                    agentCmd = _a.sent();
+                    command.addCommand(agentCmd);
+                    if (process.argv.length > 2)
+                        program.parse(process.argv);
+                    return [3 /*break*/, 6];
+                case 5:
+                    ex_1 = _a.sent();
+                    processor.logger.error(ex_1.stack);
+                    return [3 /*break*/, 6];
+                case 6: return [2 /*return*/];
+            }
+        });
+    });
+}
+start();
+//# sourceMappingURL=cli.js.map