♻️ Reinforce electron async logic and typing

Xe-Persistent · Xe-Persistent · commit 0695e92a8dad · 2026-03-02T19:38:49.000+08:00
diff --git a/electron/backend-manager.ts b/electron/backend-manager.ts
@@ -2,8 +2,20 @@ import type { ChildProcess } from 'child_process';
 import { spawn } from 'child_process';
 import { app, dialog } from 'electron';
 import fs from 'fs';
+import fsPromises from 'fs/promises';
 import path from 'path';
 
+interface AppSettings {
+  server?: {
+    host?: string;
+    port?: number;
+  };
+  mitm?: {
+    host?: string;
+    port?: number;
+  };
+}
+
 import { BACKEND_SHUTDOWN_API_TIMEOUT_MS, BACKEND_SHUTDOWN_TIMEOUT_MS } from './constants';
 import type { ResourceStatus } from './resource-validator';
 import { ResourceValidator } from './resource-validator';
@@ -16,43 +28,51 @@ export class BackendManager {
   private readyPromise: Promise<void>;
   private resolveReady!: () => void;
 
-  public getBackendConfig(): { host: string; port: number } {
+  public async getBackendConfig(): Promise<{ host: string; port: number }> {
     const defaultHost = '127.0.0.1';
     const defaultPort = 8765;
 
     try {
       const settingsPath = getAssetPath('config', 'settings.json');
+      const fileContent = await fsPromises.readFile(settingsPath, 'utf8');
+      const settings = JSON.parse(fileContent) as AppSettings;
 
-      if (fs.existsSync(settingsPath)) {
-        const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-        return {
-          host: settings?.server?.host || defaultHost,
-          port: settings?.server?.port || defaultPort,
-        };
-      }
+      return {
+        host: settings?.server?.host ?? defaultHost,
+        port: settings?.server?.port ?? defaultPort,
+      };
     } catch (err) {
-      console.warn('[BackendManager] Failed to read settings.json for backend config:', err);
+      if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
+        console.warn(
+          '[BackendManager] Failed to read settings.json for backend config:',
+          err instanceof Error ? err.message : String(err),
+        );
+      }
     }
 
     return { host: defaultHost, port: defaultPort };
   }
 
-  public getMitmConfig(): { host: string; port: number } {
+  public async getMitmConfig(): Promise<{ host: string; port: number }> {
     const defaultHost = '127.0.0.1';
     const defaultPort = 6789;
 
     try {
       const settingsPath = getAssetPath('config', 'settings.json');
+      const fileContent = await fsPromises.readFile(settingsPath, 'utf8');
+      const settings = JSON.parse(fileContent) as AppSettings;
 
-      if (fs.existsSync(settingsPath)) {
-        const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-        return {
-          host: settings?.mitm?.host || defaultHost,
-          port: settings?.mitm?.port || defaultPort,
-        };
-      }
+      return {
+        host: settings?.mitm?.host ?? defaultHost,
+        port: settings?.mitm?.port ?? defaultPort,
+      };
     } catch (err) {
-      console.warn('[BackendManager] Failed to read settings.json for mitm config:', err);
+      if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
+        console.warn(
+          '[BackendManager] Failed to read settings.json for mitm config:',
+          err instanceof Error ? err.message : String(err),
+        );
+      }
     }
 
     return { host: defaultHost, port: defaultPort };
@@ -69,8 +89,8 @@ export class BackendManager {
     this.validator = new ResourceValidator(getProjectRoot());
   }
 
-  public getResourceStatus(): ResourceStatus {
-    return this.validator.validate();
+  public async getResourceStatus(): Promise<ResourceStatus> {
+    return await this.validator.validate();
   }
 
   public start() {
@@ -231,7 +251,7 @@ export class BackendManager {
     if (!this.isRunning()) return;
 
     try {
-      const { host, port } = this.getBackendConfig();
+      const { host, port } = await this.getBackendConfig();
       await fetch(`http://${host}:${port}/api/shutdown`, {
         method: 'POST',
         signal: AbortSignal.timeout(BACKEND_SHUTDOWN_API_TIMEOUT_MS),
diff --git a/electron/game-handler.ts b/electron/game-handler.ts
@@ -1,6 +1,42 @@
 import type { Protocol } from 'devtools-protocol';
 import type { WebContents } from 'electron';
 
+export type BackendIngestPayload =
+  | {
+      source: 'electron';
+      type: 'debugger_detached';
+      reason: string;
+      time: number;
+    }
+  | {
+      source: 'electron';
+      type: 'websocket_created';
+      requestId: string;
+      url: string;
+      time: number;
+    }
+  | {
+      source: 'electron';
+      type: 'websocket_closed';
+      requestId: string;
+      time: number;
+    }
+  | {
+      source: 'electron';
+      type: 'websocket';
+      requestId: string;
+      direction: 'inbound' | 'outbound';
+      data: string;
+      opcode: number;
+      time: number;
+    }
+  | {
+      source: 'electron';
+      type: 'liqi_definition';
+      data: string;
+      url: string;
+    };
+
 export class GameHandler {
   private attached = false;
   private readonly BACKEND_API: string;
@@ -146,7 +182,7 @@ export class GameHandler {
       }
     }
 
-    const payload = {
+    const payload: BackendIngestPayload = {
       source: 'electron',
       type: 'websocket',
       requestId: requestId,
@@ -183,13 +219,16 @@ export class GameHandler {
     }
   }
 
-  private sendToBackend(data: unknown) {
+  private sendToBackend(data: BackendIngestPayload) {
     fetch(this.BACKEND_API, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify(data),
     }).catch((err) => {
-      console.error('[GameHandler] Failed to send to backend:', err);
+      console.error(
+        '[GameHandler] Failed to send to backend:',
+        err instanceof Error ? err.message : String(err),
+      );
     });
   }
 }
diff --git a/electron/ipc-handlers.ts b/electron/ipc-handlers.ts
@@ -106,7 +106,7 @@ export function registerIpcHandlers(windowManager: WindowManager, backendManager
   });
 
   // Get backend host and port from settings
-  ipcMain.handle('get-backend-config', () => {
-    return backendManager.getBackendConfig();
+  ipcMain.handle('get-backend-config', async () => {
+    return await backendManager.getBackendConfig();
   });
 }
diff --git a/electron/main.ts b/electron/main.ts
@@ -33,7 +33,7 @@ app.whenReady().then(async () => {
 
   // 4. Try to detect backend readiness (informative only, don't block the UI further)
   try {
-    const { host, port } = backendManager.getBackendConfig();
+    const { host, port } = await backendManager.getBackendConfig();
     for (let i = 0; i < BACKEND_STARTUP_CHECK_RETRIES; i++) {
       try {
         const controller = new AbortController();
diff --git a/electron/resource-validator.ts b/electron/resource-validator.ts
@@ -1,4 +1,4 @@
-import fs from 'fs';
+import fs from 'fs/promises';
 import path from 'path';
 
 export interface ResourceStatus {
@@ -11,12 +11,14 @@ export interface ResourceStatus {
 export class ResourceValidator {
   constructor(private projectRoot: string) {}
 
-  public validate(): ResourceStatus {
+  public async validate(): Promise<ResourceStatus> {
     const libPath = path.join(this.projectRoot, 'lib');
     const modelsPath = path.join(this.projectRoot, 'models');
 
-    const libExists = this.checkLib(libPath);
-    const modelsExists = this.checkModels(modelsPath);
+    const [libExists, modelsExists] = await Promise.all([
+      this.checkLib(libPath),
+      this.checkModels(modelsPath),
+    ]);
 
     const missingCritical: string[] = [];
     const missingOptional: string[] = [];
@@ -37,21 +39,27 @@ export class ResourceValidator {
     };
   }
 
-  private checkLib(dirPath: string): boolean {
-    if (!fs.existsSync(dirPath)) return false;
-    const files = fs.readdirSync(dirPath);
-    // On Windows look for .pyd, otherwise .so
-    const isWin = process.platform === 'win32';
-    const libRiichi = isWin ? 'libriichi.pyd' : 'libriichi.so';
-    const libRiichi3p = isWin ? 'libriichi3p.pyd' : 'libriichi3p.so';
+  private async checkLib(dirPath: string): Promise<boolean> {
+    try {
+      const files = await fs.readdir(dirPath);
+      // On Windows look for .pyd, otherwise .so
+      const isWin = process.platform === 'win32';
+      const libRiichi = isWin ? 'libriichi.pyd' : 'libriichi.so';
+      const libRiichi3p = isWin ? 'libriichi3p.pyd' : 'libriichi3p.so';
 
-    return files.includes(libRiichi) && files.includes(libRiichi3p);
+      return files.includes(libRiichi) && files.includes(libRiichi3p);
+    } catch {
+      return false;
+    }
   }
 
-  private checkModels(dirPath: string): boolean {
-    if (!fs.existsSync(dirPath)) return false;
-    const files = fs.readdirSync(dirPath);
-    // Look for at least one .pth file
-    return files.some((f) => f.endsWith('.pth'));
+  private async checkModels(dirPath: string): Promise<boolean> {
+    try {
+      const files = await fs.readdir(dirPath);
+      // Look for at least one .pth file
+      return files.some((f) => f.endsWith('.pth'));
+    } catch {
+      return false;
+    }
   }
 }
diff --git a/electron/window-manager.ts b/electron/window-manager.ts
@@ -258,7 +258,7 @@ export class WindowManager {
 
     // Set up proxy if using MITM
     if (useMitm) {
-      const mitm = this.backendManager.getMitmConfig();
+      const mitm = await this.backendManager.getMitmConfig();
       const proxyRules = `http://${mitm.host}:${mitm.port}`;
       console.log(`[WindowManager] Setting game window proxy to: ${proxyRules}`);
       await this.gameWindow.webContents.session.setProxy({
@@ -275,7 +275,7 @@ export class WindowManager {
           this.gameWindow.webContents &&
           !this.gameWindow.webContents.isDestroyed()
         ) {
-          const backend = this.backendManager.getBackendConfig();
+          const backend = await this.backendManager.getBackendConfig();
           const apiBase = `http://${backend.host}:${backend.port}`;
           this.gameHandler = new GameHandler(this.gameWindow.webContents, apiBase);
           this.gameHandler.attach(); // Do not await, let it happen in parallel with loadURL

Original file line number	Diff line number	Diff line change
`@@ -106,7 +106,7 @@ export function registerIpcHandlers(windowManager: WindowManager, backendManager`
`106`	`106`	`});`
`107`	`107`
`108`	`108`	`// Get backend host and port from settings`
`109`		`- ipcMain.handle('get-backend-config', () => {`
`110`		`- return backendManager.getBackendConfig();`
	`109`	`+ ipcMain.handle('get-backend-config', async () => {`
	`110`	`+ return await backendManager.getBackendConfig();`
`111`	`111`	`});`
`112`	`112`	`}`