@todesktop/plugin-recall 1.0.3 → 1.0.4

package/dist/main.js

@@ -1,6 +1,9 @@
 'use strict';
 
+Object.defineProperty(exports, '__esModule', { value: true });
+
 var electron = require('electron');
+var RecallAiSdk = require('@recallai/desktop-sdk');
 
 /**
  * Shared types and constants for Recall Desktop SDK integration
@@ -8,32 +11,32 @@ var electron = require('electron');
 // IPC channel names - use unique namespace to avoid conflicts
 const IPC_CHANNELS = {
     // SDK lifecycle
-    INIT_SDK: 'recall-desktop:init-sdk',
-    SHUTDOWN_SDK: 'recall-desktop:shutdown-sdk',
-    GET_STATUS: 'recall-desktop:get-status',
+    INIT_SDK: "recall-desktop:init-sdk",
+    SHUTDOWN_SDK: "recall-desktop:shutdown-sdk",
+    GET_STATUS: "recall-desktop:get-status",
     // Recording management
-    START_RECORDING: 'recall-desktop:start-recording',
-    STOP_RECORDING: 'recall-desktop:stop-recording',
-    PAUSE_RECORDING: 'recall-desktop:pause-recording',
-    RESUME_RECORDING: 'recall-desktop:resume-recording',
-    UPLOAD_RECORDING: 'recall-desktop:upload-recording',
+    START_RECORDING: "recall-desktop:start-recording",
+    STOP_RECORDING: "recall-desktop:stop-recording",
+    PAUSE_RECORDING: "recall-desktop:pause-recording",
+    RESUME_RECORDING: "recall-desktop:resume-recording",
+    UPLOAD_RECORDING: "recall-desktop:upload-recording",
     // Desktop audio recording
-    PREPARE_DESKTOP_AUDIO: 'recall-desktop:prepare-desktop-audio',
+    PREPARE_DESKTOP_AUDIO: "recall-desktop:prepare-desktop-audio",
     // Permission management
-    REQUEST_PERMISSION: 'recall-desktop:request-permission',
+    REQUEST_PERMISSION: "recall-desktop:request-permission",
     // Configuration
-    SET_CONFIG: 'recall-desktop:set-config',
-    GET_CONFIG: 'recall-desktop:get-config',
+    SET_CONFIG: "recall-desktop:set-config",
+    GET_CONFIG: "recall-desktop:get-config",
     // Event subscription
-    SUBSCRIBE_EVENTS: 'recall-desktop:subscribe-events',
-    UNSUBSCRIBE_EVENTS: 'recall-desktop:unsubscribe-events',
+    SUBSCRIBE_EVENTS: "recall-desktop:subscribe-events",
+    UNSUBSCRIBE_EVENTS: "recall-desktop:unsubscribe-events",
 };
 // Error types
 class RecallSdkError extends Error {
     constructor(message, code) {
         super(message);
         this.code = code;
-        this.name = 'RecallSdkError';
+        this.name = "RecallSdkError";
     }
 }
 
@@ -49,19 +52,6 @@ class RecallSdkStore {
         };
         this.initialized = false;
         this.sdkInitialized = false;
-        this.currentSdkState = 'idle';
-        // Active meetings and recordings
-        this.activeMeetings = new Map();
-        this.activeRecordings = new Map();
-        // Permission status
-        this.permissions = {
-            accessibility: false,
-            screenCapture: false,
-            microphone: false,
-            systemAudio: false,
-        };
-        // Event listeners for SDK events
-        this.eventListeners = new Set();
     }
     /**
      * Initialize the plugin store
@@ -132,148 +122,33 @@ class RecallSdkStore {
     isSdkInitialized() {
         return this.sdkInitialized;
     }
-    /**
-     * Set current SDK state
-     */
-    setSdkState(state) {
-        this.currentSdkState = state;
-    }
-    /**
-     * Get current SDK state
-     */
-    getSdkState() {
-        return this.currentSdkState;
-    }
-    /**
-     * Add an active meeting
-     */
-    addMeeting(meeting) {
-        this.activeMeetings.set(meeting.id, meeting);
-        console.log(`RecallSdkStore: Added meeting ${meeting.id}:`, meeting);
-    }
-    /**
-     * Remove a meeting
-     */
-    removeMeeting(windowId) {
-        this.activeMeetings.delete(windowId);
-        console.log(`RecallSdkStore: Removed meeting ${windowId}`);
-    }
-    /**
-     * Get active meeting by window ID
-     */
-    getMeeting(windowId) {
-        return this.activeMeetings.get(windowId);
-    }
-    /**
-     * Get all active meetings
-     */
-    getAllMeetings() {
-        return Array.from(this.activeMeetings.values());
-    }
-    /**
-     * Start a recording
-     */
-    startRecording(windowId, uploadToken) {
-        const window = this.activeMeetings.get(windowId);
-        if (window) {
-            this.activeRecordings.set(windowId, { window, uploadToken });
-            console.log(`RecallSdkStore: Started recording for ${windowId}`);
-        }
-    }
-    /**
-     * Stop a recording
-     */
-    stopRecording(windowId) {
-        this.activeRecordings.delete(windowId);
-        console.log(`RecallSdkStore: Stopped recording for ${windowId}`);
-    }
-    /**
-     * Get active recording by window ID
-     */
-    getRecording(windowId) {
-        return this.activeRecordings.get(windowId);
-    }
-    /**
-     * Get all active recordings
-     */
-    getAllRecordings() {
-        return Array.from(this.activeRecordings.values());
-    }
-    /**
-     * Update permission status
-     */
-    setPermissionStatus(permission, status) {
-        const granted = status === 'granted' || status === 'authorized' || status === 'ALLOWED';
-        if (permission === 'screen-capture') {
-            this.permissions.screenCapture = granted;
-        }
-        else if (permission === 'system-audio') {
-            this.permissions.systemAudio = granted;
-        }
-        else {
-            // permission is 'accessibility' | 'microphone'
-            // @ts-ignore - index by key
-            this.permissions[permission] = granted;
-        }
-        console.log(`RecallSdkStore: Permission ${permission} status: ${status}`);
-    }
-    /**
-     * Get permission status
-     */
-    getPermissions() {
-        return { ...this.permissions };
-    }
-    /**
-     * Check if all required permissions are granted
-     */
-    arePermissionsGranted() {
-        return (this.permissions.accessibility &&
-            this.permissions.screenCapture &&
-            this.permissions.microphone);
-    }
-    /**
-     * Add event listener for SDK events
-     */
-    addEventListener(listener) {
-        this.eventListeners.add(listener);
-    }
-    /**
-     * Remove event listener
-     */
-    removeEventListener(listener) {
-        this.eventListeners.delete(listener);
-    }
-    /**
-     * Emit event to all listeners
-     */
-    emitEvent(event) {
-        this.eventListeners.forEach(listener => {
-            try {
-                listener(event);
-            }
-            catch (error) {
-                console.error('RecallSdkStore: Error in event listener:', error);
-            }
-        });
-    }
     /**
      * Clear all state (useful for shutdown/reset)
      */
     clearState() {
-        this.activeMeetings.clear();
-        this.activeRecordings.clear();
         this.setSdkInitialized(false);
-        this.setSdkState('idle');
-        this.permissions = {
-            accessibility: false,
-            screenCapture: false,
-            microphone: false,
-            systemAudio: false,
-        };
         console.log('RecallSdkStore: Cleared all state');
     }
 }
 const recallSdkStore = new RecallSdkStore();
