fix: Don't check twice for single instance (WEBAPP-6663)

electron/src/lib/LocalAccountDeletion.ts

@@ -30,7 +30,7 @@ const LOG_DIR = path.join(USER_DATA_DIR, 'logs');
 const logger = getLogger(path.basename(__filename));
 
 const clearStorage = async (session: Session): Promise<void> => {
-  await session.clearStorageData();
+  session.clearStorageData();
   await session.clearCache();
   session.flushStorageData();
 };

electron/src/main.ts

@@ -314,9 +314,9 @@ const showMainWindow = async (mainWindowState: WindowStateKeeper.State) => {
 
 // App Events
 const handleAppEvents = () => {
-  app.on('window-all-closed', () => {
+  app.on('window-all-closed', async () => {
     if (!EnvironmentUtil.platform.IS_MAC_OS) {
-      lifecycle.quit();
+      await lifecycle.quit();
     }
   });
 
@@ -599,8 +599,10 @@ class ElectronWrapperInit {
 customProtocolHandler.registerCoreProtocol();
 Raygun.initClient();
 handlePortableFlags();
-lifecycle.checkSingleInstance();
-lifecycle.checkForUpdate().catch(error => logger.error(error));
+lifecycle
+  .checkSingleInstance()
+  .then(() => lifecycle.initSquirrelListener())
+  .catch(error => logger.error(error));
 
 // Stop further execution on update to prevent second tray icon
 if (lifecycle.isFirstInstance) {

electron/src/menu/TrayHandler.ts

@@ -22,7 +22,7 @@ import * as path from 'path';
 
 import * as locale from '../locale/locale';
 import {linuxDesktop, platform} from '../runtime/EnvironmentUtil';
-import {quit as lifecycleQuit} from '../runtime/lifecycle';
+import * as lifecycle from '../runtime/lifecycle';
 import {config} from '../settings/config';
 import {WindowManager} from '../window/WindowManager';
 
@@ -81,7 +81,7 @@ export class TrayHandler {
         label: locale.getText('trayOpen'),
       },
       {
-        click: () => lifecycleQuit(),
+        click: () => lifecycle.quit(),
         label: locale.getText('trayQuit'),
       },
     ]);

electron/src/runtime/lifecycle.ts

@@ -32,24 +32,24 @@ const logger = getLogger(path.basename(__filename));
 
 export let isFirstInstance: boolean | undefined = undefined;
 
-export async function checkForUpdate(): Promise<void> {
+export async function initSquirrelListener(): Promise<void> {
   if (EnvironmentUtil.platform.IS_WINDOWS) {
     logger.info('Checking for Windows update ...');
-    await Squirrel.handleSquirrelEvent(isFirstInstance);
+    await Squirrel.handleSquirrelArgs();
 
     ipcMain.on(EVENT_TYPE.WRAPPER.UPDATE, () => Squirrel.installUpdate());
   }
 }
 
-export const checkSingleInstance = () => {
+export const checkSingleInstance = async () => {
   if (process.mas) {
     isFirstInstance = true;
   } else {
     isFirstInstance = app.requestSingleInstanceLock();
     logger.info('Checking if we are the first instance ...', isFirstInstance);
 
     if (!EnvironmentUtil.platform.IS_WINDOWS && !isFirstInstance) {
-      quit();
+      await quit(false);
     } else {
       app.on('second-instance', () => WindowManager.showPrimaryWindow());
     }
@@ -68,20 +68,25 @@ export const getWebViewId = (contents: WebContents): string | undefined => {
 
 // Using exit instead of quit for the time being
 // see: https://github.com/electron/electron/issues/8862#issuecomment-294303518
-export const quit = (): void => {
+export const quit = async (clearCache = true): Promise<void> => {
   logger.info('Initiating app quit ...');
   settings.persistToFile();
 
-  logger.info('Clear cache ...');
-  if (session.defaultSession) {
-    session.defaultSession.clearCache().catch(error => logger.error(error));
+  if (clearCache) {
+    logger.info('Clearing cache ...');
+
+    try {
+      await session.defaultSession?.clearCache();
+    } catch (error) {
+      logger.error(error);
+    }
   }
 
   logger.info('Exiting ...');
   app.exit();
 };
 
-export const relaunch = () => {
+export const relaunch = async () => {
   logger.info('Relaunching the app ...');
   if (EnvironmentUtil.platform.IS_MAC_OS) {
     /*
@@ -92,6 +97,6 @@ export const relaunch = () => {
     WindowManager.sendActionToPrimaryWindow(EVENT_TYPE.WRAPPER.RELOAD);
   } else {
     app.relaunch();
-    quit();
+    await quit();
   }
 };

electron/src/update/squirrel.ts

@@ -139,37 +139,33 @@ async function scheduleUpdate(): Promise<void> {
   setInterval(installUpdate, everyCheck);
 }
 
-export async function handleSquirrelEvent(isFirstInstance?: boolean): Promise<boolean | void> {
+export async function handleSquirrelArgs(): Promise<void> {
   const squirrelEvent = process.argv[1];
 
   switch (squirrelEvent) {
     case SQUIRREL_EVENT.INSTALL: {
       await createStartShortcut();
       await createDesktopShortcut();
-      lifecycle.quit();
-      return true;
+      await lifecycle.quit();
+      return;
     }
 
     case SQUIRREL_EVENT.UPDATED: {
-      lifecycle.quit();
-      return true;
+      await lifecycle.quit();
+      return;
     }
 
     case SQUIRREL_EVENT.UNINSTALL: {
       await removeShortcuts();
-      lifecycle.quit();
-      return true;
+      await lifecycle.quit();
+      return;
     }
 
     case SQUIRREL_EVENT.OBSOLETE: {
-      lifecycle.quit();
-      return true;
+      await lifecycle.quit();
+      return;
     }
   }
 
-  if (!isFirstInstance) {
-    return lifecycle.quit();
-  }
-
   await scheduleUpdate();
 }