Exit code issues

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeplin/cli",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Zeplin CLI",
   "main": "./dist/src/app",
   "types": "./dist/types/index",
@@ -31,28 +31,28 @@
   },
   "homepage": "https://github.com/zeplin/cli#readme",
   "devDependencies": {
-    "@microsoft/api-documenter": "^7.7.2",
-    "@microsoft/api-extractor": "^7.7.0",
+    "@microsoft/api-documenter": "^7.8.0",
+    "@microsoft/api-extractor": "^7.8.0",
     "@types/ci-info": "^2.0.0",
     "@types/express": "^4.17.2",
     "@types/fs-extra": "^8.0.0",
     "@types/hapi__joi": "^16.0.3",
     "@types/inquirer": "^6.5.0",
-    "@types/jest": "^24.0.18",
+    "@types/jest": "^25.2.1",
     "@types/jsonwebtoken": "^8.3.4",
     "@types/node": "^12.7.5",
-    "@types/update-notifier": "^2.5.0",
+    "@types/update-notifier": "^4.1.0",
     "@types/url-join": "^4.0.0",
     "@types/winston": "^2.4.4",
     "@typescript-eslint/eslint-plugin": "^2.3.0",
     "@typescript-eslint/parser": "^2.3.0",
     "@zeplin/eslint-config": "^2.2.0",
     "eslint": "^6.4.0",
     "eslint-import-resolver-typescript": "^1.1.1",
-    "husky": "^3.0.5",
-    "jest": "^24.9.0",
-    "ts-jest": "^24.1.0",
-    "typescript": "^3.7.3"
+    "husky": "^4.2.5",
+    "jest": "^25.5.4",
+    "ts-jest": "^25.5.1",
+    "typescript": "^3.9.2"
   },
   "dependencies": {
     "@hapi/joi": "^16.1.7",

src/app.ts

@@ -15,7 +15,9 @@ function beforeCommand(): void {
         pkg: {
             name,
             version
-        }
+        },
+        updateCheckInterval: 0,
+        shouldNotifyInNpmScript: true
     });
     un.notify();
 }

src/commands/connect/index.ts

@@ -47,10 +47,6 @@ const startDevServer = async (
 
     const devServer = new ConnectDevServer(connectedBarrels);
 
-    await devServer.start(devModePort);
-
-    logger.info(chalk.green(`Development server is started.`));
-
     if (devModeWatch) {
         let componentFiles = getComponentFilePaths(connectedBarrels);
 
@@ -78,12 +74,14 @@ const startDevServer = async (
                 watcher.add(componentFiles);
             } catch (error) {
                 logger.error(chalk.red(dedent`
-                    Could not update components.
+                    Could not update connected components.
                     ${error}
                 `));
             }
         });
     }