+/**
+ * Persist the ToDesktop plugin context and hydrate the store configuration.
+ */
+const setPluginContext = (input) => {
+    const [enabledPref, apiUrlPref, requestPref] = input.plugin?.todesktop?.preferences ?? [];
+    const preferences = {
+        enabled: typeof enabledPref?.spec?.value === 'boolean'
+            ? enabledPref.spec.value
+            : undefined,
+        apiUrl: typeof apiUrlPref?.spec?.value === 'string' && apiUrlPref.spec.value.trim()
+            ? apiUrlPref.spec.value
+            : undefined,
+        requestPermissionsOnStartup: typeof requestPref?.spec?.value === 'boolean'
+            ? requestPref.spec.value
+            : undefined,
+    };
+    recallSdkStore.loadFromPreferences(preferences);
+};
 
 /**
  * ToDesktop Recall Desktop SDK Plugin - Main Process
@@ -284,199 +159,114 @@ const recallSdkStore = new RecallSdkStore();
  * - Meeting detection and recording management
  * - Event forwarding from SDK to frontend
  */
-let 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) => { console.log('RecallAiSdk.init called with:', config); return null; },
-        shutdown: async () => { console.log('RecallAiSdk.shutdown called'); return null; },
-        startRecording: async (params) => { console.log('RecallAiSdk.startRecording called with:', params); return null; },
-        stopRecording: async (params) => { console.log('RecallAiSdk.stopRecording called with:', params); return null; },
-        pauseRecording: async (params) => { console.log('RecallAiSdk.pauseRecording called with:', params); return null; },
-        resumeRecording: async (params) => { console.log('RecallAiSdk.resumeRecording called with:', params); return null; },
-        uploadRecording: async (params) => { console.log('RecallAiSdk.uploadRecording called with:', params); return null; },
-        prepareDesktopAudioRecording: async () => { console.log('RecallAiSdk.prepareDesktopAudioRecording called'); return 'mock-window-id'; },
-        requestPermission: async (permission) => { console.log(`RecallAiSdk.requestPermission called for: ${permission}`); return null; },
-        addEventListener: (_eventType) => { },
-    };
-}
 class RecallDesktopMain {
     constructor() {
-        this.version = '1.0.0';
+        this.version = "1.0.0";
         this.isInitialized = false;
         this.subscriptions = new Map();
         this.trackedWebContents = new Map();
+        this.sdkEventHandlers = new Map();
+        this.eventSideEffects = {
+            shutdown: () => {
+                recallSdkStore.clearState();
+            },
+        };
     }
     async initialize() {
+        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;
         }
     }
