proteum 2.0.0-1 → 2.1.0

package/cli/commands/build.ts

@@ -13,20 +13,24 @@ import {
     getClientBundleAnalysisReportPaths,
     waitForClientBundleAnalysisArtifacts,
 } from '../compiler/common/bundleAnalysis';
+import { refreshGeneratedTypings, runAppTypecheck } from '../utils/check';
+import { renderRows } from '../presentation/layout';
+import { renderStep, renderSuccess, renderTitle } from '../presentation/ink';
 
-const allowedBuildArgs = new Set(['prod', 'cache', 'analyze']);
+const allowedBuildArgs = new Set(['prod', 'cache', 'analyze', 'strict']);
+type TBuildMultiCompiler = Awaited<ReturnType<Compiler['create']>>;
 
 /*----------------------------------
 - COMMAND
 ----------------------------------*/
 function resolveBuildMode(): TCompileMode {
     const enabledArgs = Object.entries(cli.args)
-        .filter(([name, value]) => name !== 'workdir' && value === true)
+        .filter(([name, value]) => name !== 'workdir' && name !== 'verbose' && value === true)
         .map(([name]) => name);
 
     const invalidArgs = enabledArgs.filter((arg) => !allowedBuildArgs.has(arg));
     if (invalidArgs.length > 0)
-        throw new Error(`Unknown build argument(s): ${invalidArgs.join(', ')}. Allowed values: prod, cache, analyze.`);
+        throw new Error(`Unknown build argument(s): ${invalidArgs.join(', ')}. Allowed values: prod, cache, analyze, strict.`);
 
     const requestedModes = enabledArgs.filter((arg): arg is TCompileMode => arg === 'prod');
     if (requestedModes.length > 1)
@@ -35,37 +39,100 @@ function resolveBuildMode(): TCompileMode {
     return requestedModes[0] ?? 'prod';
 }
 
-export const run = async (): Promise<void> => {
-    const mode = resolveBuildMode();
-    const compiler = new Compiler(mode, {}, false, 'bin');
-    const multiCompiler = await compiler.create();
-
+const closeMultiCompiler = async (multiCompiler: TBuildMultiCompiler) =>
     await new Promise<void>((resolve, reject) => {
-        multiCompiler.run((error, stats) => {
+        multiCompiler.close((error) => {
             if (error) {
-                console.error('An error occurred during the compilation:', error);
                 reject(error);
                 return;
             }
 
-            if (stats?.hasErrors()) {
-                reject(new Error(`Compilation failed for build mode "${mode}".`));
-                return;
-            }
-
-            if (cli.args.analyze === true) {
-                waitForClientBundleAnalysisArtifacts(app, 'bin')
-                    .then(() => {
-                        const { reportPath, statsPath } = getClientBundleAnalysisReportPaths(app, 'bin');
-                        console.info(`Client bundle analysis report: ${reportPath}`);
-                        console.info(`Client bundle analysis stats: ${statsPath}`);
-                        resolve();
-                    })
-                    .catch(reject);
-                return;
-            }
-
             resolve();
         });
     });
+
+export const run = async (): Promise<void> => {
+    const mode = resolveBuildMode();
+    const strict = cli.args.strict === true;
+    let analysisArtifacts: { reportPath: string; statsPath: string } | undefined;
+
+    console.info(
+        [
+            await renderTitle(
+                'PROTEUM BUILD',
+                strict
+                    ? 'Refreshing contracts, running TypeScript, then producing the bundles.'
+                    : 'Producing the server and client bundles.',
+            ),
+            renderRows([
+                { label: 'app', value: cli.paths.appRoot === process.cwd() ? '.' : cli.paths.appRoot },
+                { label: 'mode', value: mode },
+                { label: 'strict', value: strict ? 'enabled' : 'disabled' },
+                { label: 'cache', value: cli.args.cache === true ? 'enabled' : 'disabled' },
+                { label: 'analyze', value: cli.args.analyze === true ? 'enabled' : 'disabled' },
+                { label: 'output', value: 'bin/' },
+            ]),
+        ].join('\n\n'),
+    );
+
+    if (strict) {
+        console.info(await renderStep('[1/3]', 'Refreshing generated typings.'));
+        await refreshGeneratedTypings();
+        console.info(await renderStep('[2/3]', 'Running TypeScript typechecking.'));
+        await runAppTypecheck();
+        console.info(await renderStep('[3/3]', 'Running the production compiler.'));
+    } else {
+        console.info(await renderStep('[1/1]', 'Running the production compiler.'));
+    }
+
+    const compiler = new Compiler(mode, {}, false, 'bin');
+    const multiCompiler = await compiler.create();
+    let buildError: Error | undefined;
+
+    try {
+        await new Promise<void>((resolve, reject) => {
+            multiCompiler.run((error, stats) => {
+                if (error) {
+                    console.error('An error occurred during the compilation:', error);
+                    reject(error);
+                    return;
+                }
+
+                if (stats?.hasErrors()) {
+                    reject(new Error(`Compilation failed for build mode "${mode}".`));
+                    return;
+                }
+
+                if (cli.args.analyze === true) {
+                    waitForClientBundleAnalysisArtifacts(app, 'bin')
+                        .then(() => {
+                            analysisArtifacts = getClientBundleAnalysisReportPaths(app, 'bin');
+                            resolve();
+                        })
+                        .catch(reject);
+                    return;
+                }
+
+                resolve();
+            });
+        });
+    } catch (error) {
+        buildError = error instanceof Error ? error : new Error(String(error));
+    } finally {
+        compiler.dispose();
+        await closeMultiCompiler(multiCompiler);
+    }
+
+    if (buildError) throw buildError;
+
+    if (analysisArtifacts !== undefined) {
+        console.info(
+            renderRows([
+                { label: 'report', value: analysisArtifacts.reportPath },
+                { label: 'stats', value: analysisArtifacts.statsPath },
+            ]),
+        );
+    }
+
+    console.info(await renderSuccess(`Build completed in ${mode} mode.`));
 };

package/cli/commands/check.ts

@@ -1,8 +1,12 @@
 import cli from '..';
 import { refreshGeneratedTypings, runAppLint, runAppTypecheck } from '../utils/check';
+import { renderRows } from '../presentation/layout';
+import { renderStep, renderSuccess, renderTitle } from '../presentation/ink';
 
 const validateCheckArgs = () => {
-    const enabledArgs = Object.entries(cli.args).filter(([name, value]) => name !== 'workdir' && value === true);
+    const enabledArgs = Object.entries(cli.args).filter(
+        ([name, value]) => name !== 'workdir' && name !== 'verbose' && value === true,
+    );
 
     if (enabledArgs.length > 0)
         throw new Error(
@@ -13,7 +17,17 @@ const validateCheckArgs = () => {
 export const run = async (): Promise<void> => {
     validateCheckArgs();
 
+    console.info(
+        [
+            await renderTitle('PROTEUM CHECK', 'Refreshing contracts, running TypeScript, then running ESLint.'),
+            renderRows([{ label: 'app', value: cli.paths.appRoot === process.cwd() ? '.' : cli.paths.appRoot }]),
+        ].join('\n\n'),
+    );
+    console.info(await renderStep('[1/3]', 'Refreshing generated typings.'));
     await refreshGeneratedTypings();
+    console.info(await renderStep('[2/3]', 'Running TypeScript typechecking.'));
     await runAppTypecheck();
+    console.info(await renderStep('[3/3]', 'Running ESLint.'));
     await runAppLint();
+    console.info(await renderSuccess('All checks passed.'));
 };

package/cli/commands/dev.ts

@@ -10,6 +10,7 @@ import { spawn, ChildProcess } from 'child_process';
 import cli from '..';
 import Keyboard from '../utils/keyboard';
 import {
+    isServerReadyMessage,
     isServerHotReloadResult,
     serverHotReloadMessageType,
     TServerHotReloadRequest,
@@ -19,6 +20,8 @@ import {
 import Compiler from '../compiler';
 import { createDevEventServer } from './devEvents';
 import { ensureProjectAgentSymlinks } from '../utils/agents';
+import { renderDevSession, renderServerReadyBanner } from '../presentation/devSession';
+import { logVerbose } from '../runtime/verbose';
 
 // Core
 import { app, App } from '../app';
@@ -28,7 +31,7 @@ import { app, App } from '../app';
 ----------------------------------*/
 
 // Watch rules shared by the dev compiler and hot reload gate.
-const ignoredWatchPathPatterns = /(node_modules\/(?!proteum\/))|(\.generated\/)|(\.cache\/)/;
+const ignoredWatchPathPatterns = /(node_modules\/(?!proteum\/))|(\.generated\/)|(\.cache\/)|(\.proteum\/)/;
 const hotReloadableServerPathPatterns = [
     /^client\/pages\//,
     /^client\/components\//,
@@ -39,164 +42,161 @@ const hotReloadableServerPathPatterns = [
 const hotReloadableRoots = [() => app.paths.root, () => cli.paths.core.root];
 
 /*----------------------------------
-- MAIN PROCESS
+- STATE
 ----------------------------------*/
-export const run = () =>
-    new Promise<void>(async () => {
-        ensureProjectAgentSymlinks({ appRoot: app.paths.root, coreRoot: cli.paths.core.root });
 
-        const devEventServer = await createDevEventServer(app.env.router.port + 1);
-        app.devEventPort = devEventServer.port;
-        console.info(`Proteum dev event server ready on http://localhost:${devEventServer.port}/__proteum_hmr`);
+// Current server child process used by the dev loop.
+let cp: ChildProcess | undefined = undefined;
+let devSessionStopping = false;
+let appProcessOperation: Promise<void> = Promise.resolve();
+type TDevWatching = ReturnType<Awaited<ReturnType<Compiler['create']>>['watch']>;
 
-        const compiler = new Compiler('dev', {
-            before: (compiler) => {
-                if (compiler.name !== 'server') return;
+/*----------------------------------
+- HELPERS
+----------------------------------*/
 
-                const changedFilesList = compiler.modifiedFiles ? [...compiler.modifiedFiles] : [];
+const closeWatching = async (watching: TDevWatching) =>
+    await new Promise<void>((resolve, reject) => {
+        watching.close((error?: Error | null) => {
+            if (error) {
+                reject(error);
+                return;
+            }
 
-                if (changedFilesList.length === 0) {
-                    console.info('Server compilation started. App restart will wait for a successful server build.');
-                } else {
-                    console.info('Need to recompile server because files changed:\n' + changedFilesList.join('\n'));
-                }
-            },
-            after: () => {},
+            resolve();
         });
+    });
 
-        const multiCompiler = await compiler.create();
-        const ignoredOutputPaths = [app.paths.bin, app.paths.dev].map(normalizeWatchPath);
-
-        multiCompiler.watch(
-            {
-                // Watching may not work with NFS and machines in VirtualBox
-                // Uncomment next line if it is your case (use true or interval in milliseconds)
-                //poll: 1000,
-
-                // Decrease CPU or memory usage in some file systems
-                // Ignore updated from:
-                // - Node modules except 5HTP core (framework dev mode)
-                // - Generated files during runtime (cause infinite loop. Ex: models.d.ts)
-                // - Webpack output folders (`./dev`, legacy `./bin`)
-                ignored: (watchPath: string) => {
-                    const normalizedPath = normalizeWatchPath(watchPath);
-                    return (
-                        ignoredWatchPathPatterns.test(normalizedPath) ||
-                        ignoredOutputPaths.some(
-                            (outputPath) =>
-                                normalizedPath === outputPath || normalizedPath.startsWith(outputPath + '/'),
-                        )
-                    );
-                },
-
-                //aggregateTimeout: 1000,
-            },
-            async (error, stats) => {
-                if (error) {
-                    compiler.consumeRecentCompilationResults();
-                    console.error('Error in milticompiler.watch', error, stats?.toString());
-                    return;
-                }
+const runSerializedAppProcessOperation = async <T>(operation: () => Promise<T>) => {
+    const resultPromise = appProcessOperation.catch(() => undefined).then(() => operation());
+    appProcessOperation = resultPromise.then(() => undefined, () => undefined);
+    return resultPromise;
+};
 
-                const recentCompilationResults = compiler.consumeRecentCompilationResults();
-                const serverResult = recentCompilationResults.server;
-                const clientResult = recentCompilationResults.client;
-
-                let restartedServer = false;
-
-                if (serverResult?.succeeded === true) {
-                    const changedFilesList = serverResult.modifiedFiles || [];
-                    const canHotReloadServer = isServerHotReloadEligible(changedFilesList);
-
-                    if (canHotReloadServer && requestServerHotReload(changedFilesList)) {
-                        console.log(
-                            'Watch callback. Server route bundle changed; hot-swapping generated routes without restarting app.',
-                        );
-                    } else {
-                        console.log('Watch callback. Reloading app because server bundle changed ...');
-                        startApp(app);
-                        restartedServer = true;
-                        devEventServer.broadcast({ type: 'reload', reason: 'server' });
-                    }
-                }
+const waitForChildExit = async (child: ChildProcess, timeoutMs: number) =>
+    await new Promise<boolean>((resolve) => {
+        if (child.exitCode !== null || child.signalCode !== null) {
+            resolve(true);
+            return;
+        }
 
-                if (serverResult?.succeeded === false) {
-                    console.log('Watch callback. Server compilation failed; keeping current app instance.');
-                }
+        let settled = false;
 
-                if (!restartedServer && clientResult?.succeeded === true) {
-                    console.log('Watch callback. Client assets updated; server restart skipped.');
-                    devEventServer.broadcast({ type: 'reload', reason: 'client' });
-                    return;
-                }
+        const finish = (result: boolean) => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timeout);
+            child.off('exit', onExit);
+            child.off('close', onClose);
+            resolve(result);
+        };
 
-                if (!restartedServer && clientResult?.succeeded === false) {
-                    console.log('Watch callback. Client compilation failed; server restart skipped.');
-                    return;
-                }
+        const onExit = () => finish(true);
+        const onClose = () => finish(true);
+        const timeout = setTimeout(() => finish(false), timeoutMs);
 
-                if (restartedServer || serverResult?.succeeded === true || serverResult?.succeeded === false) {
-                    return;
-                }
+        child.once('exit', onExit);
+        child.once('close', onClose);
+    });
 
-                console.log('Watch callback. No compiler changes were tracked.');
-            },
-        );
+const escapeForRegExp = (value: string) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const createIgnoredWatchPattern = (outputPaths: string[]) =>
+    new RegExp(
+        [
+            ignoredWatchPathPatterns.source,
+            ...outputPaths.map((outputPath) => `(?:^${escapeForRegExp(outputPath)}(?:/|$))`),
+        ].join('|'),
+    );
+const getDevAppName = (app: App) =>
+    app.identity.web?.fullTitle || app.identity.web?.title || app.identity.name || app.packageJson.name || app.paths.root;
+
+const signalAppProcess = (child: ChildProcess, signal: NodeJS.Signals) => {
+    try {
+        if (process.platform !== 'win32' && child.pid !== undefined) {
+            process.kill(-child.pid, signal);
+            return true;
+        }
 
-        Keyboard.input('ctrl+r', async () => {
-            console.log('Waiting for compilers to be ready ...', Object.keys(compiler.compiling));
-            await Promise.all(Object.values(compiler.compiling));
+        child.kill(signal);
+        return true;
+    } catch (error) {
+        const errno = error as NodeJS.ErrnoException;
 
-            console.log('Reloading app ...');
-            startApp(app);
-            devEventServer.broadcast({ type: 'reload', reason: 'manual' });
+        if (errno.code === 'ESRCH') return false;
+
+        throw error;
+    }
+};
+
+async function startApp(app: App) {
+    await runSerializedAppProcessOperation(async () => {
+        if (devSessionStopping) return;
+
+        await stopAppInternal('Restart asked');
+        if (devSessionStopping) return;
+
+        logVerbose('Launching new server ...');
+        cp = spawn('node', ['--preserve-symlinks', app.outputPath('dev') + '/server.js'], {
+            // stdin, stdout, stderr
+            stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+            detached: true,
         });
 
-        Keyboard.input('ctrl+c', () => {
-            stopApp('CTRL+C Pressed');
-            void devEventServer.close();
+        const child = cp;
+
+        child.on('exit', () => {
+            if (cp === child) cp = undefined;
+        });
+
+        child.on('message', (message: unknown) => {
+            if (isServerReadyMessage(message)) {
+                void (async () => {
+                    console.info(
+                        await renderServerReadyBanner({
+                            appName: getDevAppName(app),
+                            publicUrl: message.publicUrl,
+                        }),
+                    );
+                })();
+                return;
+            }
+
+            if (!isServerHotReloadResult(message)) return;
+
+            if (message.type === serverHotReloadMessageType.succeeded) {
+                logVerbose('Server hot reload applied without restarting app.');
+                return;
+            }
+
+            console.error('Server hot reload failed. Restarting app with a fresh process.', message.error || '');
+            void startApp(app);
         });
     });
+}
 
-/*----------------------------------
-- STATE
-----------------------------------*/
+async function stopAppInternal(reason: string) {
+    const currentApp = cp;
+    if (currentApp === undefined) return;
 
-// Current server child process used by the dev loop.
-let cp: ChildProcess | undefined = undefined;
+    cp = undefined;
 
-/*----------------------------------
-- HELPERS
-----------------------------------*/
+    logVerbose(`Killing current server instance (ID: ${currentApp.pid}) for the following reason:`, reason);
 
-async function startApp(app: App) {
-    stopApp('Restart asked');
+    if (!signalAppProcess(currentApp, 'SIGTERM')) return;
 
-    console.info('Launching new server ...');
-    cp = spawn('node', ['--preserve-symlinks', app.outputPath('dev') + '/server.js'], {
-        // sdin, sdout, sderr
-        stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
-    });
+    if (await waitForChildExit(currentApp, 5000)) return;
 
-    cp.on('message', (message: unknown) => {
-        if (!isServerHotReloadResult(message)) return;
+    logVerbose(`Server instance ${currentApp.pid} did not stop after SIGTERM. Escalating to SIGKILL.`);
 
-        if (message.type === serverHotReloadMessageType.succeeded) {
-            console.log('Server hot reload applied without restarting app.');
-            return;
-        }
+    if (!signalAppProcess(currentApp, 'SIGKILL')) return;
 
-        console.error('Server hot reload failed. Restarting app with a fresh process.', message.error || '');
-        startApp(app);
-    });
+    await waitForChildExit(currentApp, 2000);
 }
 
-function stopApp(reason: string) {
-    if (cp !== undefined) {
-        console.info(`Killing current server instance (ID: ${cp.pid}) for the following reason:`, reason);
-        cp.kill();
-        cp = undefined;
-    }
+async function stopApp(reason: string) {
+    await runSerializedAppProcessOperation(async () => {
+        await stopAppInternal(reason);
+    });
 }
 
 function requestServerHotReload(changedFiles: string[]) {
@@ -204,8 +204,12 @@ function requestServerHotReload(changedFiles: string[]) {
 
     const message: TServerHotReloadRequest = { type: serverHotReloadMessageType.request, changedFiles };
 
-    cp.send(message);
-    return true;
+    try {
+        cp.send(message);
+        return true;
+    } catch {
+        return false;
+    }
 }
 
 function isServerHotReloadEligible(changedFiles: string[]) {
@@ -232,3 +236,155 @@ function isServerHotReloadEligible(changedFiles: string[]) {
 function normalizeWatchPath(watchPath: string) {
     return path.resolve(watchPath).replace(/\\/g, '/').replace(/\/$/, '');
 }
+
+/*----------------------------------
+- MAIN PROCESS
+----------------------------------*/
+export const run = async () => {
+    devSessionStopping = false;
+    ensureProjectAgentSymlinks({ appRoot: app.paths.root, coreRoot: cli.paths.core.root });
+
+    const devEventServer = await createDevEventServer(app.env.router.port + 1);
+    app.devEventPort = devEventServer.port;
+    console.info(
+        await renderDevSession({
+            appName: getDevAppName(app),
+            appRoot: app.paths.root === process.cwd() ? '.' : app.paths.root,
+            routerPort: app.env.router.port,
+            devEventPort: devEventServer.port,
+        }),
+    );
+
+    const compiler = new Compiler('dev', {
+        before: (compiler) => {
+            if (compiler.name !== 'server') return;
+
+            const changedFilesList = compiler.modifiedFiles ? [...compiler.modifiedFiles] : [];
+
+            if (changedFilesList.length === 0) {
+                logVerbose('Server compilation started. App restart will wait for a successful server build.');
+            } else {
+                logVerbose('Need to recompile server because files changed:\n' + changedFilesList.join('\n'));
+            }
+        },
+        after: () => {},
+    });
+
+    const multiCompiler = await compiler.create();
+    const ignoredOutputPaths = [app.paths.bin, app.paths.dev].map(normalizeWatchPath);
+    const ignoredWatchPattern = createIgnoredWatchPattern(ignoredOutputPaths);
+
+    const watching = multiCompiler.watch(
+        {
+            // Watching may not work with NFS and machines in VirtualBox
+            // Uncomment next line if it is your case (use true or interval in milliseconds)
+            //poll: 1000,
+
+            // Decrease CPU or memory usage in some file systems
+            // Ignore updated from:
+            // - Node modules except 5HTP core (framework dev mode)
+            // - Generated files during runtime (cause infinite loop. Ex: models.d.ts)
+            // - Webpack output folders (`./dev`, legacy `./bin`)
+            ignored: ignoredWatchPattern,
+
+            //aggregateTimeout: 1000,
+        },
+        async (error, stats) => {
+            if (error) {
+                compiler.consumeRecentCompilationResults();
+                console.error('Error in milticompiler.watch', error, stats ? stats.toString('errors-warnings') : '');
+                return;
+            }
+
+            const recentCompilationResults = compiler.consumeRecentCompilationResults();
+            const serverResult = recentCompilationResults.server;
+            const clientResult = recentCompilationResults.client;
+
+            let restartedServer = false;
+
+            if (serverResult?.succeeded === true) {
+                const changedFilesList = serverResult.modifiedFiles || [];
+                const canHotReloadServer = isServerHotReloadEligible(changedFilesList);
+
+                if (canHotReloadServer && requestServerHotReload(changedFilesList)) {
+                    logVerbose(
+                        'Watch callback. Server route bundle changed; hot-swapping generated routes without restarting app.',
+                    );
+                } else {
+                    logVerbose('Watch callback. Reloading app because server bundle changed ...');
+                    await startApp(app);
+                    restartedServer = true;
+                    devEventServer.broadcast({ type: 'reload', reason: 'server' });
+                }
+            }
+
+            if (serverResult?.succeeded === false) {
+                logVerbose('Watch callback. Server compilation failed; keeping current app instance.');
+            }
+
+            if (!restartedServer && clientResult?.succeeded === true) {
+                logVerbose('Watch callback. Client assets updated; server restart skipped.');
+                devEventServer.broadcast({ type: 'reload', reason: 'client' });
+                return;
+            }
+
+            if (!restartedServer && clientResult?.succeeded === false) {
+                logVerbose('Watch callback. Client compilation failed; server restart skipped.');
+                return;
+            }
+
+            if (restartedServer || serverResult?.succeeded === true || serverResult?.succeeded === false) {
+                return;
+            }
+
+            logVerbose('Watch callback. No compiler changes were tracked.');
+        },
+    );
+
+    let shuttingDownPromise: Promise<void> | undefined;
+
+    const shutdown = async (reason: string) => {
+        if (shuttingDownPromise) return shuttingDownPromise;
+
+        devSessionStopping = true;
+        shuttingDownPromise = (async () => {
+            logVerbose('Stopping the Proteum dev session ...', reason);
+            await closeWatching(watching);
+            compiler.dispose();
+            await stopApp(reason);
+            await devEventServer.close();
+        })();
+
+        return shuttingDownPromise;
+    };
+
+    const exitAfterShutdown = (reason: string, exitCode: number) => {
+        void (async () => {
+            try {
+                await shutdown(reason);
+                process.exit(exitCode);
+            } catch (error) {
+                console.error(error);
+                process.exit(1);
+            }
+        })();
+    };
+
+    Keyboard.input('ctrl+r', async () => {
+        logVerbose('Waiting for compilers to be ready ...', Object.keys(compiler.compiling));
+        await Promise.all(Object.values(compiler.compiling));
+
+        logVerbose('Reloading app ...');
+        await startApp(app);
+        devEventServer.broadcast({ type: 'reload', reason: 'manual' });
+    });
+
+    Keyboard.input('ctrl+c', async () => {
+        await shutdown('CTRL+C Pressed');
+        process.exit(0);
+    });
+
+    process.once('SIGINT', () => exitAfterShutdown('SIGINT', 0));
+    process.once('SIGTERM', () => exitAfterShutdown('SIGTERM', 0));
+    process.once('SIGHUP', () => exitAfterShutdown('SIGHUP', 0));
+};