@todesktop/plugin-recall 1.0.1

package/src/main.ts

@@ -0,0 +1,474 @@
+/**
+ * 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
+ * - Meeting detection and recording management
+ * - Event forwarding from SDK to frontend
+ */
+
+import { ipcMain, BrowserWindow } from 'electron';
+import { 
+  IPC_CHANNELS, 
+  ApiResponse, 
+  PluginStatus, 
+  RecallSdkError,
+  StartRecordingRequest,
+  StopRecordingRequest,
+  PauseRecordingRequest,
+  ResumeRecordingRequest,
+  UploadRecordingRequest,
+  PermissionType,
+  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;
+}
+
+class RecallDesktopMain {
+  private version = '1.0.0';
+  private isInitialized = false;
+  private subscriptions: Map<RecallSdkEventType, Map<number, number>> = new Map();
+  private trackedWebContents = new Map<number, Electron.WebContents>();
+
+  async initialize(): Promise<void> {
+    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();
+      }
+
+      this.isInitialized = true;
+      console.log('RecallDesktopMain: Main process initialized');
+    } catch (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']
+          : undefined,
+        restartOnError: true,
+      };
+
+      // Initialize the Recall SDK
+      await (RecallAiSdk.init as any)(sdkOptions);
+
+      // Set up event listeners
+      this.setupSdkEventListeners();
+
+      recallSdkStore.setSdkInitialized(true);
+      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');
+    }
+  }
+
+  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);
+    });
+
+    // 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);
+    });
+
+    // 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);
+    });
+
+    // 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);
+        });
+      });
+
+    // 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);
+    });
+
+    // Error handling
+    RecallAiSdk.addEventListener('error', (evt) => {
+      console.error('RecallDesktopMain: SDK error:', evt);
+      const type: RecallSdkEventType = 'error';
+      recallSdkStore.emitEvent({ type, data: evt });
+      broadcast(type, evt);
+    });
+
+    // 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);
+    });
+  }
+
+
+  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', () => {
+        // Remove this wc from all subscriptions
+        this.subscriptions.forEach((map) => {
+          map.delete(id);
+        });
+        this.trackedWebContents.delete(id);
+      });
+    };
+
+    // 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);
+        }
+        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);
+        }
+        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');
+        }
+
+        if (recallSdkStore.isSdkInitialized()) {
+          return { success: true, message: 'SDK already initialized' };
+        }
+
+        await this.initializeSdk();
+        return { success: true, message: 'SDK initialized successfully' };
+      } catch (error) {
+        console.error('RecallDesktopMain: SDK initialization failed:', error);
+        return {
+          success: false,
+          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' };
+      }
+    });
+
+    // Get plugin status
+    ipcMain.handle(IPC_CHANNELS.GET_STATUS, async (): Promise<PluginStatus> => {
+      return {
+        initialized: this.isInitialized,
+        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');
+        }
+
+        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' };
+      }
+    });
+
+    // 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' };
+      }
+    });
+
+    // 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' };
+      }
+    });
+
+    // 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();
+        }
+        
+        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()
+      };
+    });
+  }
+}
+
+// Initialize plugin
+const recallDesktopMain = new RecallDesktopMain();
+recallDesktopMain.initialize().catch(console.error);
+
+export default recallDesktopMain;