spec-3nweb-server 1.6.4 → 1.7.1

package/build/lib-common/ipc/generic-ipc.js

@@ -586,14 +586,14 @@ function makeSubscribingClient(channel, comm) {
 }
 exports.makeSubscribingClient = makeSubscribingClient;
 class MultiObserverWrap {
+    get done() {
+        return this.isDone;
+    }
     constructor() {
         this.isDone = false;
         this.obs = new Set();
         Object.seal(this);
     }
-    get done() {
-        return this.isDone;
-    }
     add(obs) {
         if (this.isDone) {
             throw new Error(`Cannot add observer, as this source is already done`);
@@ -645,15 +645,15 @@ exports.MultiObserverWrap = MultiObserverWrap;
 Object.freeze(MultiObserverWrap.prototype);
 Object.freeze(MultiObserverWrap);
 class SingleObserverWrap {
+    get done() {
+        return this.isDone;
+    }
     constructor() {
         this.isDone = false;
         this.obs = undefined;
         this.detach = () => this.setDone();
         Object.seal(this);
     }
-    get done() {
-        return this.isDone;
-    }
     set(obs) {
         if (this.isDone) {
             throw new Error(`Cannot add observer, as this source is already done`);

package/build/lib-common/objs-on-disk/file-layout.d.ts

@@ -4,10 +4,10 @@ export interface HeaderChunkInfo {
     len: number;
     fileOfs: number;
 }
-export declare type NotOnDiskFiniteChunk = NewSegsChunk | BaseSegsChunk;
-export declare type OnDiskChunk = NewSegsChunkOnDisk | BaseSegsChunkOnDisk;
-export declare type FiniteSegsChunk = OnDiskChunk | NotOnDiskFiniteChunk;
-export declare type SegsChunk = OnDiskChunk | NotOnDiskFiniteChunk | NewEndlessSegsChunk;
+export type NotOnDiskFiniteChunk = NewSegsChunk | BaseSegsChunk;
+export type OnDiskChunk = NewSegsChunkOnDisk | BaseSegsChunkOnDisk;
+export type FiniteSegsChunk = OnDiskChunk | NotOnDiskFiniteChunk;
+export type SegsChunk = OnDiskChunk | NotOnDiskFiniteChunk | NewEndlessSegsChunk;
 export interface FiniteChunk {
     thisVerOfs: number;
     len: number;

package/build/lib-common/objs-on-disk/utils.d.ts

@@ -14,10 +14,10 @@ export interface ChunkWithSegs {
     len: number;
     segsOfs: number;
 }
-export declare type Chunk = ChunkWithHeader | ChunkWithSegs;
+export type Chunk = ChunkWithHeader | ChunkWithSegs;
 export declare function streamToObjFile(file: ObjVersionFile, content: Chunk[], src: Readable, maxBufferLen: number): Promise<void>;
 export declare function chunksInOrderedStream(len: number, headerLen: undefined | number, segsOfs: number): Chunk[];
-export declare type ObjPipe = (outStream: NodeJS.WritableStream) => Promise<void>;
-export declare type GetObjFile = (objId: string | null, version: number) => Promise<ObjVersionFile>;
+export type ObjPipe = (outStream: NodeJS.WritableStream) => Promise<void>;
+export type GetObjFile = (objId: string | null, version: number) => Promise<ObjVersionFile>;
 export declare function makeObjPipe(file: ObjVersionFile, header: boolean, segsOfs: number, segsLen: number, objId: string | null, getObjFile: GetObjFile): ObjPipe;
 export declare function makeNoBaseObjPipe(file: ObjVersionFile, header: boolean, segsOfs: number, segsLen: number): ObjPipe;

package/build/lib-common/processes.d.ts

@@ -29,7 +29,7 @@ export declare function finalizeAsync<T>(promise: Promise<T>, fin: () => Promise
  * later time. Scheduler needs a not-yet-started activity, as scheduler has
  * control action's start.
  */
-export declare type Action<T> = () => Promise<T>;
+export type Action<T> = () => Promise<T>;
 /**
  * This is a container of processes, labeled by some ids. It allows to track if
  * there is a process already in progress with a given id. And, it allows to

package/build/lib-common/service-api/ipc-api.d.ts

@@ -1,9 +1,9 @@
-export declare type Envelope = web3n.ipc.Envelope;
-export declare type EventEnvelope<T> = web3n.ipc.EventEnvelope<T>;
-export declare type EventEndEnvelope = web3n.ipc.EventEndEnvelope;
-export declare type EventException = web3n.ipc.EventException;
-export declare type RequestEnvelope<T> = web3n.ipc.RequestEnvelope<T>;
-export declare type ReplyEnvelope<T> = web3n.ipc.ReplyEnvelope<T>;
+export type Envelope = web3n.ipc.Envelope;
+export type EventEnvelope<T> = web3n.ipc.EventEnvelope<T>;
+export type EventEndEnvelope = web3n.ipc.EventEndEnvelope;
+export type EventException = web3n.ipc.EventException;
+export type RequestEnvelope<T> = web3n.ipc.RequestEnvelope<T>;
+export type ReplyEnvelope<T> = web3n.ipc.ReplyEnvelope<T>;
 export declare namespace events {
     namespace subscribe {
         const REQ_NAME = "subscribe";

package/build/lib-common/service-api/web-socket-base.d.ts

@@ -16,7 +16,7 @@ export interface EventEnvelope<T> {
     eventChannel: string;
     eventPayload: T;
 }
-export declare type Envelope = RequestEnvelope<any> | ReplyEnvelope<any> | EventEnvelope<any>;
+export type Envelope = RequestEnvelope<any> | ReplyEnvelope<any> | EventEnvelope<any>;
 export declare namespace events {
     const MISSED_EVENTS_CHANNEL = "missed-events";
     const SUBSCRIBE_REQ_NAME = "subscribe";

package/build/lib-server/middleware/error-handler.d.ts

@@ -11,6 +11,6 @@ export interface HttpError extends ErrorWithCause {
  * @param cause
  */
 export declare function makeErr(code: number, msg: string, cause?: any): HttpError;
-export declare type ErrLogger = (err: any, req: Request) => void;
+export type ErrLogger = (err: any, req: Request) => void;
 export declare function makeErrHandler(log?: ErrLogger): ErrorRequestHandler;
 export declare function makeErrLoggerToConsole(srvName: string): ErrLogger;

package/build/lib-server/resources/dns.d.ts

@@ -2,5 +2,5 @@ export declare const SC: {
     RECORDS_MISSING: string;
     DOMAIN_NOT_FOUND: string;
 };
-export declare type ServiceLabel = 'asmail' | 'mailerid' | '3nstorage';
+export type ServiceLabel = 'asmail' | 'mailerid' | '3nstorage';
 export declare function get3NWebRecords(address: string, serviceLabel: ServiceLabel): Promise<string>;

package/build/lib-server/resources/dns.js

@@ -1,6 +1,6 @@
 "use strict";
 /*
- Copyright (C) 2015 - 2016 3NSoft Inc.
+ Copyright (C) 2015 - 2016, 2023 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
@@ -39,19 +39,57 @@ Object.freeze(DNS_ERR_CODE);
  */
 function extractPair(txtRecords, serviceLabel) {
     for (const txtRecord of txtRecords) {
-        const txt = txtRecord.join(' ');
-        const eqPos = txt.indexOf('=');
-        if (eqPos < 0) {
-            continue;
-        }
-        const name = txt.substring(0, eqPos).trim();
-        if (name === serviceLabel) {
-            const value = txt.substring(eqPos + 1).trim();
-            return value;
+        let joinedTXTstanzas = txtRecord.join('');
+        let record = getRecordAtStartOf(joinedTXTstanzas);
+        while (record) {
+            if (record.service === serviceLabel) {
+                const value = record.value.trim();
+                if (value.length > 0) {
+                    return value;
+                }
+            }
+            if (record.txtTail) {
+                record = getRecordAtStartOf(record.txtTail);
+            }
+            else {
+                break;
+            }
         }
     }
     return;
 }
+const recordsStarts = {
+    "3nstorage": '3nstorage=',
+    asmail: 'asmail=',
+    mailerid: 'mailerid='
+};
+function getRecordAtStartOf(txt) {
+    let service = undefined;
+    for (const [label, startSeq] of Object.entries(recordsStarts)) {
+        if (txt.startsWith(startSeq)) {
+            service = label;
+            txt = txt.substring(startSeq.length);
+            break;
+        }
+    }
+    if (!service) {
+        return;
+    }
+    for (const delimiter of Object.values(recordsStarts)) {
+        const endPos = txt.indexOf(delimiter);
+        if (endPos >= 0) {
+            return {
+                service,
+                value: txt.substring(0, endPos),
+                txtTail: txt.substring(endPos)
+            };
+        }
+    }
+    return {
+        service,
+        value: txt
+    };
+}
 function resolveTxt(domain) {
     return new Promise((resolve, reject) => {
         // As of March 2017, docs for node say that texts given in a callback

package/build/lib-server/resources/sessions.d.ts

@@ -22,8 +22,8 @@ export interface Request<T> extends express.Request {
 export interface BaseRequest<T> extends http.IncomingMessage {
     session: Session<T>;
 }
-export declare type CheckSession<T> = (req: BaseRequest<T>) => Promise<boolean>;
-export declare type GenerateSession<T> = () => Promise<Session<T>>;
+export type CheckSession<T> = (req: BaseRequest<T>) => Promise<boolean>;
+export type GenerateSession<T> = () => Promise<Session<T>>;
 export interface Factory<T> {
     generate: GenerateSession<T>;
     ensureAuthorizedSession(): express.RequestHandler;

package/build/lib-server/resources/user-files.d.ts

@@ -15,7 +15,7 @@ export declare abstract class UserFiles {
     getParam<T>(paramFileName: string): Promise<T>;
     setParam<T>(paramFileName: string, param: T): Promise<void>;
 }
-export declare type ObjPipe = (outStream: NodeJS.WritableStream) => Promise<void>;
+export type ObjPipe = (outStream: NodeJS.WritableStream) => Promise<void>;
 export interface ObjReader {
     len: number;
     /**

package/build/lib-server/routes/pub-key-login/start-exchange.d.ts

@@ -10,7 +10,7 @@ export interface SessionParams extends UserParams {
     sessionKey: Uint8Array;
     serverVerificationBytes: Uint8Array;
 }
-export declare type Request = SessReq<SessionParams>;
+export type Request = SessReq<SessionParams>;
 export interface UserPKeyAndKeyGenParams {
     pkey: Uint8Array;
     params?: any;
@@ -22,7 +22,7 @@ export interface UserPKeyAndKeyGenParams {
  * Else, if incoming id is not ok, undefined is returned.
  * @params initUserId is a an incoming string, that should be an id
  */
-export declare type CheckAndTransformUserId = (initUserId: string) => string | undefined;
+export type CheckAndTransformUserId = (initUserId: string) => string | undefined;
 /**
  * This returns a promise of user public key and related parameters.
  * If user is not found, undefined is returned.
@@ -30,8 +30,8 @@ export declare type CheckAndTransformUserId = (initUserId: string) => string | u
  * @param kid is a key id that should be used at login. Undefined value
  * indicates that default key should be used.
  */
-export declare type GetUserPKeyAndKeyGenParams = (userId: string, kid: string | undefined) => Promise<UserPKeyAndKeyGenParams | undefined>;
-export declare type ComputeDHSharedKey = (userKey: Uint8Array) => {
+export type GetUserPKeyAndKeyGenParams = (userId: string, kid: string | undefined) => Promise<UserPKeyAndKeyGenParams | undefined>;
+export type ComputeDHSharedKey = (userKey: Uint8Array) => {
     dhsharedKey: Uint8Array;
     serverPubKey: Uint8Array;
 };

package/build/lib-server/routes/sessions/mid-auth.d.ts

@@ -6,7 +6,7 @@ import { SignedLoad } from '../../../lib-common/jwkeys';
  * Autherization failure may be due to either, invalid MailerId credentials, or
  * due to other service's restriction(s) on users.
  */
-export declare type MidAuthorizer = (rpDomain: string, sessionId: string, userId: string, mailerIdAssertion: SignedLoad, userCert: SignedLoad, provCert: SignedLoad) => Promise<boolean>;
+export type MidAuthorizer = (rpDomain: string, sessionId: string, userId: string, mailerIdAssertion: SignedLoad, userCert: SignedLoad, provCert: SignedLoad) => Promise<boolean>;
 /**
  * @param relyingPartyDomain is a domain of service, for which this assertion
  * check is done. Usually, it is this site's domain, which we set explicitly.

package/build/lib-server/routes/sessions/start.d.ts

@@ -1,6 +1,6 @@
 import { RequestHandler } from 'express';
 import { GenerateSession, Request as SessionReq, SessionParams } from '../../resources/sessions';
-export declare type Request = SessionReq<SessionParams>;
+export type Request = SessionReq<SessionParams>;
 /**
  * This function checks overall shape of a given user id, possibly
  * transforming it to some canonical form, used by the service.
@@ -8,9 +8,9 @@ export declare type Request = SessionReq<SessionParams>;
  * Else, if incoming id is not ok, undefined is returned.
  * @params initUserId is a an incoming string, that should be an id
  */
-export declare type CheckAndTransformUserId = (initUserId: string) => string | undefined;
-export declare type UserExists = (userId: string) => Promise<boolean>;
-export declare type Redirect = (userId: string) => Promise<string>;
+export type CheckAndTransformUserId = (initUserId: string) => string | undefined;
+export type UserExists = (userId: string) => Promise<boolean>;
+export type Redirect = (userId: string) => Promise<string>;
 /**
  * This returns route handler that creates sessions for a given userId, with
  * potential redirect for a named user.

package/build/lib-server/web-sockets/app.d.ts

@@ -5,7 +5,7 @@ import * as https from 'https';
 import * as express from 'express';
 import * as WebSocket from 'ws';
 import { CheckSession, SessionParams } from '../resources/sessions';
-export declare type HttpServer = http.Server | https.Server;
+export type HttpServer = http.Server | https.Server;
 export declare class UserSockets {
     checkSession: CheckSession<SessionParams>;
     /**

package/build/lib-server/web-sockets/app.js

@@ -209,6 +209,12 @@ class PingSender {
 Object.freeze(PingSender.prototype);
 Object.freeze(PingSender);
 class AppWithWSs {
+    get sockServer() {
+        if (!this.socks) {
+            this.socks = new UserSocketsServer();
+        }
+        return this.socks;
+    }
     constructor(httpApp) {
         this.server = undefined;
         this.closingProc = undefined;
@@ -216,12 +222,6 @@ class AppWithWSs {
         this.http = (httpApp ? httpApp : express());
         Object.seal(this);
     }
-    get sockServer() {
-        if (!this.socks) {
-            this.socks = new UserSocketsServer();
-        }
-        return this.socks;
-    }
     addWS(path, socks) {
         if (typeof path === 'string') {
             socks.path = ensureSlashesOnFront(path);

package/build/lib-server/web-sockets/server-events.d.ts

@@ -1,6 +1,6 @@
 import * as WebSocket from 'ws';
 import { SocketIPCs } from './app';
-export declare type EventsSink<T> = (userId: string, channel: string, event: T) => void;
+export type EventsSink<T> = (userId: string, channel: string, event: T) => void;
 export declare class ServerEvents<T> implements SocketIPCs {
     ipcChannel: string | undefined;
     private eventChannels;

package/build/lib.d.ts

@@ -1,5 +1,5 @@
 export { AppWithWSs } from './lib-server/web-sockets/app';
 export { Configurations, servicesApp, adminApp } from './services';
-export { addSingleUserSignup, getConfsFromEnv, getBindParamsFromEnv } from './run-config';
+export { addSingleUserSignup } from './config/signup';
 export import errors = require('./lib-server/middleware/error-handler');
 export * as mock from './mock/run-in-proc';

package/build/lib.js

@@ -16,16 +16,14 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mock = exports.getBindParamsFromEnv = exports.getConfsFromEnv = exports.addSingleUserSignup = exports.adminApp = exports.servicesApp = exports.AppWithWSs = void 0;
+exports.mock = exports.addSingleUserSignup = exports.adminApp = exports.servicesApp = exports.AppWithWSs = void 0;
 var app_1 = require("./lib-server/web-sockets/app");
 Object.defineProperty(exports, "AppWithWSs", { enumerable: true, get: function () { return app_1.AppWithWSs; } });
 var services_1 = require("./services");
 Object.defineProperty(exports, "servicesApp", { enumerable: true, get: function () { return services_1.servicesApp; } });
 Object.defineProperty(exports, "adminApp", { enumerable: true, get: function () { return services_1.adminApp; } });
-var run_config_1 = require("./run-config");
-Object.defineProperty(exports, "addSingleUserSignup", { enumerable: true, get: function () { return run_config_1.addSingleUserSignup; } });
-Object.defineProperty(exports, "getConfsFromEnv", { enumerable: true, get: function () { return run_config_1.getConfsFromEnv; } });
-Object.defineProperty(exports, "getBindParamsFromEnv", { enumerable: true, get: function () { return run_config_1.getBindParamsFromEnv; } });
+var signup_1 = require("./config/signup");
+Object.defineProperty(exports, "addSingleUserSignup", { enumerable: true, get: function () { return signup_1.addSingleUserSignup; } });
 exports.errors = require("./lib-server/middleware/error-handler");
 exports.mock = require("./mock/run-in-proc");
 Object.freeze(exports);

package/build/mailerId/resources/certifier.d.ts

@@ -6,7 +6,7 @@ export interface RootCerts {
     current: SignedLoad;
     previous: SignedLoad[];
 }
-export declare type ICertify = (userPKey: JsonKey, address: string, validFor?: number) => {
+export type ICertify = (userPKey: JsonKey, address: string, validFor?: number) => {
     userCert: SignedLoad;
     provCert: SignedLoad;
 };

package/build/mailerId/resources/sessions.d.ts

@@ -1,7 +1,7 @@
 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 declare type SessionsFactory = Factory<SessionParams>;
+export type SessionsFactory = Factory<SessionParams>;
 /**
  * This returns factory, that works properly in a single process application,
  * clearing up sessions that past given timeout.

package/build/main.js

@@ -16,67 +16,218 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-/*
- * This script starts server, according to settings, given in config file.
- */
+const cli_1 = require("./config/cli");
+const from_yaml_1 = require("./config/from-yaml");
+const letsencrypt_1 = require("./config/letsencrypt");
 const lib_1 = require("./lib");
-const fs_1 = require("fs");
-const async_fs_node_1 = require("./lib-common/async-fs-node");
-const child_process_1 = require("child_process");
-const processes_1 = require("./lib-common/processes");
-const PID_FILE = '/var/3nweb/service.pid';
-const confFile = process.argv[2];
-if (!confFile) {
-    console.error(`Configuration file is not given. It should be the first script argument.`);
-    process.exit(-1);
-}
-const conf = JSON.parse((0, fs_1.readFileSync)(confFile, 'utf8'));
-const noop = () => { };
-(async () => {
+const signup_1 = require("./config/signup");
+async function run(conf) {
     if (!conf.servicesConnect) {
-        console.error(`No connection settings found in ${confFile}.`);
+        console.error(`No connection settings found in ??.`);
         process.exit(-1);
         return;
     }
-    try {
-        const prevPidStr = await (0, async_fs_node_1.readFile)(PID_FILE, { encoding: 'utf8' });
-        const prevPid = Number.parseInt(prevPidStr);
-        if (!Number.isNaN(prevPid)) {
-            (0, child_process_1.execSync)(`kill -SIGTERM ${prevPid}`);
-            while (!!(0, child_process_1.execSync)(`ps ${prevPid} | grep ${prevPid}`)) {
-                await (0, processes_1.sleep)(1000);
-            }
-            await (0, async_fs_node_1.unlink)(PID_FILE).catch(noop);
-        }
-    }
-    catch (err) {
-        if (!err.notFound) {
-            throw err;
-        }
-    }
     let app = undefined;
+    function createApp(conf) {
+        const app = new lib_1.AppWithWSs();
+        app.use((0, lib_1.servicesApp)(conf, 'console', 'console'));
+        app.use((0, lib_1.adminApp)(conf, 'console', 'console'));
+        return app;
+    }
     async function stopProcess() {
         if (!app) {
             return;
         }
-        app.stop().then(err => console.log(err));
-        app = undefined;
-        (0, async_fs_node_1.unlink)(PID_FILE).catch(noop);
+        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;
+        }
     }
-    try {
-        app = new lib_1.AppWithWSs();
-        app.use((0, lib_1.servicesApp)(conf));
-        app.use((0, lib_1.adminApp)(conf));
-        const { hostname, port, sslOpts } = conf.servicesConnect;
+    async function startAppWithTLS(sslOpts, port, hostname) {
         await app.start(sslOpts, port, hostname);
-        console.log(`Started 3NWeb server at address "${hostname}", port ${port}, ${sslOpts ? 'via TLS' : 'without TLS, and requiring TLS reverse proxy infront.'}`);
-        (0, fs_1.writeFileSync)(PID_FILE, `${process.pid}`);
+        console.log(`Started 3NWeb server on port ${port},${hostname ? ` hostname ${hostname},` : ''} with TLS.`);
+    }
+    async function startAppWithoutTLS(port, hostname) {
+        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 = (0, letsencrypt_1.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) {
-        stopProcess();
+        await stopProcess();
         console.error(err);
         process.exit(-500);
     }
-})();
+}
+function showUsage({ txtToDisplay, exitStatus }) {
+    if (exitStatus === 0) {
+        console.log(txtToDisplay);
+    }
+    else {
+        console.error(txtToDisplay);
+    }
+    process.exit(exitStatus);
+}
+function assembleConfig(configPath) {
+    if (configPath) {
+        return (0, from_yaml_1.readYamlConfFile)(configPath);
+    }
+    else {
+        throw new Error(`Config path must be given`);
+    }
+}
+async function displaySignupInfo(conf) {
+    if (!conf.signup) {
+        console.log(`\nSignup is disabled.\n`);
+    }
+    else {
+        console.log(`\nSignup is enabled.\n`);
+        if (conf.signup.noTokenFile) {
+            const ctx = await (0, signup_1.readNoTokensFile)(conf.signup.noTokenFile);
+            console.log(`Signup of user without token is allowed in domains:\n`, ctx.domains, `\n`);
+        }
+        else {
+            console.log(`Signup of users is allowed only with valid signup tokens.\n`);
+        }
+    }
+    const { multiUserTokens, singleUserTokens } = await (0, signup_1.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) {
+    const { multiUserTokens, singleUserTokens } = await (0, signup_1.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, tokenId) {
+    const ctx = await (0, signup_1.readTokenFile)(conf.rootFolder, tokenId);
+    if (!ctx) {
+        console.error(`Token ${tokenId} is not found.`);
+        process.exit(-1);
+    }
+    else 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()}\n`);
+        }
+        else {
+            console.log(``);
+        }
+    }
+    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()}\n`);
+        }
+        else {
+            console.log(``);
+        }
+    }
+}
+async function createMultiUserToken(conf, domains) {
+    const token = await (0, signup_1.addMultiDomainSignup)(conf.rootFolder, domains);
+    console.log(`\nToken value:\n  ${token}\n`);
+}
+async function createSingleUserToken(conf, userId) {
+    const token = await (0, signup_1.addSingleUserSignup)(conf.rootFolder, userId);
+    console.log(`\nToken value:\n  ${token}\n`);
+}
+const cmd = (0, cli_1.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 {
+        throw new Error(`CLI parser failed to capture invalid command`);
+    }
+}
+else if (cmd.showUsage) {
+    showUsage(cmd.showUsage);
+}
+else {
+    throw new Error(`CLI parser failed to trigger useful action`);
+}

package/build/mock/node-child-ipc.d.ts

@@ -2,7 +2,7 @@
 import * as cProcs from 'child_process';
 import { RequestServer, RequestingClient } from '../lib-common/ipc/generic-ipc';
 export { RequestEnvelope, RequestHandler } from '../lib-common/ipc/generic-ipc';
-export declare type IPCToChild = RequestingClient;
-export declare type IPCToParent = RequestServer;
+export type IPCToChild = RequestingClient;
+export type IPCToParent = RequestServer;
 export declare function commToChild(channel: string, child: cProcs.ChildProcess): IPCToChild;
 export declare function commToParent(channel: string): IPCToParent;