spec-3nweb-server 1.8.5 → 1.8.7

package/ts-code/mailerId/resources/certifier.ts

@@ -0,0 +1,181 @@
+/*
+ Copyright (C) 2015 - 2016 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import { signing } from 'ecma-nacl';
+import { relyingParty as midRP, idProvider as midIdP, KEY_USE } from '../../lib-common/mid-sigs-NaCl-Ed';
+import { getKeyCert, JsonKey, SignedLoad, keyFromJson } from '../../lib-common/jwkeys';
+import * as random from '../../lib-common/random-node';
+import { readFileSync, writeFileSync } from 'fs';
+import { FileException, Code as excCode } from '../../lib-common/exceptions/file';
+
+export const ROOT_CERT_VALIDITY = 365*24*60*60;
+export const PROVIDER_CERT_VALIDITY = 10*24*60*60;
+export const MAX_USER_CERT_VALIDITY = 24*60*60;
+
+export interface RootCerts {
+	current: SignedLoad;
+	previous: SignedLoad[];
+}
+
+interface LogFn {
+	(msg: string): void;
+}
+
+function loadOrGenerateRootCert(
+	domain: string, path: string
+): { certs: RootCerts; skey: JsonKey; } {
+	let certsAndKey: { certs: RootCerts; skey: JsonKey; };
+	try {
+		certsAndKey = JSON.parse(
+			readFileSync(path, { encoding: 'utf8', flag: 'r' }));
+	} catch (err) {
+		if ((<FileException> err).code === excCode.notFound) {
+			return createFirstCert(domain, path);
+		} else {
+			throw err;
+		}
+	}
+	const certDomain = getKeyCert(certsAndKey.certs.current).issuer;
+	if (certDomain !== domain) {
+		throw new Error('Give domain '+domain+
+			' does not equal domain in certificates file: '+certDomain);
+	}
+	try {
+		const pkeyBytes = signing.extract_pkey(keyFromJson(
+			certsAndKey.skey, KEY_USE.ROOT, signing.JWK_ALG_NAME,
+			signing.SECRET_KEY_LENGTH).k);
+		const rootPKey = {
+			k: pkeyBytes,
+			kid: certsAndKey.skey.kid,
+			alg: certsAndKey.skey.alg,
+			use: certsAndKey.skey.use
+		};
+		midRP.verifyKeyCert(certsAndKey.certs.current, domain,
+			rootPKey, Math.floor(Date.now()/1000)+PROVIDER_CERT_VALIDITY);
+		return certsAndKey;
+	} catch (err) {
+		return updateCert(domain, path, certsAndKey.certs);
+	}
+}
+
+function createFirstCert(
+	domain: string, path: string, log?: LogFn
+): { certs: RootCerts; skey: JsonKey; } {
+	if (log) { log("\nMailerId service: Creating and saving new root certificate."); } 
+	const root = midIdP.generateRootKey(
+		domain, ROOT_CERT_VALIDITY, random.bytesSync);
+	const toSave = {
+		skey: root.skey,
+		certs: {
+			current: root.cert,
+			previous: []
+		}
+	};
+	writeFileSync(path, JSON.stringify(toSave),
+		{ encoding: 'utf8', flag: 'wx' });
+	return toSave;
+}
+
+function updateCert(
+	domain: string, path: string, certs: RootCerts, log?: LogFn
+): { certs: RootCerts; skey: JsonKey; } {
+	if (log) { log("\nMailerId service: Updating root certificate."); }
+	const root = midIdP.generateRootKey(
+		domain, ROOT_CERT_VALIDITY, random.bytesSync);
+	const toSave = {
+		skey: root.skey,
+		certs: {
+			current: root.cert,
+			previous: [ certs.current ].concat(certs.previous)
+		}
+	};
+	writeFileSync(path, JSON.stringify(toSave),
+		{ encoding: 'utf8', flag: 'w' });
+	return toSave;
+}
+
+export type ICertify = (
+	userPKey: JsonKey, address: string, validFor?: number
+) => { userCert: SignedLoad; provCert: SignedLoad; };
+export interface Certifier {
+	certify: ICertify;
+	getRootCert(): SignedLoad;
+	getPrevCerts(): SignedLoad[];
+}
+
+const UPDATE_PERIOD = 8*60*60;
+
+if (UPDATE_PERIOD >= PROVIDER_CERT_VALIDITY) {
+	throw new Error('Either provider certificate validity is to too short, '+
+		'or an update period is too long.');
+}
+
+export function makeSingleProcCertifier(
+	domain: string, certsPath: string
+): Certifier {
+	
+	let rootCerts: RootCerts;
+	let certifier: midIdP.IdProviderCertifier;
+	let provCert: SignedLoad;
+	let updateTime: number;
+	
+	function updateCertifier(): void {
+		if (certifier) {
+			if (updateTime > Date.now()) { return; }
+			certifier.destroy();
+		}
+		
+		let certsAndKey = loadOrGenerateRootCert(domain, certsPath);
+		rootCerts = certsAndKey.certs;
+		
+		const provider = midIdP.generateProviderKey(
+				domain, PROVIDER_CERT_VALIDITY, certsAndKey.skey, random.bytesSync);
+		certsAndKey = (undefined as any);
+		
+		provCert = provider.cert;
+		Object.freeze(provCert);
+	
+		certifier = midIdP.makeIdProviderCertifier(
+				domain, MAX_USER_CERT_VALIDITY, provider.skey);
+		
+		updateTime = (getKeyCert(provCert).expiresAt - 2*UPDATE_PERIOD)*1000;
+	}
+	
+	updateCertifier();
+	const timer: NodeJS.Timer = <any> setInterval(
+		updateCertifier, UPDATE_PERIOD*1000);
+	timer.unref();
+	
+	const fact: Certifier = {
+		certify: (userPKey, address, validFor) => {
+			return {
+				userCert: certifier.certify(userPKey, address, validFor),
+				provCert: provCert
+			};
+		},
+		getRootCert: () => {
+			return rootCerts.current;
+		},
+		getPrevCerts: () => {
+			return rootCerts.previous;
+		}
+	};
+	Object.freeze(fact);
+	return fact;
+}
+
+Object.freeze(exports);

package/ts-code/mailerId/resources/sessions.ts

@@ -0,0 +1,44 @@
+/*
+ Copyright (C) 2017 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import { InMemorySessions } from '../../lib-server/resources/mem-backed-sessions-factory';
+import { Factory } from '../../lib-server/resources/sessions';
+import { SessionParams } from '../../lib-server/routes/pub-key-login/start-exchange';
+export { Request } from '../../lib-server/routes/pub-key-login/start-exchange';
+
+
+export type SessionsFactory = Factory<SessionParams>;
+
+function makeSessionParams(): SessionParams {
+	return {
+		userId: (undefined as any),
+		encryptor: (undefined as any),
+		serverVerificationBytes: (undefined as any),
+		sessionKey: (undefined as any)
+	 };
+}
+
+/**
+ * This returns factory, that works properly in a single process application,
+ * clearing up sessions that past given timeout.
+ * @param timeout is a session timeout in seconds
+ */
+export function makeSessionFactory(timeout: number): SessionsFactory {
+	return InMemorySessions.factory<SessionParams>(timeout, makeSessionParams);
+}
+
+Object.freeze(exports);

