🤖 refactor: convert ExtensionMetadataService to use fs promises

Replaced synchronous fs operations with async fs/promises throughout
ExtensionMetadataService. Updated IpcMain and all callers to use static
factory methods for async initialization.

Changes:
- ExtensionMetadataService: Use fs/promises (readFile, writeFile, mkdir)
- Added ExtensionMetadataService.create() static factory method
- Made all write methods async (updateRecency, setStreaming, deleteWorkspace)
- Added IpcMain.create() static factory method for async initialization
- Updated all callers: main-desktop.ts, main-server.ts, tests/ipcMain/setup.ts, bench/headlessEnvironment.ts
- Used 'void' keyword for fire-and-forget async calls in event handlers

Benefits:
- Non-blocking I/O operations
- Consistent async patterns throughout codebase
- Better error handling potential
- No blocking main thread on file operations

Author: ammar-agent

src/bench/headlessEnvironment.ts

@@ -104,7 +104,7 @@ export async function createHeadlessEnvironment(
   const mockIpcMainModule = mockedElectron.ipcMain;
   const mockIpcRendererModule = mockedElectron.ipcRenderer;
 
-  const ipcMain = new IpcMain(config);
+  const ipcMain = await IpcMain.create(config);
   ipcMain.register(mockIpcMainModule, mockWindow);
 
   const dispose = async () => {

src/main-desktop.ts

@@ -315,7 +315,7 @@ async function loadServices(): Promise<void> {
   ]);
   /* eslint-enable no-restricted-syntax */
   config = new ConfigClass();
-  ipcMain = new IpcMainClass(config);
+  ipcMain = await IpcMainClass.create(config);
 
   loadTokenizerModules().catch((error) => {
     console.error("Failed to preload tokenizer modules:", error);

src/main-server.ts

@@ -135,26 +135,28 @@ const app = express();
 app.use(cors());
 app.use(express.json({ limit: "50mb" }));
 
-// Initialize config and IPC service
-const config = new Config();
-const ipcMainService = new IpcMain(config);
-
 // Track WebSocket clients and their subscriptions
 const clients: Clients = new Map();
 
 const mockWindow = new MockBrowserWindow(clients);
 const httpIpcMain = new HttpIpcMainAdapter(app);
 
-// Register IPC handlers
-ipcMainService.register(
-  httpIpcMain as unknown as ElectronIpcMain,
-  mockWindow as unknown as BrowserWindow
-);
-
-// Add custom endpoint for launch project (only for server mode)
-httpIpcMain.handle("server:getLaunchProject", () => {
-  return Promise.resolve(launchProjectPath);
-});
+// Initialize async services and register handlers
+(async () => {
+  // Initialize config and IPC service
+  const config = new Config();
+  const ipcMainService = await IpcMain.create(config);
+
+  // Register IPC handlers
+  ipcMainService.register(
+    httpIpcMain as unknown as ElectronIpcMain,
+    mockWindow as unknown as BrowserWindow
+  );
+
+  // Add custom endpoint for launch project (only for server mode)
+  httpIpcMain.handle("server:getLaunchProject", () => {
+    return Promise.resolve(launchProjectPath);
+  });
 
 // Serve static files from dist directory (built renderer)
 app.use(express.static(path.join(__dirname, ".")));
@@ -338,12 +340,17 @@ async function initializeProject(
   }
 }
 
-server.listen(PORT, HOST, () => {
-  console.log(`Server is running on http://${HOST}:${PORT}`);
+  // Start server after initialization
+  server.listen(PORT, HOST, () => {
+    console.log(`Server is running on http://${HOST}:${PORT}`);
 
-  // Handle --add-project flag if present
-  if (ADD_PROJECT_PATH) {
-    console.log(`Initializing project at: ${ADD_PROJECT_PATH}`);
-    void initializeProject(ADD_PROJECT_PATH, httpIpcMain);
-  }
+    // Handle --add-project flag if present
+    if (ADD_PROJECT_PATH) {
+      console.log(`Initializing project at: ${ADD_PROJECT_PATH}`);
+      void initializeProject(ADD_PROJECT_PATH, httpIpcMain);
+    }
+  });
+})().catch((error) => {
+  console.error("Failed to initialize server:", error);
+  process.exit(1);
 });

src/services/ExtensionMetadataService.ts

@@ -1,5 +1,6 @@
 import { dirname } from "path";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { existsSync } from "fs";
 import {
   type ExtensionMetadata,
   type ExtensionMetadataFile,
@@ -29,29 +30,42 @@ export class ExtensionMetadataService {
   private readonly filePath: string;
   private data: ExtensionMetadataFile;
 
-  constructor(filePath?: string) {
-    this.filePath = filePath ?? getExtensionMetadataPath();
+  private constructor(filePath: string, data: ExtensionMetadataFile) {
+    this.filePath = filePath;
+    this.data = data;
+  }
+
+  /**
+   * Create a new ExtensionMetadataService instance.
+   * Use this static factory method instead of the constructor.
+   */
+  static async create(filePath?: string): Promise<ExtensionMetadataService> {
+    const path = filePath ?? getExtensionMetadataPath();
 
     // Ensure directory exists
-    const dir = dirname(this.filePath);
+    const dir = dirname(path);
     if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
+      await mkdir(dir, { recursive: true });
     }
 
     // Load existing data or initialize
-    this.data = this.load();
+    const data = await ExtensionMetadataService.loadData(path);
+
+    const service = new ExtensionMetadataService(path, data);
 
     // Clear stale streaming flags (from crashes)
-    this.clearStaleStreaming();
+    await service.clearStaleStreaming();
+
+    return service;
   }
 
-  private load(): ExtensionMetadataFile {
-    if (!existsSync(this.filePath)) {
+  private static async loadData(filePath: string): Promise<ExtensionMetadataFile> {
+    if (!existsSync(filePath)) {
       return { version: 1, workspaces: {} };
     }
 
     try {
-      const content = readFileSync(this.filePath, "utf-8");
+      const content = await readFile(filePath, "utf-8");
       const parsed = JSON.parse(content) as ExtensionMetadataFile;
 
       // Validate structure
@@ -69,12 +83,10 @@ export class ExtensionMetadataService {
     }
   }
 
-  private save() {
+  private async save(): Promise<void> {
     try {
       const content = JSON.stringify(this.data, null, 2);
-      // Simple synchronous write - atomic enough for our use case
-      // VS Code extension only reads, never writes concurrently
-      writeFileSync(this.filePath, content, "utf-8");
+      await writeFile(this.filePath, content, "utf-8");
     } catch (error) {
       console.error("[ExtensionMetadataService] Failed to save metadata:", error);
     }
@@ -84,7 +96,7 @@ export class ExtensionMetadataService {
    * Update the recency timestamp for a workspace.
    * Call this on user messages or other interactions.
    */
-  updateRecency(workspaceId: string, timestamp: number = Date.now()) {
+  async updateRecency(workspaceId: string, timestamp: number = Date.now()): Promise<void> {
     if (!this.data.workspaces[workspaceId]) {
       this.data.workspaces[workspaceId] = {
         recency: timestamp,
@@ -94,14 +106,14 @@ export class ExtensionMetadataService {
     } else {
       this.data.workspaces[workspaceId].recency = timestamp;
     }
-    this.save();
+    await this.save();
   }
 
   /**
    * Set the streaming status for a workspace.
    * Call this when streams start/end.
    */
-  setStreaming(workspaceId: string, streaming: boolean, model?: string) {
+  async setStreaming(workspaceId: string, streaming: boolean, model?: string): Promise<void> {
     const now = Date.now();
     if (!this.data.workspaces[workspaceId]) {
       this.data.workspaces[workspaceId] = {
@@ -115,7 +127,7 @@ export class ExtensionMetadataService {
         this.data.workspaces[workspaceId].lastModel = model;
       }
     }
-    this.save();
+    await this.save();
   }
 
   /**
@@ -158,18 +170,18 @@ export class ExtensionMetadataService {
    * Delete metadata for a workspace.
    * Call this when a workspace is deleted.
    */
-  deleteWorkspace(workspaceId: string) {
+  async deleteWorkspace(workspaceId: string): Promise<void> {
     if (this.data.workspaces[workspaceId]) {
       delete this.data.workspaces[workspaceId];
-      this.save();
+      await this.save();
     }
   }
 
   /**
    * Clear all streaming flags.
    * Call this on app startup to clean up stale streaming states from crashes.
    */
-  clearStaleStreaming() {
+  async clearStaleStreaming(): Promise<void> {
     let modified = false;
     for (const entry of Object.values(this.data.workspaces)) {
       if (entry.streaming) {
@@ -178,7 +190,7 @@ export class ExtensionMetadataService {
       }
     }
     if (modified) {
-      this.save();
+      await this.save();
     }
   }
 }

src/services/ipcMain.ts

@@ -59,23 +59,46 @@ export class IpcMain {
 
   private registered = false;
 
-  constructor(config: Config) {
+  private constructor(
+    config: Config,
+    historyService: HistoryService,
+    partialService: PartialService,
+    initStateManager: InitStateManager,
+    extensionMetadata: ExtensionMetadataService,
+    aiService: AIService
+  ) {
     this.config = config;
-    this.historyService = new HistoryService(config);
-    this.partialService = new PartialService(config, this.historyService);
-    this.initStateManager = new InitStateManager(config);
-    this.extensionMetadata = new ExtensionMetadataService();
-    this.aiService = new AIService(
-      config,
-      this.historyService,
-      this.partialService,
-      this.initStateManager
-    );
+    this.historyService = historyService;
+    this.partialService = partialService;
+    this.initStateManager = initStateManager;
+    this.extensionMetadata = extensionMetadata;
+    this.aiService = aiService;
 
     // Listen to AIService events to update metadata
     this.setupMetadataListeners();
   }
 
+  /**
+   * Create a new IpcMain instance.
+   * Use this static factory method instead of the constructor.
+   */
+  static async create(config: Config): Promise<IpcMain> {
+    const historyService = new HistoryService(config);
+    const partialService = new PartialService(config, historyService);
+    const initStateManager = new InitStateManager(config);
+    const extensionMetadata = await ExtensionMetadataService.create();
+    const aiService = new AIService(config, historyService, partialService, initStateManager);
+
+    return new IpcMain(
+      config,
+      historyService,
+      partialService,
+      initStateManager,
+      extensionMetadata,
+      aiService
+    );
+  }
+
   /**
    * Setup listeners to update metadata store based on AIService events.
    * This tracks workspace recency and streaming status for VS Code extension integration.
@@ -90,14 +113,16 @@ export class IpcMain {
     // Update streaming status and recency on stream start
     this.aiService.on("stream-start", (data: unknown) => {
       if (isStreamStartEvent(data)) {
-        this.extensionMetadata.setStreaming(data.workspaceId, true, data.model);
+        // Fire and forget - don't block event handler
+        void this.extensionMetadata.setStreaming(data.workspaceId, true, data.model);
       }
     });
 
     // Clear streaming status on stream end/abort
     const handleStreamStop = (data: unknown) => {
       if (isWorkspaceEvent(data)) {
-        this.extensionMetadata.setStreaming(data.workspaceId, false);
+        // Fire and forget - don't block event handler
+        void this.extensionMetadata.setStreaming(data.workspaceId, false);
       }
     };
     this.aiService.on("stream-end", handleStreamStop);
@@ -692,8 +717,8 @@ export class IpcMain {
         try {
           const session = this.getOrCreateSession(workspaceId);
 
-          // Update recency on user message
-          this.extensionMetadata.updateRecency(workspaceId);
+          // Update recency on user message (fire and forget)
+          void this.extensionMetadata.updateRecency(workspaceId);
 
           const result = await session.sendMessage(message, options);
           if (!result.success) {
@@ -1087,8 +1112,8 @@ export class IpcMain {
         return { success: false, error: aiResult.error };
       }
 
-      // Delete workspace metadata
-      this.extensionMetadata.deleteWorkspace(workspaceId);
+      // Delete workspace metadata (fire and forget)
+      void this.extensionMetadata.deleteWorkspace(workspaceId);
 
       // Update config to remove the workspace from all projects
       const projectsConfig = this.config.loadConfigOrDefault();

tests/ipcMain/setup.ts

@@ -66,7 +66,7 @@ export async function createTestEnvironment(): Promise<TestEnvironment> {
   const mockIpcRendererModule = mocked.ipcRenderer;
 
   // Create IpcMain instance
-  const ipcMain = new IpcMain(config);
+  const ipcMain = await IpcMain.create(config);
 
   // Register handlers with mock ipcMain and window
   ipcMain.register(mockIpcMainModule, mockWindow);