@todesktop/plugin-recall 1.0.2 → 1.0.4

package/src/main.ts

@@ -1,6 +1,6 @@
 /**
  * ToDesktop Recall Desktop SDK Plugin - Main Process
- * 
+ *
  * This file runs in Electron's main process and handles:
  * - Recall Desktop SDK integration and lifecycle management
  * - IPC communication with renderer processes
@@ -8,11 +8,11 @@
  * - Event forwarding from SDK to frontend
  */
 
-import { ipcMain, BrowserWindow } from 'electron';
-import { 
-  IPC_CHANNELS, 
-  ApiResponse, 
-  PluginStatus, 
+import { ipcMain } from "electron";
+import {
+  IPC_CHANNELS,
+  ApiResponse,
+  PluginStatus,
   RecallSdkError,
   StartRecordingRequest,
   StopRecordingRequest,
@@ -23,235 +23,143 @@ import {
   SdkInitOptions,
   PrepareDesktopAudioResponse,
   RecallSdkConfig,
-  RecallSdkEventType
-} from './shared';
-import { recallSdkStore } from './store';
-
-// Import Recall SDK, with a dev-friendly fallback mock if the package isn't installed
-type RecallAiSdk = {
-  init(options: any): Promise<null> | void;
-  shutdown(): Promise<null> | void;
-  startRecording(config: { windowId: string; uploadToken: string }): Promise<null> | void;
-  stopRecording(config: { windowId: string }): Promise<null> | void;
-  pauseRecording(config: { windowId: string }): Promise<null> | void;
-  resumeRecording(config: { windowId: string }): Promise<null> | void;
-  uploadRecording(config: { windowId: string }): Promise<null> | void;
-  prepareDesktopAudioRecording(): Promise<string>;
-  requestPermission(permission: PermissionType): Promise<null> | void;
-  addEventListener<T extends RecallSdkEventType>(type: T, callback: (event: any) => void): void;
-};
-
-let RecallAiSdk: RecallAiSdk;
-try {
-  // eslint-disable-next-line @typescript-eslint/no-var-requires
-  const mod = require('@recallai/desktop-sdk');
-  RecallAiSdk = (mod && mod.default) ? mod.default : mod;
-} catch {
-  RecallAiSdk = {
-    init: async (config: any) => { console.log('RecallAiSdk.init called with:', config); return null; },
-    shutdown: async () => { console.log('RecallAiSdk.shutdown called'); return null; },
-    startRecording: async (params: any) => { console.log('RecallAiSdk.startRecording called with:', params); return null; },
-    stopRecording: async (params: any) => { console.log('RecallAiSdk.stopRecording called with:', params); return null; },
-    pauseRecording: async (params: any) => { console.log('RecallAiSdk.pauseRecording called with:', params); return null; },
-    resumeRecording: async (params: any) => { console.log('RecallAiSdk.resumeRecording called with:', params); return null; },
-    uploadRecording: async (params: any) => { console.log('RecallAiSdk.uploadRecording called with:', params); return null; },
-    prepareDesktopAudioRecording: async () => { console.log('RecallAiSdk.prepareDesktopAudioRecording called'); return 'mock-window-id'; },
-    requestPermission: async (permission: PermissionType) => { console.log(`RecallAiSdk.requestPermission called for: ${permission}`); return null; },
-    addEventListener: (_eventType: string) => { /* no-op in mock */ },
-  } as RecallAiSdk;
-}
+  RecallSdkEventType,
+  PluginContext,
+} from "./shared";
+import { recallSdkStore, setPluginContext } from "./store";
+import RecallAiSdk from "@recallai/desktop-sdk";
 
 class RecallDesktopMain {
-  private version = '1.0.0';
+  private version = "1.0.0";
   private isInitialized = false;
-  private subscriptions: Map<RecallSdkEventType, Map<number, number>> = new Map();
+  private subscriptions: Map<RecallSdkEventType, Map<number, number>> =
+    new Map();
   private trackedWebContents = new Map<number, Electron.WebContents>();
+  private sdkEventHandlers = new Map<RecallSdkEventType, (evt: any) => void>();
+  private readonly eventSideEffects: Partial<
+    Record<RecallSdkEventType, (evt: any) => void>
+  > = {
+    shutdown: () => {
+      recallSdkStore.clearState();
+    },
+  };
 
   async initialize(): Promise<void> {
+    if (this.isInitialized) {
+      return;
+    }
+
+    if (!recallSdkStore.isEnabled()) {
+      console.log("RecallDesktopMain: Plugin is disabled");
+      return;
+    }
+
     try {
       // Initialize plugin store
       await recallSdkStore.initialize();
 
-      // Load configuration from ToDesktop preferences
-      // In a real implementation, this would integrate with ToDesktop's preference system
-      this.loadPreferences();
-
       // Register IPC handlers
       this.registerIpcHandlers();
 
-      // Initialize SDK if plugin is enabled
-      if (recallSdkStore.isEnabled()) {
-        await this.initializeSdk();
-      }
+      // SDK will now be initialized on-demand via IPC
 
       this.isInitialized = true;
-      console.log('RecallDesktopMain: Main process initialized');
+      console.log("RecallDesktopMain: Main process initialized");
     } catch (error) {
-      console.error('RecallDesktopMain: Failed to initialize main process:', error);
+      console.error(
+        "RecallDesktopMain: Failed to initialize main process:",
+        error
+      );
       throw error;
     }
   }
 
-  private loadPreferences(): void {
-    // In a real implementation, this would load from ToDesktop's preference system
-    // For now, we'll use defaults
-    const preferences = {
-      enabled: true,
-      apiUrl: 'https://us-east-1.recall.ai',
-      requestPermissionsOnStartup: true,
-    };
-    
-    recallSdkStore.loadFromPreferences(preferences);
-  }
-
   private async initializeSdk(): Promise<void> {
     try {
       const config = recallSdkStore.getConfig();
-      
+
       const sdkOptions: SdkInitOptions = {
         apiUrl: config.apiUrl,
         acquirePermissionsOnStartup: config.requestPermissionsOnStartup
-          ? ['accessibility', 'screen-capture', 'microphone', 'system-audio']
+          ? ["accessibility", "screen-capture", "microphone", "system-audio"]
           : undefined,
         restartOnError: true,
       };
 
-      // Initialize the Recall SDK
-      await (RecallAiSdk.init as any)(sdkOptions);
+      console.log("RecallDesktopMain: SDK options:", sdkOptions);
 
-      // Set up event listeners
-      this.setupSdkEventListeners();
+      // Initialize the Recall SDK
+      await RecallAiSdk.init(sdkOptions);
 
       recallSdkStore.setSdkInitialized(true);
-      console.log('RecallDesktopMain: SDK initialized successfully');
+      console.log("RecallDesktopMain: SDK initialized successfully");
     } catch (error) {
-      console.error('RecallDesktopMain: Failed to initialize SDK:', error);
-      throw new RecallSdkError('SDK initialization failed', 'SDK_INIT_ERROR');
+      console.error("RecallDesktopMain: Failed to initialize SDK:", error);
+      throw new RecallSdkError("SDK initialization failed", "SDK_INIT_ERROR");
     }
   }
 
-  private setupSdkEventListeners(): void {
-    const broadcast = (type: RecallSdkEventType, data: any) => {
-      const channel = `recall-desktop:event:${type}`;
-      const subs = this.subscriptions.get(type);
-      if (!subs) return;
-      subs.forEach((_count, wcId) => {
-        const wc = this.trackedWebContents.get(wcId);
-        if (!wc) return;
-        try {
-          wc.send(channel, data);
-        } catch (err) {
-          console.error('RecallDesktopMain: Failed to send event to webContents', wcId, err);
-        }
-      });
-    };
-
-    // Permissions granted
-    RecallAiSdk.addEventListener('permissions-granted', (evt) => {
-      console.log('RecallDesktopMain: Permissions granted');
-      const type: RecallSdkEventType = 'permissions-granted';
-      recallSdkStore.emitEvent({ type, data: evt });
-      broadcast(type, evt);
-    });
-
-    // Meeting detected
-    RecallAiSdk.addEventListener('meeting-detected', (evt) => {
-      console.log('RecallDesktopMain: Meeting detected:', evt);
-      const meeting = evt.window;
-      recallSdkStore.addMeeting(meeting);
-      const type: RecallSdkEventType = 'meeting-detected';
-      recallSdkStore.emitEvent({ type, data: evt });
-      broadcast(type, evt);
-    });
-
-    // SDK state change
-    RecallAiSdk.addEventListener('sdk-state-change', (evt) => {
-      console.log('RecallDesktopMain: SDK state change:', evt);
-      const state = evt.sdk.state.code;
-      recallSdkStore.setSdkState(state);
-      const type: RecallSdkEventType = 'sdk-state-change';
-      recallSdkStore.emitEvent({ type, data: evt });
-      broadcast(type, evt);
-    });
-
-    // Recording started
-    RecallAiSdk.addEventListener('recording-started', (evt) => {
-      console.log('RecallDesktopMain: Recording started:', evt);
-      const type: RecallSdkEventType = 'recording-started';
-      recallSdkStore.emitEvent({ type, data: evt });
-      broadcast(type, evt);
-    });
-
-    // Recording ended
-    RecallAiSdk.addEventListener('recording-ended', (evt) => {
-      console.log('RecallDesktopMain: Recording ended:', evt);
-      recallSdkStore.stopRecording(evt.window.id);
-      const type: RecallSdkEventType = 'recording-ended';
-      recallSdkStore.emitEvent({ type, data: evt });
-      broadcast(type, evt);
+  private broadcastEvent(type: RecallSdkEventType, data: any): void {
+    const channel = `recall-desktop:event:${type}`;
+    const subs = this.subscriptions.get(type);
+    if (!subs) return;
+    subs.forEach((_count, wcId) => {
+      const wc = this.trackedWebContents.get(wcId);
+      if (!wc) return;
+      try {
+        wc.send(channel, data);
+      } catch (err) {
+        console.error(
+          "RecallDesktopMain: Failed to send event to webContents",
+          wcId,
+          err
+        );
+      }
     });
+  }
 
-    // Meeting closed
-    RecallAiSdk.addEventListener('meeting-closed', (evt) => {
-      console.log('RecallDesktopMain: Meeting closed:', evt);
-      recallSdkStore.removeMeeting(evt.window.id);
-      const type: RecallSdkEventType = 'meeting-closed';
-      recallSdkStore.emitEvent({ type, data: evt });
-      broadcast(type, evt);
-    });
+  private ensureSdkListener(eventType: RecallSdkEventType): void {
+    if (this.sdkEventHandlers.has(eventType)) {
+      return;
+    }
 
-    // Upload progress
-    RecallAiSdk.addEventListener('upload-progress', (evt) => {
-      console.log(`RecallDesktopMain: Upload progress: ${evt.progress}%`);
-      const type: RecallSdkEventType = 'upload-progress';
-      recallSdkStore.emitEvent({ type, data: evt });
-      broadcast(type, evt);
-    });
+    const handler = (evt: any) => {
+      this.handleSdkEvent(eventType, evt);
+    };
 
-    // Other events
-    (['realtime-event', 'meeting-updated', 'media-capture-status', 'participant-capture-status'] as RecallSdkEventType[])
-      .forEach(eventType => {
-        RecallAiSdk.addEventListener(eventType, (evt) => {
-          console.log(`RecallDesktopMain: ${eventType}:`, evt);
-          recallSdkStore.emitEvent({ type: eventType, data: evt });
-          broadcast(eventType, evt);
-        });
-      });
+    this.sdkEventHandlers.set(eventType, handler);
+    RecallAiSdk.addEventListener(eventType as any, handler);
+  }
 
-    // Permission status
-    RecallAiSdk.addEventListener('permission-status', (evt) => {
-      console.log('RecallDesktopMain: Permission status:', evt);
-      recallSdkStore.setPermissionStatus(evt.permission, evt.status);
-      const type: RecallSdkEventType = 'permission-status';
-      recallSdkStore.emitEvent({ type, data: evt });
-      broadcast(type, evt);
-    });
+  private handleSdkEvent(eventType: RecallSdkEventType, evt: any): void {
+    if (eventType === "error") {
+      console.error("RecallDesktopMain: SDK error:", evt);
+    } else {
+      console.log(`RecallDesktopMain: ${eventType}`, evt);
+    }
 
-    // Error handling
-    RecallAiSdk.addEventListener('error', (evt) => {
-      console.error('RecallDesktopMain: SDK error:', evt);
-      const type: RecallSdkEventType = 'error';
-      recallSdkStore.emitEvent({ type, data: evt });
-      broadcast(type, evt);
-    });
+    const sideEffect = this.eventSideEffects[eventType];
+    if (sideEffect) {
+      try {
+        sideEffect(evt);
+      } catch (error) {
+        console.error(
+          "RecallDesktopMain: Side effect failed for",
+          eventType,
+          error
+        );
+      }
+    }
 
-    // Shutdown
-    RecallAiSdk.addEventListener('shutdown', (evt) => {
-      console.log('RecallDesktopMain: SDK shutdown:', evt);
-      recallSdkStore.setSdkInitialized(false);
-      const type: RecallSdkEventType = 'shutdown';
-      recallSdkStore.emitEvent({ type, data: evt });
-      broadcast(type, evt);
-    });
+    this.broadcastEvent(eventType, evt);
   }
 
-
   private registerIpcHandlers(): void {
     const addDestroyedCleanup = (wc: Electron.WebContents) => {
       const id = wc.id;
       if (this.trackedWebContents.has(id)) return;
       this.trackedWebContents.set(id, wc);
-      wc.once('destroyed', () => {
+      wc.once("destroyed", () => {
         // Remove this wc from all subscriptions
         this.subscriptions.forEach((map) => {
           map.delete(id);
@@ -261,75 +169,91 @@ class RecallDesktopMain {
     };
 
     // Subscribe to events
-    ipcMain.handle(IPC_CHANNELS.SUBSCRIBE_EVENTS, async (event, eventType: RecallSdkEventType): Promise<ApiResponse> => {
-      try {
-        const wc = event.sender;
-        addDestroyedCleanup(wc);
-        let map = this.subscriptions.get(eventType);
-        if (!map) {
-          map = new Map();
-          this.subscriptions.set(eventType, map);
+    ipcMain.handle(
+      IPC_CHANNELS.SUBSCRIBE_EVENTS,
+      async (event, eventType: RecallSdkEventType): Promise<ApiResponse> => {
+        try {
+          const wc = event.sender;
+          addDestroyedCleanup(wc);
+          let map = this.subscriptions.get(eventType);
+          if (!map) {
+            map = new Map();
+            this.subscriptions.set(eventType, map);
+          }
+          const id = wc.id;
+          const prev = map.get(id) || 0;
+          map.set(id, prev + 1);
+          this.ensureSdkListener(eventType);
+          return { success: true, message: `Subscribed to ${eventType}` };
+        } catch (error) {
+          console.error("RecallDesktopMain: subscribe-events failed", error);
+          return { success: false, message: "Failed to subscribe to events" };
         }
-        const id = wc.id;
-        const prev = map.get(id) || 0;
-        map.set(id, prev + 1);
-        return { success: true, message: `Subscribed to ${eventType}` };
-      } catch (error) {
-        console.error('RecallDesktopMain: subscribe-events failed', error);
-        return { success: false, message: 'Failed to subscribe to events' };
       }
-    });
+    );
 
     // Unsubscribe from events
-    ipcMain.handle(IPC_CHANNELS.UNSUBSCRIBE_EVENTS, async (event, eventType: RecallSdkEventType): Promise<ApiResponse> => {
-      try {
-        const wc = event.sender;
-        const map = this.subscriptions.get(eventType);
-        if (map) {
-          const id = wc.id;
-          const prev = map.get(id) || 0;
-          if (prev <= 1) map.delete(id);
-          else map.set(id, prev - 1);
+    ipcMain.handle(
+      IPC_CHANNELS.UNSUBSCRIBE_EVENTS,
+      async (event, eventType: RecallSdkEventType): Promise<ApiResponse> => {
+        try {
+          const wc = event.sender;
+          const map = this.subscriptions.get(eventType);
+          if (map) {
+            const id = wc.id;
+            const prev = map.get(id) || 0;
+            if (prev <= 1) map.delete(id);
+            else map.set(id, prev - 1);
+          }
+          return { success: true, message: `Unsubscribed from ${eventType}` };
+        } catch (error) {
+          console.error("RecallDesktopMain: unsubscribe-events failed", error);
+          return {
+            success: false,
+            message: "Failed to unsubscribe from events",
+          };
         }
-        return { success: true, message: `Unsubscribed from ${eventType}` };
-      } catch (error) {
-        console.error('RecallDesktopMain: unsubscribe-events failed', error);
-        return { success: false, message: 'Failed to unsubscribe from events' };
       }
-    });
+    );
     // Initialize SDK
     ipcMain.handle(IPC_CHANNELS.INIT_SDK, async (): Promise<ApiResponse> => {
       try {
         if (!recallSdkStore.isEnabled()) {
-          throw new RecallSdkError('Plugin is disabled', 'PLUGIN_DISABLED');
+          throw new RecallSdkError("Plugin is disabled", "PLUGIN_DISABLED");
         }
 
         if (recallSdkStore.isSdkInitialized()) {
-          return { success: true, message: 'SDK already initialized' };
+          return { success: true, message: "SDK already initialized" };
         }
 
         await this.initializeSdk();
-        return { success: true, message: 'SDK initialized successfully' };
+        return { success: true, message: "SDK initialized successfully" };
       } catch (error) {
-        console.error('RecallDesktopMain: SDK initialization failed:', error);
+        console.error("RecallDesktopMain: SDK initialization failed:", error);
         return {
           success: false,
-          message: error instanceof RecallSdkError ? error.message : 'SDK initialization failed'
+          message:
+            error instanceof RecallSdkError
+              ? error.message
+              : "SDK initialization failed",
         };
       }
     });
 
     // Shutdown SDK
-    ipcMain.handle(IPC_CHANNELS.SHUTDOWN_SDK, async (): Promise<ApiResponse> => {
-      try {
-        await (RecallAiSdk.shutdown as any)();
-        recallSdkStore.clearState();
-        return { success: true, message: 'SDK shutdown successfully' };
-      } catch (error) {
-        console.error('RecallDesktopMain: SDK shutdown failed:', error);
-        return { success: false, message: 'SDK shutdown failed' };
+    ipcMain.handle(
+      IPC_CHANNELS.SHUTDOWN_SDK,
+      async (): Promise<ApiResponse> => {
+        try {
+          await (RecallAiSdk.shutdown as any)();
+          recallSdkStore.clearState();
+          return { success: true, message: "SDK shutdown successfully" };
+        } catch (error) {
+          console.error("RecallDesktopMain: SDK shutdown failed:", error);
+          return { success: false, message: "SDK shutdown failed" };
+        }
       }
-    });
+    );
 
     // Get plugin status
     ipcMain.handle(IPC_CHANNELS.GET_STATUS, async (): Promise<PluginStatus> => {
@@ -338,137 +262,200 @@ class RecallDesktopMain {
         sdkInitialized: recallSdkStore.isSdkInitialized(),
         version: this.version,
         config: recallSdkStore.getConfig(),
-        sdkState: recallSdkStore.getSdkState(),
-        permissions: recallSdkStore.getPermissions()
       };
     });
 
     // Start recording
-    ipcMain.handle(IPC_CHANNELS.START_RECORDING, async (event, request: StartRecordingRequest): Promise<ApiResponse> => {
-      try {
-        if (!recallSdkStore.isSdkInitialized()) {
-          throw new RecallSdkError('SDK not initialized', 'SDK_NOT_INITIALIZED');
+    ipcMain.handle(
+      IPC_CHANNELS.START_RECORDING,
+      async (event, request: StartRecordingRequest): Promise<ApiResponse> => {
+        try {
+          if (!recallSdkStore.isSdkInitialized()) {
+            throw new RecallSdkError(
+              "SDK not initialized",
+              "SDK_NOT_INITIALIZED"
+            );
+          }
+
+          await (RecallAiSdk.startRecording as any)({
+            windowId: request.windowId,
+            uploadToken: request.uploadToken,
+          });
+          return { success: true, message: "Recording started successfully" };
+        } catch (error) {
+          console.error("RecallDesktopMain: Start recording failed:", error);
+          return {
+            success: false,
+            message:
+              error instanceof RecallSdkError
+                ? error.message
+                : "Failed to start recording",
+          };
         }
-
-        await (RecallAiSdk.startRecording as any)({
-          windowId: request.windowId,
-          uploadToken: request.uploadToken
-        });
-
-        recallSdkStore.startRecording(request.windowId, request.uploadToken);
-        return { success: true, message: 'Recording started successfully' };
-      } catch (error) {
-        console.error('RecallDesktopMain: Start recording failed:', error);
-        return {
-          success: false,
-          message: error instanceof RecallSdkError ? error.message : 'Failed to start recording'
-        };
       }
-    });
+    );
 
     // Stop recording
-    ipcMain.handle(IPC_CHANNELS.STOP_RECORDING, async (event, request: StopRecordingRequest): Promise<ApiResponse> => {
-      try {
-        await (RecallAiSdk.stopRecording as any)({ windowId: request.windowId });
-        recallSdkStore.stopRecording(request.windowId);
-        return { success: true, message: 'Recording stopped successfully' };
-      } catch (error) {
-        console.error('RecallDesktopMain: Stop recording failed:', error);
-        return { success: false, message: 'Failed to stop recording' };
+    ipcMain.handle(
+      IPC_CHANNELS.STOP_RECORDING,
+      async (event, request: StopRecordingRequest): Promise<ApiResponse> => {
+        try {
+          await (RecallAiSdk.stopRecording as any)({
+            windowId: request.windowId,
+          });
+          return { success: true, message: "Recording stopped successfully" };
+        } catch (error) {
+          console.error("RecallDesktopMain: Stop recording failed:", error);
+          return { success: false, message: "Failed to stop recording" };
+        }
       }
-    });
+    );
 
     // Pause recording
-    ipcMain.handle(IPC_CHANNELS.PAUSE_RECORDING, async (event, request: PauseRecordingRequest): Promise<ApiResponse> => {
-      try {
-        await (RecallAiSdk.pauseRecording as any)({ windowId: request.windowId });
-        return { success: true, message: 'Recording paused successfully' };
-      } catch (error) {
-        console.error('RecallDesktopMain: Pause recording failed:', error);
-        return { success: false, message: 'Failed to pause recording' };
+    ipcMain.handle(
+      IPC_CHANNELS.PAUSE_RECORDING,
+      async (event, request: PauseRecordingRequest): Promise<ApiResponse> => {
+        try {
+          await (RecallAiSdk.pauseRecording as any)({
+            windowId: request.windowId,
+          });
+          return { success: true, message: "Recording paused successfully" };
+        } catch (error) {
+          console.error("RecallDesktopMain: Pause recording failed:", error);
+          return { success: false, message: "Failed to pause recording" };
+        }
       }
-    });
+    );
 
     // Resume recording
-    ipcMain.handle(IPC_CHANNELS.RESUME_RECORDING, async (event, request: ResumeRecordingRequest): Promise<ApiResponse> => {
-      try {
-        await (RecallAiSdk.resumeRecording as any)({ windowId: request.windowId });
-        return { success: true, message: 'Recording resumed successfully' };
-      } catch (error) {
-        console.error('RecallDesktopMain: Resume recording failed:', error);
-        return { success: false, message: 'Failed to resume recording' };
+    ipcMain.handle(
+      IPC_CHANNELS.RESUME_RECORDING,
+      async (event, request: ResumeRecordingRequest): Promise<ApiResponse> => {
+        try {
+          await (RecallAiSdk.resumeRecording as any)({
+            windowId: request.windowId,
+          });
+          return { success: true, message: "Recording resumed successfully" };
+        } catch (error) {
+          console.error("RecallDesktopMain: Resume recording failed:", error);
+          return { success: false, message: "Failed to resume recording" };
+        }
       }
-    });
+    );
 
     // Upload recording
-    ipcMain.handle(IPC_CHANNELS.UPLOAD_RECORDING, async (event, request: UploadRecordingRequest): Promise<ApiResponse> => {
-      try {
-        await (RecallAiSdk.uploadRecording as any)({ windowId: request.windowId });
-        return { success: true, message: 'Recording upload started successfully' };
-      } catch (error) {
-        console.error('RecallDesktopMain: Upload recording failed:', error);
-        return { success: false, message: 'Failed to upload recording' };
+    ipcMain.handle(
+      IPC_CHANNELS.UPLOAD_RECORDING,
+      async (event, request: UploadRecordingRequest): Promise<ApiResponse> => {
+        try {
+          await (RecallAiSdk.uploadRecording as any)({
+            windowId: request.windowId,
+          });
+          return {
+            success: true,
+            message: "Recording upload started successfully",
+          };
+        } catch (error) {
+          console.error("RecallDesktopMain: Upload recording failed:", error);
+          return { success: false, message: "Failed to upload recording" };
+        }
       }
-    });
+    );
 
     // Prepare desktop audio recording
-    ipcMain.handle(IPC_CHANNELS.PREPARE_DESKTOP_AUDIO, async (): Promise<ApiResponse<PrepareDesktopAudioResponse>> => {
-      try {
-        const windowId = await (RecallAiSdk.prepareDesktopAudioRecording as any)();
-        return { 
-          success: true, 
-          message: 'Desktop audio recording prepared successfully',
-          data: { windowId }
-        };
-      } catch (error) {
-        console.error('RecallDesktopMain: Prepare desktop audio failed:', error);
-        return { success: false, message: 'Failed to prepare desktop audio recording' };
+    ipcMain.handle(
+      IPC_CHANNELS.PREPARE_DESKTOP_AUDIO,
+      async (): Promise<ApiResponse<PrepareDesktopAudioResponse>> => {
+        try {
+          const windowId = await (
+            RecallAiSdk.prepareDesktopAudioRecording as any
+          )();
+          return {
+            success: true,
+            message: "Desktop audio recording prepared successfully",
+            data: { windowId },
+          };
+        } catch (error) {
+          console.error(
+            "RecallDesktopMain: Prepare desktop audio failed:",
+            error
+          );
+          return {
+            success: false,
+            message: "Failed to prepare desktop audio recording",
+          };
+        }
       }
-    });
+    );
 
     // Request permission
-    ipcMain.handle(IPC_CHANNELS.REQUEST_PERMISSION, async (event, permission: PermissionType): Promise<ApiResponse> => {
-      try {
-        await (RecallAiSdk.requestPermission as any)(permission);
-        return { success: true, message: `Permission request sent for ${permission}` };
-      } catch (error) {
-        console.error('RecallDesktopMain: Request permission failed:', error);
-        return { success: false, message: 'Failed to request permission' };
+    ipcMain.handle(
+      IPC_CHANNELS.REQUEST_PERMISSION,
+      async (event, permission: PermissionType): Promise<ApiResponse> => {
+        try {
+          await (RecallAiSdk.requestPermission as any)(permission);
+          return {
+            success: true,
+            message: `Permission request sent for ${permission}`,
+          };
+        } catch (error) {
+          console.error("RecallDesktopMain: Request permission failed:", error);
+          return { success: false, message: "Failed to request permission" };
+        }
       }
-    });
+    );
 
     // Set configuration
-    ipcMain.handle(IPC_CHANNELS.SET_CONFIG, async (event, config: Partial<RecallSdkConfig>): Promise<ApiResponse> => {
-      try {
-        recallSdkStore.setConfig(config);
-        
-        // If SDK settings changed and SDK is initialized, reinitialize
-        if (recallSdkStore.isSdkInitialized() && (config.apiUrl || config.requestPermissionsOnStartup !== undefined)) {
-          console.log('RecallDesktopMain: Reinitializing SDK due to configuration change');
-          await (RecallAiSdk.shutdown as any)();
-          await this.initializeSdk();
+    ipcMain.handle(
+      IPC_CHANNELS.SET_CONFIG,
+      async (event, config: Partial<RecallSdkConfig>): Promise<ApiResponse> => {
+        try {
+          recallSdkStore.setConfig(config);
+
+          // If SDK settings changed and SDK is initialized, reinitialize
+          if (
+            recallSdkStore.isSdkInitialized() &&
+            (config.apiUrl || config.requestPermissionsOnStartup !== undefined)
+          ) {
+            console.log(
+              "RecallDesktopMain: Reinitializing SDK due to configuration change"
+            );
+            await (RecallAiSdk.shutdown as any)();
+            await this.initializeSdk();
+          }
+
+          return {
+            success: true,
+            message: "Configuration updated successfully",
+          };
+        } catch (error) {
+          console.error(
+            "RecallDesktopMain: Failed to set configuration:",
+            error
+          );
+          return { success: false, message: "Failed to update configuration" };
         }
-        
-        return { success: true, message: 'Configuration updated successfully' };
-      } catch (error) {
-        console.error('RecallDesktopMain: Failed to set configuration:', error);
-        return { success: false, message: 'Failed to update configuration' };
       }
-    });
+    );
 
     // Get configuration
-    ipcMain.handle(IPC_CHANNELS.GET_CONFIG, async (): Promise<ApiResponse<RecallSdkConfig>> => {
-      return { 
-        success: true, 
-        message: 'Configuration retrieved successfully',
-        data: recallSdkStore.getConfig()
-      };
-    });
+    ipcMain.handle(
+      IPC_CHANNELS.GET_CONFIG,
+      async (): Promise<ApiResponse<RecallSdkConfig>> => {
+        return {
+          success: true,
+          message: "Configuration retrieved successfully",
+          data: recallSdkStore.getConfig(),
+        };
+      }
+    );
   }
 }
 
 // Initialize plugin
-const recallDesktopMain = new RecallDesktopMain();
-recallDesktopMain.initialize().catch(console.error);
+export const recallDesktopMain = new RecallDesktopMain();
 
-export default recallDesktopMain;
+export default (context: PluginContext): void => {
+  setPluginContext(context);
+  recallDesktopMain.initialize().catch(() => undefined);
+};