package/ts-code/mailerId/resources/users.ts

@@ -0,0 +1,88 @@
+/*
+ Copyright (C) 2015 - 2016, 2020 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/**
+ * This module is constructs users factories for MailerId app.
+ */
+
+import { readFile, FileException } from '../../lib-common/async-fs-node';
+import { box } from 'ecma-nacl';
+import { JsonKey, keyFromJson } from '../../lib-common/jwkeys';
+import { GetUserPKeyAndKeyGenParams, UserPKeyAndKeyGenParams } from '../../lib-server/routes/pub-key-login/start-exchange';
+import { UserMidParams } from '../../lib-common/admin-api/signup';
+import { join } from 'path';
+import { userDataInRootFolder } from '../../lib-server/resources/server-data-folders';
+
+export interface Factory {
+	getUserParamsAndKey: GetUserPKeyAndKeyGenParams;
+}
+
+async function getUser(
+	rootFolder: string, userId: string
+): Promise<UserMidParams|undefined> {
+	try {
+		const userFolder = userDataInRootFolder(rootFolder, userId);
+		const midParamsPath = join(userFolder, 'info', 'mid-params');
+		const str = await readFile(midParamsPath, { encoding: 'utf8' });
+		return JSON.parse(str) as UserMidParams;
+	} catch (exc) {
+		if ((exc as FileException).notFound) {
+			return;
+		}
+		throw exc;
+	}
+}
+
+const MID_KEY_USE = 'login-pub-key';
+
+function extractPKeyBytes(pkey: JsonKey): Uint8Array {
+	return keyFromJson(pkey, MID_KEY_USE,
+		box.JWK_ALG_NAME, box.KEY_LENGTH).k;
+}
+
+export function makeFactory(rootFolder: string): Factory {
+	
+	const factory: Factory = {
+
+		getUserParamsAndKey: async (userId, kid) => {
+			const userInfo = await getUser(rootFolder, userId);
+			if (!userInfo) { return; }
+			let params: UserPKeyAndKeyGenParams;
+			if (typeof kid === 'string') {
+				const pkey = userInfo.otherPKeys.find((pkey) => {
+					return (pkey.kid === kid);
+				});
+				if (!pkey) { return; }
+				params = {
+					pkey: extractPKeyBytes(pkey),
+				};
+			} else {
+				params = {
+					pkey: extractPKeyBytes(userInfo.defaultPKey.pkey),
+					params: userInfo.defaultPKey.kdParams
+				};
+			}
+			return params;
+		}
+
+	};
+	Object.freeze(factory);
+	
+	return factory;
+}
+
+Object.freeze(exports);