-    loadPreferences() {
-        // 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);
-    }
     async initializeSdk() {
         try {
             const config = recallSdkStore.getConfig();
             const sdkOptions = {
                 apiUrl: config.apiUrl,
                 acquirePermissionsOnStartup: config.requestPermissionsOnStartup
-                    ? ['accessibility', 'screen-capture', 'microphone', 'system-audio']
+                    ? ["accessibility", "screen-capture", "microphone", "system-audio"]
                     : undefined,
                 restartOnError: true,
             };
+            console.log("RecallDesktopMain: SDK options:", sdkOptions);
             // Initialize the Recall SDK
             await RecallAiSdk.init(sdkOptions);
-            // Set up event listeners
-            this.setupSdkEventListeners();
             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");
         }
     }
-    setupSdkEventListeners() {
-        const broadcast = (type, data) => {
-            const channel = `recall-desktop:event:${type}`;
-            const subs = this.subscriptions.get(type);
-            if (!subs)
+    broadcastEvent(type, data) {
+        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;
-            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 = '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 = '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 = '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 = '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 = '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 = '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 = 'upload-progress';
-            recallSdkStore.emitEvent({ type, data: evt });
-            broadcast(type, evt);
-        });
-        // Other events
-        ['realtime-event', 'meeting-updated', 'media-capture-status', 'participant-capture-status']
-            .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 = 'permission-status';
-            recallSdkStore.emitEvent({ type, data: evt });
-            broadcast(type, evt);
-        });
-        // Error handling
-        RecallAiSdk.addEventListener('error', (evt) => {
-            console.error('RecallDesktopMain: SDK error:', evt);
-            const type = '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 = 'shutdown';
-            recallSdkStore.emitEvent({ type, data: evt });
-            broadcast(type, evt);
+            try {
+                wc.send(channel, data);
+            }
+            catch (err) {
+                console.error("RecallDesktopMain: Failed to send event to webContents", wcId, err);
+            }
         });
     }
