fixed startup event oder - fixes #6511

app/lib/config.ts

@@ -6,28 +6,29 @@ import * as gracefulFS from 'graceful-fs'
 import { app } from 'electron'
 import { promisify } from 'util'
 
-export async function migrateConfig (): Promise<void> {
+export function migrateConfig (): void {
     const configPath = path.join(app.getPath('userData'), 'config.yaml')
     const legacyConfigPath = path.join(app.getPath('userData'), '../terminus', 'config.yaml')
-    if (await fs.exists(legacyConfigPath) && (
-        !await fs.exists(configPath) ||
-        (await fs.stat(configPath)).mtime < (await fs.stat(legacyConfigPath)).mtime
+    if (fs.existsSync(legacyConfigPath) && (
+        !fs.existsSync(configPath) ||
+        fs.statSync(configPath).mtime < fs.statSync(legacyConfigPath).mtime
     )) {
-        await fs.writeFile(configPath, await fs.readFile(legacyConfigPath))
+        fs.writeFileSync(configPath, fs.readFileSync(legacyConfigPath))
     }
 }
 
-export async function loadConfig (): Promise<any> {
-    await migrateConfig()
+export function loadConfig (): any {
+    migrateConfig()
 
     const configPath = path.join(app.getPath('userData'), 'config.yaml')
-    if (await fs.exists(configPath)) {
-        return yaml.load(await fs.readFile(configPath, 'utf8'))
+    if (fs.existsSync(configPath)) {
+        return yaml.load(fs.readFileSync(configPath, 'utf8'))
     } else {
         return {}
     }
 }
 
+
 const configPath = path.join(app.getPath('userData'), 'config.yaml')
 let _configSaveInProgress = Promise.resolve()
 

app/lib/index.ts

@@ -15,43 +15,45 @@ if (!process.env.TABBY_PLUGINS) {
 
 const argv = parseArgs(process.argv, process.cwd())
 
-const application = loadConfig().catch(err => {
+// eslint-disable-next-line @typescript-eslint/init-declarations
+let configStore: any
+
+try {
+    configStore = loadConfig()
+} catch (err) {
     dialog.showErrorBox('Could not read config', err.message)
     app.exit(1)
-}).then(configStore => {
-    const _application = new Application(configStore)
+}
 
-    ipcMain.on('app:new-window', () => {
-        _application.newWindow()
-    })
+const application = new Application(configStore)
 
-    process.on('uncaughtException' as any, err => {
+ipcMain.on('app:new-window', () => {
+    application.newWindow()
+})
+
+process.on('uncaughtException' as any, err => {
     console.log(err)
-        _application.broadcast('uncaughtException', err)
-    })
+    application.broadcast('uncaughtException', err)
+})
 
-    if (argv.d) {
+if (argv.d) {
     electronDebug({
         isEnabled: true,
         showDevTools: true,
         devToolsMode: 'undocked',
     })
-    }
-
-    return _application
-})
-
+}
 
 app.on('activate', async () => {
-    if (!(await application).hasWindows()) {
-        (await application).newWindow()
+    if (!application.hasWindows()) {
+        application.newWindow()
     } else {
-        (await application).focus()
+        application.focus()
     }
 })
 
 app.on('second-instance', async (_event, newArgv, cwd) => {
-    (await application).handleSecondInstance(newArgv, cwd)
+    application.handleSecondInstance(newArgv, cwd)
 })
 
 if (!app.requestSingleInstanceLock()) {
@@ -71,9 +73,9 @@ app.on('ready', async () => {
         ]))
     }
 
-    (await application).init()
+    application.init()
 
-    const window = await (await application).newWindow({ hidden: argv.hidden })
+    const window = await application.newWindow({ hidden: argv.hidden })
     await window.ready
     window.passCliArguments(process.argv, process.cwd(), false)
     window.focus()