package/ts-code/mailerId/routes/certify.ts

@@ -0,0 +1,68 @@
+/*
+ Copyright (C) 2015 - 2016 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import { RequestHandler, Response, NextFunction } from 'express';
+import { utf8, toBuffer } from '../../lib-common/buffer-utils';
+import { ICertify } from '../resources/certifier';
+import { Request } from '../resources/sessions';
+import { certify as api } from '../../lib-common/service-api/mailer-id/provisioning';
+
+export function certify(certifyingFunc: ICertify): RequestHandler {
+	if ('function' !== typeof certifyingFunc) { throw new TypeError(
+			"Given argument 'certifyingFunc' must be function, but is not."); }
+	
+	return function (req: Request, res: Response, next: NextFunction) {
+		const session = req.session;
+		const c = new Uint8Array(req.body);
+		const encryptor = session.params.encryptor;
+		const email = session.params.userId;
+		let bodyBytes: Uint8Array;
+		
+		// decrypt request body
+		try {
+			bodyBytes = encryptor.open(c);
+		} catch (err) {
+			session.close();
+			res.status(api.SC.cryptoVerifFail).send(
+				'Bytes fail cryptographic verification.');
+			return;
+		}
+		
+		let signedCerts: api.Reply;
+		
+		// extract parameters and certify
+		try {
+			const reqParams: api.Request =
+				JSON.parse(utf8.open(bodyBytes));
+			if (!reqParams.pkey) { throw new Error("Missing field"); }
+			signedCerts = certifyingFunc(
+				reqParams.pkey, email, reqParams.duration);
+		} catch (err) {
+			session.close();
+			res.status(api.SC.malformed).send(
+				'Missing or incorrectly formatted payload.');
+			return;
+		}
+		
+		res.status(api.SC.ok).send(
+			toBuffer(encryptor.pack(utf8.pack(JSON.stringify(signedCerts)))));
+		session.close();
+		
+	};
+}
+
+Object.freeze(exports);

package/ts-code/main.ts

@@ -0,0 +1,304 @@
+#!/usr/bin/env node
+
+/*
+ Copyright (C) 2015 - 2016, 2019, 2025 3NSoft Inc.
+ 
+ This program is free software: you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free Software
+ Foundation, either version 3 of the License, or (at your option) any later
+ version.
+ 
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License along with
+ this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/*
+ * This script starts server, according to settings, given in config file.
+ */
+
+import { ServerOptions } from 'https';
+import { CliUsageDisplay, parseProcessArgv } from './cli';
+import { readYamlConfFile } from './config/from-yaml';
+import { sslOptsFromConfig } from './config/letsencrypt';
+import { Configurations, servicesApp, accountsApp, AppWithWSs } from './lib';
+import { addMultiDomainSignup, addSingleUserSignup, readAllSignupTokens, readNoTokensFile, readTokenFile } from './config/signup';
+import { DEFAULT_CONFIG_PATH } from './config/default-confs';
+import { Code } from './lib-common/exceptions/file';
+
+async function run(conf: Configurations): Promise<void> {
+
+	if (!conf.servicesConnect) {
+		console.error(`❌ No connection settings found in configuration.`);
+		process.exit(-1);
+		return;
+	}
+
+	let app: AppWithWSs|undefined = undefined;
+
+	function createApp(conf: Configurations): AppWithWSs {
+		const app = new AppWithWSs();
+		app.use(servicesApp(conf, 'console', 'console'));
+		app.use(accountsApp(conf, 'console', 'console'));
+		return app;
+	}
+
+	async function stopProcess() {
+		if (!app) { return; }
+		try {
+			console.log(`🏁 Stopping app ...`);
+			await app.stop();
+			console.log(`app has stopped.`);
+		} catch (err) {
+			console.log(`app encounter an error, when stopping`);
+			console.error(err);
+		} finally {
+			app = undefined;
+		}
+	}
+
+	async function startAppWithTLS(
+		sslOpts: ServerOptions, port: number, hostname: string|undefined
+	): Promise<void> {
+		await app!.start(sslOpts, port, hostname);
+		console.log(`🚀 Started 3NWeb server on port ${port},${hostname ? ` hostname ${hostname},` : ''} with TLS.`);
+	}
+
+	async function startAppWithoutTLS(
+		port: number, hostname: string|undefined
+	): Promise<void> {
+		await app!.start(undefined, port, hostname);
+		console.log(`🚀 Started 3NWeb server on port ${port},${hostname ? ` hostname ${hostname},` : ''} without TLS, and requiring TLS reverse proxy infront.`);	
+	}
+
+	try {
+
+		app = createApp(conf);
+
+		const {
+			hostname, port, letsencrypt, sslOpts, skipReloadOnCertsChange
+		} = conf.servicesConnect;
+		const tls = sslOptsFromConfig(
+			letsencrypt, sslOpts, skipReloadOnCertsChange
+		);
+		if (tls) {
+			await startAppWithTLS(tls.sslOpts, port, hostname);
+			if (!skipReloadOnCertsChange) {
+				tls.onCertsUpdate!(async (newOpts, originalOpts) => {
+					console.log(`🗘  Reloading server app server on TLS certificates change`);
+					try {
+						await stopProcess();
+						app = createApp(conf);
+						await startAppWithTLS(newOpts, port, hostname);
+					} catch (err) {
+						console.error(err);
+						console.log(`⚠️  Failed to reload with new TLS certs. Attempting to load with original ones.`);
+						try {
+							await stopProcess();
+							app = createApp(conf);
+							await startAppWithTLS(originalOpts, port, hostname);
+						} catch (err) {
+							await stopProcess();
+							console.error(err);
+							process.exit(-500);					
+						}
+					}
+				});
+			}
+		} else {
+			await startAppWithoutTLS(port, hostname);
+		}
+
+		process.on('SIGINT', stopProcess);
+		process.on('SIGTERM', stopProcess);
+
+	} catch (err) {
+		await stopProcess();
+		console.error(err);
+		process.exit(-500);
+	}
+}
+
+function showUsage({ txtToDisplay, exitStatus }: CliUsageDisplay): void {
+	if (exitStatus === 0) {
+		console.log(txtToDisplay);
+	} else {
+		console.error(txtToDisplay);
+	}
+	process.exit(exitStatus);
+}
+
+function assembleConfig(configPath: string|undefined): Configurations {
+	if (!configPath) {
+		configPath = DEFAULT_CONFIG_PATH;
+		console.log(`Looking for configuration in default location: ${configPath}`);
+	}
+	try {
+		return readYamlConfFile(configPath);
+	} catch (err) {
+		if (err.code === Code.notFound) {
+			console.error(`❌ Configuration file ${configPath} is not found.`);
+			process.exit(-2);
+		}
+		throw err;
+	}
+}
+
+async function displaySignupInfo(conf: Configurations): Promise<void> {
+	if (!conf.signup) {
+		console.log(`\nSignup is disabled.\n`);
+	} else {
+		console.log(`\nSignup is enabled.\n`);
+		if (conf.signup.noTokenFile) {
+			const ctx = await readNoTokensFile(conf.signup.noTokenFile);
+			console.log(`Signup of user without token is allowed in domains:\n`, ctx.domains, `\n`);
+			const signupLink = signupLinkFrom(conf, undefined);
+			if (signupLink) {
+				console.log(`Signup link:\n`, signupLink, `\n`);
+			}
+		} else {
+			console.log(`Signup of users is allowed only with valid signup tokens.\n`);
+		}
+		if (conf.signup.serviceUrl) {
+			console.log(`Signup service url (from configuration file):\n`, conf.signup.serviceUrl, `\n`);
+		}
+	}
+	const {
+		multiUserTokens, singleUserTokens
+	} = await readAllSignupTokens(conf.rootFolder);
+	console.log(`There are ${multiUserTokens.length} multi-user tokens.\n`);
+	console.log(`There are ${singleUserTokens.length} single-user tokens.\n`);
+}
+
+async function displayTokensList(conf: Configurations): Promise<void> {
+	const {
+		multiUserTokens, singleUserTokens
+	} = await readAllSignupTokens(conf.rootFolder);
+	if (multiUserTokens.length > 0) {
+		console.log(`\nMulti-user signup tokens:`);
+		for (const { tokenId, ctx: { domains } } of multiUserTokens) {
+			console.log(`  id: ${tokenId}  -> domains:`, domains);
+		}
+		console.log(``);
+	} else {
+		console.log(`\nThere are no multi-user signup tokens.\n`);
+	}
+	if (singleUserTokens.length > 0) {
+		console.log(`Single-user signup tokens:`);
+		for (const { tokenId, ctx: { userId } } of singleUserTokens) {
+			console.log(`  id: ${tokenId}  -> user: ${userId}`);
+		}
+		console.log(``);
+	} else {
+		console.log(`There are no single-user signup tokens.\n`);
+	}
+}
+
+async function displayTokenValue(
+	conf: Configurations, tokenId: string
+): Promise<void> {
+	const ctx = await readTokenFile(conf.rootFolder, tokenId);
+	if (ctx) {
+		const signupLink = signupLinkFrom(conf, ctx.token);
+		if (signupLink) {
+			console.log(`\nSignup link:\n  ${signupLink}`);
+		}
+		if (ctx.type === 'multi-domain') {
+			console.log(`\nMulti-user signup context:`);
+			console.log(`  domains:`, ctx.domains);
+			console.log(`  value:`, ctx.token);
+			if (ctx.validTill) {
+				console.log(`  valid till: ${(new Date(ctx.validTill)).toString()}`);
+			}
+		} else if (ctx.type === 'single-user') {
+			console.log(`\nSingle-user signup context:`);
+			console.log(`  address: `, ctx.userId);
+			console.log(`  value: `, ctx.token);
+			if (ctx.validTill) {
+				console.log(`  valid till: ${(new Date(ctx.validTill)).toString()}`);
+			}
+		}
+		console.log(``);
+	} else {
+		console.error(`Token ${tokenId} is not found.`);
+		process.exit(-1);
+	}
+}
+
+const signupLinkStart = `w3n://signup/`;
+
+function signupLinkFrom(conf: Configurations, token = ''): string|undefined {
+	if (!conf.signup?.serviceUrl) {
+		return;
+	}
+	try {
+		const url = new URL(conf.signup.serviceUrl);
+		return `${signupLinkStart}${url.host}${url.pathname}${url.pathname.endsWith('/') ? '' : '/'}${token}`;
+	} catch (err) {
+		return;
+	}
+}
+
+async function createMultiUserToken(
+	conf: Configurations, domains: string[]
+): Promise<void> {
+	const token = await addMultiDomainSignup(conf.rootFolder, domains);
+	console.log (`\nFor creating users on domain${(domains.length > 0) ? 's' : ''} ${domains.join(', ')}:\n  token value:  ${token}`);
+	const signupLink = signupLinkFrom(conf, token);
+	if (signupLink) {
+		console.log(`Signup link:\n  ${signupLink}\n`);
+	}
+	console.log(``);
+}
+
+async function createSingleUserToken(
+	conf: Configurations, userId: string
+): Promise<void> {
+	const token = await addSingleUserSignup(conf.rootFolder, userId);
+	console.log (`\nFor creating user ${userId}:\n  token value:  ${token}`);
+	const signupLink = signupLinkFrom(conf, token);
+	if (signupLink) {
+		console.log(`Signup link:\n  ${signupLink}\n`);
+	}
+	console.log(``);
+}
+
+const cmd = parseProcessArgv();
+
+if (cmd.runCmd) {
+	const conf = assembleConfig(cmd.runCmd.config!);
+	run(conf);
+} else if (cmd.signupCmd) {
+	const conf = assembleConfig(cmd.signupCmd.config!);
+	if (cmd.signupCmd.info) {
+		displaySignupInfo(conf);
+	} else if (cmd.signupCmd.listTokens) {
+		displayTokensList(conf);
+	} else if (cmd.signupCmd.showToken) {
+		displayTokenValue(conf, cmd.signupCmd.token!);
+	} else if (cmd.signupCmd.createToken) {
+		if (cmd.signupCmd.user) {
+			createSingleUserToken(conf, cmd.signupCmd.user!);
+		} else {
+			createMultiUserToken(conf, cmd.signupCmd.domain!);
+		}
+	} else {
+		showUsage({
+			txtToDisplay: `❌ No recognized subcommand given to signup module`,
+			exitStatus: -1
+		});
+	}
+} else if (cmd.showSampleConfig) {
+	showUsage(cmd.showSampleConfig);
+} else if (cmd.showUsage) {
+	showUsage(cmd.showUsage);
+} else {
+	showUsage({
+		txtToDisplay: `❌ No recognized command given`,
+		exitStatus: -1
+	});
+}