+    ensureSdkListener(eventType) {
+        if (this.sdkEventHandlers.has(eventType)) {
+            return;
+        }
+        const handler = (evt) => {
+            this.handleSdkEvent(eventType, evt);
+        };
+        this.sdkEventHandlers.set(eventType, handler);
+        RecallAiSdk.addEventListener(eventType, handler);
+    }
+    handleSdkEvent(eventType, evt) {
+        if (eventType === "error") {
+            console.error("RecallDesktopMain: SDK error:", evt);
+        }
+        else {
+            console.log(`RecallDesktopMain: ${eventType}`, evt);
+        }
+        const sideEffect = this.eventSideEffects[eventType];
+        if (sideEffect) {
+            try {
+                sideEffect(evt);
+            }
+            catch (error) {
+                console.error("RecallDesktopMain: Side effect failed for", eventType, error);
+            }
+        }
+        this.broadcastEvent(eventType, evt);
+    }
     registerIpcHandlers() {
         const addDestroyedCleanup = (wc) => {
             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);
@@ -497,11 +287,12 @@ class RecallDesktopMain {
                 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' };
+                console.error("RecallDesktopMain: subscribe-events failed", error);
+                return { success: false, message: "Failed to subscribe to events" };
             }
         });
         // Unsubscribe from events
@@ -520,27 +311,32 @@ class RecallDesktopMain {
                 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' };
+                console.error("RecallDesktopMain: unsubscribe-events failed", error);
+                return {
+                    success: false,
+                    message: "Failed to unsubscribe from events",
+                };
             }
         });
         // Initialize SDK
         electron.ipcMain.handle(IPC_CHANNELS.INIT_SDK, async () => {
             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",
                 };
             }
         });
@@ -549,11 +345,11 @@ class RecallDesktopMain {
             try {
                 await RecallAiSdk.shutdown();
                 recallSdkStore.clearState();
-                return { success: true, message: 'SDK shutdown successfully' };
+                return { success: true, message: "SDK shutdown successfully" };
             }
             catch (error) {
-                console.error('RecallDesktopMain: SDK shutdown failed:', error);
-                return { success: false, message: 'SDK shutdown failed' };
+                console.error("RecallDesktopMain: SDK shutdown failed:", error);
+                return { success: false, message: "SDK shutdown failed" };
             }
         });
         // Get plugin status
