@todesktop/plugin-recall 1.0.1

package/dist/main.js

@@ -0,0 +1,694 @@
+'use strict';
+
+var electron = require('electron');
+
+/**
+ * Shared types and constants for Recall Desktop SDK integration
+ */
+// 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',
+    // 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',
+    // Desktop audio recording
+    PREPARE_DESKTOP_AUDIO: 'recall-desktop:prepare-desktop-audio',
+    // Permission management
+    REQUEST_PERMISSION: 'recall-desktop:request-permission',
+    // Configuration
+    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',
+};
+// Error types
+class RecallSdkError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'RecallSdkError';
+    }
+}
+
+/**
+ * Recall Desktop SDK plugin state management and storage
+ */
+class RecallSdkStore {
+    constructor() {
+        this.config = {
+            enabled: true,
+            apiUrl: 'https://us-east-1.recall.ai',
+            requestPermissionsOnStartup: true,
+        };
+        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
+     */
+    async initialize() {
+        // Load configuration from ToDesktop preferences
+        try {
+            // In a real implementation, this would load from ToDesktop's preference system
+            // For now, we'll use the defaults
+            this.initialized = true;
+            console.log('RecallSdkStore: Initialized successfully');
+        }
+        catch (error) {
+            console.error('RecallSdkStore: Failed to initialize:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get current plugin configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Update plugin configuration
+     */
+    setConfig(updates) {
+        this.config = { ...this.config, ...updates };
+        console.log('RecallSdkStore: Configuration updated:', this.config);
+    }
+    /**
+     * Load configuration from ToDesktop preferences
+     */
+    loadFromPreferences(preferences) {
+        if (preferences.enabled !== undefined) {
+            this.config.enabled = preferences.enabled;
+        }
+        if (preferences.apiUrl !== undefined) {
+            this.config.apiUrl = preferences.apiUrl;
+        }
+        // autoRecord removed by design
+        if (preferences.requestPermissionsOnStartup !== undefined) {
+            this.config.requestPermissionsOnStartup = preferences.requestPermissionsOnStartup;
+        }
+        console.log('RecallSdkStore: Loaded configuration from preferences:', this.config);
+    }
+    /**
+     * Check if plugin is initialized
+     */
+    isInitialized() {
+        return this.initialized;
+    }
+    /**
+     * Check if plugin is enabled
+     */
+    isEnabled() {
+        return this.config.enabled;
+    }
+    /**
+     * Set SDK initialization status
+     */
+    setSdkInitialized(initialized) {
+        this.sdkInitialized = initialized;
+    }
+    /**
+     * Check if SDK is initialized
+     */
+    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();
+
+/**
+ * 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
+ */
+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.isInitialized = false;
+        this.subscriptions = new Map();
+        this.trackedWebContents = new Map();
+    }
+    async initialize() {
+        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;
+        }
+    }
+    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']
+                    : undefined,
+                restartOnError: true,
+            };
+            // Initialize the Recall SDK
+            await RecallAiSdk.init(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');
+        }
+    }
+    setupSdkEventListeners() {
+        const broadcast = (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;
+                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);
+        });
+    }
+    registerIpcHandlers() {
+        const addDestroyedCleanup = (wc) => {
+            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
+        electron.ipcMain.handle(IPC_CHANNELS.SUBSCRIBE_EVENTS, async (event, eventType) => {
+            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
+        electron.ipcMain.handle(IPC_CHANNELS.UNSUBSCRIBE_EVENTS, async (event, eventType) => {
+            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
+        electron.ipcMain.handle(IPC_CHANNELS.INIT_SDK, async () => {
+            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
+        electron.ipcMain.handle(IPC_CHANNELS.SHUTDOWN_SDK, async () => {
+            try {
+                await RecallAiSdk.shutdown();
+                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
+        electron.ipcMain.handle(IPC_CHANNELS.GET_STATUS, async () => {
+            return {
+                initialized: this.isInitialized,
+                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');
+                }
+                await RecallAiSdk.startRecording({
+                    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
+        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' };
+            }
+            catch (error) {
+                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' };
+            }
+            catch (error) {
+                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' };
+            }
+            catch (error) {
+                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' };
+            }
+            catch (error) {
+                console.error('RecallDesktopMain: Upload recording failed:', error);
+                return { success: false, message: 'Failed to upload recording' };
+            }
+        });
+        // Prepare desktop audio recording
+        electron.ipcMain.handle(IPC_CHANNELS.PREPARE_DESKTOP_AUDIO, async () => {
+            try {
+                const windowId = await RecallAiSdk.prepareDesktopAudioRecording();
+                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
+        electron.ipcMain.handle(IPC_CHANNELS.REQUEST_PERMISSION, async (event, permission) => {
+            try {
+                await RecallAiSdk.requestPermission(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
+        electron.ipcMain.handle(IPC_CHANNELS.SET_CONFIG, async (event, config) => {
+            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();
+                    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
+        electron.ipcMain.handle(IPC_CHANNELS.GET_CONFIG, async () => {
+            return {
+                success: true,
+                message: 'Configuration retrieved successfully',
+                data: recallSdkStore.getConfig()
+            };
+        });
+    }
+}
+// Initialize plugin
+const recallDesktopMain = new RecallDesktopMain();
+recallDesktopMain.initialize().catch(console.error);
+
+module.exports = recallDesktopMain;
+//# sourceMappingURL=main.js.map