+
+    await devServer.listen(devModePort);
 };
 
 const upload = async (connectedBarrels: ConnectedBarrelComponents[]): Promise<void> => {

src/commands/connect/plugin.ts

@@ -57,7 +57,7 @@ const createPluginInstance = async (plugin: Plugin): Promise<ConnectPluginInstan
     pluginInstance.name = plugin.name;
 
     if (typeof pluginInstance.init === "function") {
-        logger.debug(`${plugin.name} has init method. Initializing with ${plugin.config}`);
+        logger.debug(`${plugin.name} has init method. Initializing with ${JSON.stringify(plugin.config)}`);
         await pluginInstance.init({ config: plugin.config });
     }
 

src/commands/connect/server/index.ts

@@ -1,3 +1,4 @@
+import chalk from "chalk";
 import express from "express";
 import { Server } from "http";
 import { OK } from "http-status-codes";
@@ -29,7 +30,7 @@ export class ConnectDevServer {
     }
 
     start(port: number): Promise<Server> {
-        if (this.server && this.server.listening) {
+        if (this.server?.listening) {
             return Promise.resolve(this.server);
         }
 
@@ -55,6 +56,9 @@ export class ConnectDevServer {
             this.server = app.listen(port)
                 .on("listening", () => {
                     logger.debug(`Started dev server on port ${port}`);
+
+                    logger.info(chalk.green(`Development server is started.`));
+
                     resolve(this.server);
                 })
                 .on("error", (err: NodeJS.ErrnoException) => {
@@ -84,4 +88,13 @@ export class ConnectDevServer {
             });
         });
     }
+    async listen(port: number): Promise<void> {
+        await this.start(port);
+        return new Promise((resolve): void => {
+            process.on("SIGINT", async () => {
+                await this.stop();
+                resolve();
+            });
+        });
+    }
 }

src/util/command.ts

@@ -1,18 +1,13 @@
 import chalk from "chalk";
 import dedent from "ts-dedent";
-import { isVerbose } from "../util/env";
+import os from "os";
+import path from "path";
+import { isVerbose } from "./env";
 import { CLIError } from "../errors";
-import logger from "../util/logger";
+import logger from "./logger";
+import { gracefulExit } from "./process";
 
-const waitForLoggerAndExit = (exitCode = 0): Promise<void> =>
-    new Promise((resolve): void => {
-        logger.on("finish", () => {
-            resolve();
-            process.exit(exitCode);
-        });
-    });
-
-const errorHandler = (error: Error): void => {
+const errorHandler = (error: Error): Promise<never> => {
     if (isVerbose()) {
         logger.error(`\n${chalk.redBright(error.stack)}`);
     } else {
@@ -24,24 +19,29 @@ const errorHandler = (error: Error): void => {
         const errorDetails = JSON.stringify(error.details);
         if (isVerbose()) {
             logger.error(chalk.redBright(dedent`
-                Details:
-                ${errorDetails}`));
+            Details:
+            ${errorDetails}`));
         } else {
             logger.debug(`${errorDetails}`);
         }
     }
-    logger.info(`\nPlease check ${chalk.dim("~/.zeplin/cli.log")} for details.\n`);
 
-    waitForLoggerAndExit(1);
+    const logFile = path.join(os.homedir(), ".zeplin", "cli.log");
+    logger.info(`\nPlease check ${chalk.dim(logFile)} for details.\n`);
+
+    return gracefulExit(1);
 };
 
 type FunctionReturnsPromise = (...args: Array<any>) => Promise<void>;
 
 function commandRunner(fn: FunctionReturnsPromise): FunctionReturnsPromise {
     return async (...args: Array<any>): Promise<void> => {
-        await fn(...args)
-            .then(() => waitForLoggerAndExit())
-            .catch(errorHandler);
+        try {
+            await fn(...args);
+            await gracefulExit();
+        } catch (e) {
+            await errorHandler(e);
+        }
     };
 }
 

src/util/logger.ts

@@ -1,37 +1,63 @@
 import winston, { format } from "winston";
 import os from "os";
 import stripAnsi from "strip-ansi";
+import { EventEmitter } from "events";
+
+const fileTransport = new winston.transports.File({
+    level: "silly",
+    filename: "cli.log",
+    maxsize: 1048576, // 1 MB
+    maxFiles: 2,
+    dirname: `${os.homedir()}/.zeplin`,
+    tailable: true,
+    format: format.combine(
+        format.timestamp({
+            format: "YYYY-MM-DD HH:mm:ss"
+        }),
+        format.errors({ stack: true }),
+        format.splat(),
+        format.printf(m =>
+            stripAnsi(`${m.timestamp} - ${m.level} - ${m.message}${m.stack ? `\n${m.stack}` : ""}`)
+                .replace(/\r?\n/g, "")
+        )
+    )
+});
+
+const consoleTransport = new winston.transports.Console({
+    level: "info",
+    stderrLevels: ["error"],
+    format: format.combine(
+        format.splat(),
+        format.printf(m => `${m.message}`)
+    )
+});
 
 const logger = winston.createLogger({
     transports: [
-        new winston.transports.File({
-            level: "silly",
-            filename: "cli.log",
-            maxsize: 1048576, // 1 MB
-            maxFiles: 2,
-            dirname: `${os.homedir()}/.zeplin`,
-            tailable: true,
-            format: format.combine(
-                format.timestamp({
-                    format: "YYYY-MM-DD HH:mm:ss"
-                }),
-                format.errors({ stack: true }),
-                format.splat(),
-                format.printf(m =>
-                    stripAnsi(`${m.timestamp} - ${m.level} - ${m.message}${m.stack ? `\n${m.stack}` : ""}`)
-                        .replace(/\r?\n/g, "")
-                )
-            )
-        }),
-        new winston.transports.Console({
-            level: "info",
-            stderrLevels: ["error"],
-            format: format.combine(
-                format.splat(),
-                format.printf(m => `${m.message}`)
-            )
-        })
+        fileTransport,
+        consoleTransport
     ]
 });
 
+// Workaround to ensure all logs are written into the file before process exit
+const fileLogWatcher = new EventEmitter();
+fileTransport.on("open", () => {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
+    // @ts-ignore
+    // eslint-disable-next-line no-underscore-dangle
+    fileTransport._dest.on("finish", () => {
+        fileLogWatcher.emit("finish");
+    });
+});
+
+const finishLogger = (): Promise<void> => new Promise((resolve): void => {
+    fileLogWatcher.on("finish", (): void => {
+        resolve();
+    });
+    logger.end();
+});
+
 export default logger;
+export {
+    finishLogger
+};

src/util/process.ts

@@ -0,0 +1,10 @@
+import { finishLogger } from "./logger";
+
+const gracefulExit = async (exitCode = 0): Promise<never> => {
+    await finishLogger();
+    process.exit(exitCode);
+};
+
+export {
+    gracefulExit
+};