@@ -563,74 +359,83 @@ class RecallDesktopMain {
                 sdkInitialized: recallSdkStore.isSdkInitialized(),
                 version: this.version,
                 config: recallSdkStore.getConfig(),
-                sdkState: recallSdkStore.getSdkState(),
-                permissions: recallSdkStore.getPermissions()
             };
         });
         // Start recording
         electron.ipcMain.handle(IPC_CHANNELS.START_RECORDING, async (event, request) => {
             try {
                 if (!recallSdkStore.isSdkInitialized()) {
-                    throw new RecallSdkError('SDK not initialized', 'SDK_NOT_INITIALIZED');
+                    throw new RecallSdkError("SDK not initialized", "SDK_NOT_INITIALIZED");
                 }
                 await RecallAiSdk.startRecording({
                     windowId: request.windowId,
-                    uploadToken: request.uploadToken
+                    uploadToken: request.uploadToken,
                 });
-                recallSdkStore.startRecording(request.windowId, request.uploadToken);
-                return { success: true, message: 'Recording started successfully' };
+                return { success: true, message: "Recording started successfully" };
             }
             catch (error) {
-                console.error('RecallDesktopMain: Start recording failed:', error);
+                console.error("RecallDesktopMain: Start recording failed:", error);
                 return {
                     success: false,
-                    message: error instanceof RecallSdkError ? error.message : 'Failed to start recording'
+                    message: error instanceof RecallSdkError
+                        ? error.message
+                        : "Failed to start recording",
                 };
             }
         });
         // Stop recording
         electron.ipcMain.handle(IPC_CHANNELS.STOP_RECORDING, async (event, request) => {
             try {
-                await RecallAiSdk.stopRecording({ windowId: request.windowId });
-                recallSdkStore.stopRecording(request.windowId);
-                return { success: true, message: 'Recording stopped successfully' };
+                await RecallAiSdk.stopRecording({
+                    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' };
+                console.error("RecallDesktopMain: Stop recording failed:", error);
+                return { success: false, message: "Failed to stop recording" };
             }
         });
         // Pause recording
         electron.ipcMain.handle(IPC_CHANNELS.PAUSE_RECORDING, async (event, request) => {
             try {
-                await RecallAiSdk.pauseRecording({ windowId: request.windowId });
-                return { success: true, message: 'Recording paused successfully' };
+                await RecallAiSdk.pauseRecording({
+                    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' };
+                console.error("RecallDesktopMain: Pause recording failed:", error);
+                return { success: false, message: "Failed to pause recording" };
             }
         });
         // Resume recording
         electron.ipcMain.handle(IPC_CHANNELS.RESUME_RECORDING, async (event, request) => {
             try {
-                await RecallAiSdk.resumeRecording({ windowId: request.windowId });
-                return { success: true, message: 'Recording resumed successfully' };
+                await RecallAiSdk.resumeRecording({
+                    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' };
+                console.error("RecallDesktopMain: Resume recording failed:", error);
+                return { success: false, message: "Failed to resume recording" };
             }
         });
         // Upload recording
         electron.ipcMain.handle(IPC_CHANNELS.UPLOAD_RECORDING, async (event, request) => {
             try {
-                await RecallAiSdk.uploadRecording({ windowId: request.windowId });
-                return { success: true, message: 'Recording upload started successfully' };
+                await RecallAiSdk.uploadRecording({
+                    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' };
+                console.error("RecallDesktopMain: Upload recording failed:", error);
+                return { success: false, message: "Failed to upload recording" };
             }
         });
         // Prepare desktop audio recording
@@ -639,24 +444,30 @@ class RecallDesktopMain {
                 const windowId = await RecallAiSdk.prepareDesktopAudioRecording();
                 return {
                     success: true,
-                    message: 'Desktop audio recording prepared successfully',
-                    data: { windowId }
+                    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' };
+                console.error("RecallDesktopMain: Prepare desktop audio failed:", error);
+                return {
+                    success: false,
+                    message: "Failed to prepare desktop audio recording",
+                };
             }
         });
         // Request permission
         electron.ipcMain.handle(IPC_CHANNELS.REQUEST_PERMISSION, async (event, permission) => {
             try {
                 await RecallAiSdk.requestPermission(permission);
-                return { success: true, message: `Permission request sent for ${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' };
+                console.error("RecallDesktopMain: Request permission failed:", error);
+                return { success: false, message: "Failed to request permission" };
             }
         });
         // Set configuration
@@ -664,31 +475,39 @@ class RecallDesktopMain {
             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');
+                if (recallSdkStore.isSdkInitialized() &&
+                    (config.apiUrl || config.requestPermissionsOnStartup !== undefined)) {
+                    console.log("RecallDesktopMain: Reinitializing SDK due to configuration change");
                     await RecallAiSdk.shutdown();
                     await this.initializeSdk();
                 }
-                return { success: true, message: 'Configuration updated successfully' };
+                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' };
+                console.error("RecallDesktopMain: Failed to set configuration:", error);
+                return { success: false, message: "Failed to update configuration" };
             }
         });
         // Get configuration
         electron.ipcMain.handle(IPC_CHANNELS.GET_CONFIG, async () => {
             return {
                 success: true,
-                message: 'Configuration retrieved successfully',
-                data: recallSdkStore.getConfig()
+                message: "Configuration retrieved successfully",
+                data: recallSdkStore.getConfig(),
             };
         });
     }
 }
 // Initialize plugin
 const recallDesktopMain = new RecallDesktopMain();
-recallDesktopMain.initialize().catch(console.error);
+var main = (context) => {
+    setPluginContext(context);
+    recallDesktopMain.initialize().catch(() => undefined);
+};
 
-module.exports = recallDesktopMain;
+exports.default = main;
+exports.recallDesktopMain = recallDesktopMain;
 //# sourceMappingURL=main.js.map