improve autoupdating logic and logging

Author: Onatcer

src/main/autoUpdater.ts

@@ -1,8 +1,10 @@
-import { ipcMain, app } from 'electron'
+import { ipcMain, app, autoUpdater as nativeAutoUpdater } from 'electron'
 import type { AppUpdater } from 'electron-updater'
 import electronUpdater from 'electron-updater'
 import log from 'electron-log'
 
+let updaterLifecycleLoggingRegistered = false
+
 export function getAutoUpdater(): AppUpdater {
     // Using destructuring to access autoUpdater due to the CommonJS module of 'electron-updater'.
     // It is a workaround for ESM compatibility issues, see https://github.com/electron-userland/electron-builder/issues/7976.
@@ -13,37 +15,81 @@ export function getAutoUpdater(): AppUpdater {
 }
 
 export function initializeAutoUpdater() {
-    getAutoUpdater().autoDownload = true
-    getAutoUpdater().autoInstallOnAppQuit = false
-    getAutoUpdater().allowDowngrade = true
+    registerUpdaterLifecycleLogging()
+
+    const updater = getAutoUpdater()
+    updater.autoDownload = true
+    updater.autoInstallOnAppQuit = false
+    updater.allowDowngrade = true
+
+    log.info(
+        `[updater] initialized (appVersion=${app.getVersion()}, isPackaged=${app.isPackaged}, platform=${process.platform})`
+    )
 }
 
 export function registerAutoUpdateListeners(mainWindow: Electron.BrowserWindow) {
+    const updater = getAutoUpdater()
+
     ipcMain.on('updateAutoUpdater', () => {
-        // force dev update config
-        getAutoUpdater().checkForUpdatesAndNotify()
+        updater.checkForUpdatesAndNotify().catch((error) => {
+            const message = error instanceof Error ? error.message : String(error)
+            log.error(`[updater] checkForUpdatesAndNotify rejected: ${message}`)
+        })
     })
 
-    getAutoUpdater().addListener('update-available', () => {
+    updater.addListener('update-available', (info) => {
+        log.info(`[updater] update-available (version=${info.version})`)
         mainWindow.webContents.send('updateAvailable')
     })
 
-    getAutoUpdater().addListener('update-not-available', () => {
+    updater.addListener('update-not-available', () => {
         mainWindow.webContents.send('updateNotAvailable')
     })
 
-    getAutoUpdater().addListener('update-downloaded', () => {
+    updater.addListener('update-downloaded', (info) => {
+        log.info(`[updater] update-downloaded (version=${info.version})`)
         mainWindow.webContents.send('updateDownloaded')
     })
 
-    getAutoUpdater().addListener('error', (error) => {
+    updater.addListener('error', (error) => {
+        log.error(`[updater] error: ${error.message}`)
         mainWindow.webContents.send('updateError', error.message)
     })
 
     ipcMain.on('installUpdate', () => {
-        app.emit('before-quit')
-        setTimeout(() => {
-            getAutoUpdater().quitAndInstall()
-        }, 500)
+        log.info(`[updater] installUpdate IPC received, calling quitAndInstall()`)
+        try {
+            updater.quitAndInstall()
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error)
+            log.error(`[updater] quitAndInstall() threw: ${message}`)
+            mainWindow.webContents.send('updateError', message)
+        }
+    })
+}
+
+function registerUpdaterLifecycleLogging() {
+    if (updaterLifecycleLoggingRegistered) {
+        return
+    }
+
+    updaterLifecycleLoggingRegistered = true
+
+    // These four events are the ones that tell us whether Squirrel.Mac is actually
+    // being reached during an install. Keep them.
+    nativeAutoUpdater.on('before-quit-for-update', () => {
+        log.info(`[updater] native autoUpdater emitted before-quit-for-update`)
+    })
+
+    app.on('before-quit', () => {
+        log.info(`[updater] app emitted before-quit`)
+    })
+
+    app.on('will-quit', () => {
+        log.info(`[updater] app emitted will-quit`)
+    })
+
+    app.on('quit', (_event, exitCode) => {
+        log.info(`[updater] app emitted quit (exitCode=${exitCode})`)
     })
 }

src/main/index.ts

@@ -202,37 +202,50 @@ app.on('window-all-closed', () => {
     }
 })
 
-// Save active periods before the app quits
-app.on('before-quit', async (event) => {
-    // Skip cleanup during E2E testing to avoid slow shutdown
+// Save active periods before quitting. Use app.quit() after the async save so
+// Squirrel.Mac can finish updater handoff; app.exit(0) bypasses it.
+let saveCompleted = false
+let saveInProgress = false
+
+app.on('before-quit', (event) => {
     if (isE2ETesting()) {
         return
     }
 
-    event?.preventDefault()
+    if (saveCompleted) {
+        return
+    }
 
-    try {
-        console.log('App quitting - saving active periods...')
+    event.preventDefault()
 
-        // Create a promise that rejects after 5 seconds
-        const timeoutPromise = new Promise<never>((_, reject) => {
-            setTimeout(() => reject(new Error('Save operation timeout after 5 seconds')), 5000)
+    if (saveInProgress) {
+        return
+    }
+    saveInProgress = true
+
+    saveActivePeriodsBeforeQuit()
+        .catch((error) => {
+            console.error('Error saving active periods on quit:', error)
+        })
+        .finally(() => {
+            saveCompleted = true
+            app.quit()
         })
+})
 
-        // Race the save operations against the timeout
-        const savePromise = Promise.all([stopActivityTracking(), stopIdleMonitoring()])
+async function saveActivePeriodsBeforeQuit(): Promise<void> {
+    console.log('App quitting - saving active periods...')
 
-        await Promise.race([savePromise, timeoutPromise])
+    const timeoutPromise = new Promise<never>((_, reject) => {
+        setTimeout(() => reject(new Error('Save operation timeout after 5 seconds')), 5000)
+    })
 
-        console.log('Active periods saved successfully')
-    } catch (error) {
-        console.error('Error saving active periods on quit:', error)
-        // Continue with quit even if save fails
-    } finally {
-        // Now allow the app to quit
-        app.exit(0)
-    }
-})
+    const savePromise = Promise.all([stopActivityTracking(), stopIdleMonitoring()])
+
+    await Promise.race([savePromise, timeoutPromise])
+
+    console.log('Active periods saved successfully')
+}
 
 // In this file you can include the rest of your app"s specific main process
 // code. You can also put them in separate files and require them here.

src/main/mainWindow.ts

@@ -1,5 +1,5 @@
 import { join } from 'path'
-import { app, BrowserWindow, ipcMain, shell } from 'electron'
+import { app, autoUpdater as nativeAutoUpdater, BrowserWindow, ipcMain, shell } from 'electron'
 import { is } from '@electron-toolkit/utils'
 import { isE2ETesting } from './env'
 
@@ -48,6 +48,9 @@ export function initializeMainWindow(icon: string) {
     app.on('before-quit', () => {
         forcequit = true
     })
+    nativeAutoUpdater.on('before-quit-for-update', () => {
+        forcequit = true
+    })
 
     mainWindow.on('ready-to-show', () => {
         if (!isE2ETesting()) {

src/main/miniWindow.ts

@@ -1,5 +1,5 @@
 import { join } from 'path'
-import { app, BrowserWindow, ipcMain } from 'electron'
+import { app, autoUpdater as nativeAutoUpdater, BrowserWindow, ipcMain } from 'electron'
 import { isE2ETesting } from './env'
 
 export function initializeMiniWindow(icon: string) {
@@ -53,4 +53,7 @@ export function registerMiniWindowListeners(miniWindow: BrowserWindow) {
     app.on('before-quit', () => {
         forcequit = true
     })
+    nativeAutoUpdater.on('before-quit-for-update', () => {
+        forcequit = true
+    })
 }