@todesktop/plugin-recall 1.0.1

package/src/preload.ts

@@ -0,0 +1,237 @@
+/**
+ * ToDesktop Recall Desktop SDK Plugin - Preload Script
+ * 
+ * This file runs in the renderer process with Node.js access and exposes
+ * safe APIs to the web application through the contextBridge.
+ */
+
+import { contextBridge, ipcRenderer } from 'electron';
+import { 
+  IPC_CHANNELS, 
+  ApiResponse, 
+  PluginStatus, 
+  StartRecordingRequest,
+  StopRecordingRequest,
+  PauseRecordingRequest,
+  ResumeRecordingRequest,
+  UploadRecordingRequest,
+  PermissionType,
+  RecallSdkConfig,
+  PrepareDesktopAudioResponse,
+  RecallSdkEventType
+} from './shared';
+
+/**
+ * Recall Desktop SDK API exposed to the renderer process
+ */
+const recallDesktopApi = {
+  /**
+   * Initialize the Recall SDK
+   * @returns Promise resolving to initialization result
+   */
+  async initSdk(): Promise<ApiResponse> {
+    return ipcRenderer.invoke(IPC_CHANNELS.INIT_SDK);
+  },
+
+  /**
+   * Shutdown the Recall SDK
+   * @returns Promise resolving to shutdown result
+   */
+  async shutdownSdk(): Promise<ApiResponse> {
+    return ipcRenderer.invoke(IPC_CHANNELS.SHUTDOWN_SDK);
+  },
+
+  /**
+   * Get current plugin and SDK status
+   * @returns Promise resolving to plugin status
+   */
+  async getStatus(): Promise<PluginStatus> {
+    return ipcRenderer.invoke(IPC_CHANNELS.GET_STATUS);
+  },
+
+  /**
+   * Start recording a meeting
+   * @param windowId The meeting window ID
+   * @param uploadToken Upload token from your backend
+   * @returns Promise resolving to recording start result
+   */
+  async startRecording(windowId: string, uploadToken: string): Promise<ApiResponse> {
+    const request: StartRecordingRequest = { windowId, uploadToken };
+    return ipcRenderer.invoke(IPC_CHANNELS.START_RECORDING, request);
+  },
+
+  /**
+   * Stop recording a meeting
+   * @param windowId The meeting window ID
+   * @returns Promise resolving to recording stop result
+   */
+  async stopRecording(windowId: string): Promise<ApiResponse> {
+    const request: StopRecordingRequest = { windowId };
+    return ipcRenderer.invoke(IPC_CHANNELS.STOP_RECORDING, request);
+  },
+
+  /**
+   * Pause recording a meeting
+   * @param windowId The meeting window ID
+   * @returns Promise resolving to recording pause result
+   */
+  async pauseRecording(windowId: string): Promise<ApiResponse> {
+    const request: PauseRecordingRequest = { windowId };
+    return ipcRenderer.invoke(IPC_CHANNELS.PAUSE_RECORDING, request);
+  },
+
+  /**
+   * Resume recording a meeting
+   * @param windowId The meeting window ID
+   * @returns Promise resolving to recording resume result
+   */
+  async resumeRecording(windowId: string): Promise<ApiResponse> {
+    const request: ResumeRecordingRequest = { windowId };
+    return ipcRenderer.invoke(IPC_CHANNELS.RESUME_RECORDING, request);
+  },
+
+  /**
+   * Upload a completed recording
+   * @param windowId The meeting window ID
+   * @returns Promise resolving to upload start result
+   */
+  async uploadRecording(windowId: string): Promise<ApiResponse> {
+    const request: UploadRecordingRequest = { windowId };
+    return ipcRenderer.invoke(IPC_CHANNELS.UPLOAD_RECORDING, request);
+  },
+
+  /**
+   * Prepare desktop audio recording for non-meeting audio capture
+   * @returns Promise resolving to desktop audio preparation result
+   */
+  async prepareDesktopAudioRecording(): Promise<ApiResponse<PrepareDesktopAudioResponse>> {
+    return ipcRenderer.invoke(IPC_CHANNELS.PREPARE_DESKTOP_AUDIO);
+  },
+
+  /**
+   * Request a specific permission from the user
+   * @param permission The permission to request
+   * @returns Promise resolving to permission request result
+   */
+  async requestPermission(permission: PermissionType): Promise<ApiResponse> {
+    return ipcRenderer.invoke(IPC_CHANNELS.REQUEST_PERMISSION, permission);
+  },
+
+  /**
+   * Update plugin configuration
+   * @param config Configuration updates
+   * @returns Promise resolving to update result
+   */
+  async setConfig(config: Partial<RecallSdkConfig>): Promise<ApiResponse> {
+    return ipcRenderer.invoke(IPC_CHANNELS.SET_CONFIG, config);
+  },
+
+  /**
+   * Get current plugin configuration
+   * @returns Promise resolving to current configuration
+   */
+  async getConfig(): Promise<ApiResponse<RecallSdkConfig>> {
+    return ipcRenderer.invoke(IPC_CHANNELS.GET_CONFIG);
+  },
+
+  /**
+   * Subscribe to SDK events
+   * @param eventType The type of event to listen for
+   * @param callback Function to call when event occurs
+   * @returns Function to unsubscribe from the event
+   */
+  addEventListener(eventType: RecallSdkEventType, callback: (data: any) => void): () => void {
+    const channel = `recall-desktop:event:${eventType}`;
+
+    // Fire-and-forget subscribe to main
+    ipcRenderer.invoke(IPC_CHANNELS.SUBSCRIBE_EVENTS, eventType).catch(console.error);
+
+    const listener = (_event: any, data: any) => {
+      callback(data);
+    };
+    ipcRenderer.on(channel, listener);
+
+    // Return unsubscribe function
+    return () => {
+      ipcRenderer.removeListener(channel, listener);
+      ipcRenderer.invoke(IPC_CHANNELS.UNSUBSCRIBE_EVENTS, eventType).catch(console.error);
+    };
+  },
+
+  /**
+   * Get plugin version
+   * @returns Plugin version string
+   */
+  getVersion(): string {
+    return '1.0.0';
+  },
+
+  /**
+   * Convenience method for handling meeting detection events
+   * @param callback Function to call when a meeting is detected
+   * @returns Function to unsubscribe from the event
+   */
+  onMeetingDetected(callback: (meetingData: any) => void): () => void {
+    return this.addEventListener('meeting-detected', callback);
+  },
+
+  /**
+   * Convenience method for handling recording state changes
+   * @param callback Function to call when recording state changes
+   * @returns Function to unsubscribe from the event
+   */
+  onRecordingStateChange(callback: (stateData: any) => void): () => void {
+    return this.addEventListener('sdk-state-change', callback);
+  },
+
+  /**
+   * Convenience method for handling upload progress updates
+   * @param callback Function to call when upload progress updates
+   * @returns Function to unsubscribe from the event
+   */
+  onUploadProgress(callback: (progressData: any) => void): () => void {
+    return this.addEventListener('upload-progress', callback);
+  },
+
+  /**
+   * Convenience method for handling permission status updates
+   * @param callback Function to call when permission status changes
+   * @returns Function to unsubscribe from the event
+   */
+  onPermissionStatusChange(callback: (permissionData: any) => void): () => void {
+    return this.addEventListener('permission-status', callback);
+  },
+
+  /**
+   * Convenience method for handling SDK errors
+   * @param callback Function to call when SDK errors occur
+   * @returns Function to unsubscribe from the event
+   */
+  onError(callback: (errorData: any) => void): () => void {
+    return this.addEventListener('error', callback);
+  },
+
+  /**
+   * Convenience method for handling real-time events (transcription, participants, etc.)
+   * @param callback Function to call when real-time events occur
+   * @returns Function to unsubscribe from the event
+   */
+  onRealtimeEvent(callback: (realtimeData: any) => void): () => void {
+    return this.addEventListener('realtime-event', callback);
+  }
+};
+
+// Export the API type for TypeScript support
+export type RecallDesktopApi = typeof recallDesktopApi;
+
+// Expose the API to the renderer process
+contextBridge.exposeInMainWorld('recallDesktop', recallDesktopApi);
+
+// Extend the global Window interface for TypeScript
+declare global {
+  interface Window {
+    recallDesktop: RecallDesktopApi;
+  }
+}
+
+console.log('RecallDesktop: Preload script loaded successfully');

package/src/shared.ts

@@ -0,0 +1,204 @@
+/**
+ * Shared types and constants for Recall Desktop SDK integration
+ */
+
+// IPC channel names - use unique namespace to avoid conflicts
+export 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',
+} as const;
+
+// Recall SDK Configuration (mirrors RecallAiSdkConfig where applicable)
+export interface RecallSdkConfig {
+  enabled: boolean;
+  apiUrl: string;
+  requestPermissionsOnStartup: boolean;
+}
+
+// Meeting window information from SDK
+export interface MeetingWindow {
+  id: string;
+  title?: string;
+  url?: string;
+  platform: string;
+}
+
+// Recording request/response types
+export interface StartRecordingRequest {
+  windowId: string;
+  uploadToken: string;
+}
+
+export interface StopRecordingRequest {
+  windowId: string;
+}
+
+export interface PauseRecordingRequest {
+  windowId: string;
+}
+
+export interface ResumeRecordingRequest {
+  windowId: string;
+}
+
+export interface UploadRecordingRequest {
+  windowId: string;
+}
+
+// SDK Events from Recall SDK (mirror upstream)
+export type RecallSdkEventType =
+  | 'recording-started'
+  | 'recording-ended'
+  | 'upload-progress'
+  | 'meeting-detected'
+  | 'meeting-updated'
+  | 'meeting-closed'
+  | 'sdk-state-change'
+  | 'error'
+  | 'media-capture-status'
+  | 'participant-capture-status'
+  | 'permissions-granted'
+  | 'permission-status'
+  | 'realtime-event'
+  | 'shutdown';
+
+export interface RecallSdkEvent {
+  type: RecallSdkEventType;
+  data: any;
+}
+
+// SDK Event payloads
+export interface MeetingDetectedEvent {
+  window: MeetingWindow;
+}
+
+export interface SdkStateChangeEvent {
+  sdk: {
+    state: {
+      code: 'recording' | 'idle' | 'paused';
+    };
+  };
+}
+
+export interface RecordingStartedEvent {
+  window: MeetingWindow;
+}
+
+export interface RecordingEndedEvent {
+  window: MeetingWindow;
+}
+
+export interface MeetingClosedEvent {
+  window: MeetingWindow;
+}
+
+export interface UploadProgressEvent {
+  window: { id: string };
+  progress: number; // 0-100
+}
+
+export interface MeetingUpdatedEvent {
+  window: MeetingWindow;
+}
+
+export interface MediaCaptureStatusEvent {
+  window: MeetingWindow;
+  type: 'video' | 'audio';
+  capturing: boolean;
+}
+
+export interface ParticipantCaptureStatusEvent {
+  window: MeetingWindow;
+  type: 'video' | 'audio' | 'screenshare';
+  capturing: boolean;
+}
+
+export interface RealtimeEvent {
+  window: MeetingWindow;
+  event: string;
+  data: any;
+}
+
+export interface SdkErrorEvent {
+  window?: MeetingWindow;
+  type: string;
+  message: string;
+}
+
+export interface PermissionStatusEvent {
+  permission: PermissionType;
+  status: string;
+}
+
+export interface ShutdownEvent {
+  code: number;
+  signal: string;
+}
+
+// Permission types (mirror upstream)
+export type PermissionType = 'accessibility' | 'screen-capture' | 'microphone' | 'system-audio';
+
+// API Response types
+export interface ApiResponse<T = any> {
+  success: boolean;
+  message: string;
+  data?: T;
+}
+
+// Plugin status
+export interface PluginStatus {
+  initialized: boolean;
+  sdkInitialized: boolean;
+  version: string;
+  config: RecallSdkConfig;
+  sdkState?: 'recording' | 'idle' | 'paused';
+  permissions?: {
+    accessibility: boolean;
+    screenCapture: boolean;
+    microphone: boolean;
+    systemAudio: boolean;
+  };
+}
+
+// Error types
+export class RecallSdkError extends Error {
+  constructor(message: string, public code?: string) {
+    super(message);
+    this.name = 'RecallSdkError';
+  }
+}
+
+// SDK Initialization options
+export interface SdkInitOptions {
+  apiUrl: string;
+  acquirePermissionsOnStartup?: PermissionType[];
+  restartOnError?: boolean;
+}
+
+// Desktop audio recording response
+export interface PrepareDesktopAudioResponse {
+  windowId: string;
+}

package/src/store.ts

@@ -0,0 +1,266 @@
+/**
+ * Recall Desktop SDK plugin state management and storage
+ */
+
+import { RecallSdkConfig, MeetingWindow, PermissionType } from './shared';
+
+class RecallSdkStore {
+  private config: RecallSdkConfig = {
+    enabled: true,
+    apiUrl: 'https://us-east-1.recall.ai',
+    requestPermissionsOnStartup: true,
+  };
+
+  private initialized = false;
+  private sdkInitialized = false;
+  private currentSdkState: 'recording' | 'idle' | 'paused' = 'idle';
+  
+  // Active meetings and recordings
+  private activeMeetings = new Map<string, MeetingWindow>();
+  private activeRecordings = new Map<string, { window: MeetingWindow; uploadToken: string }>();
+  
+  // Permission status
+  private permissions = {
+    accessibility: false,
+    screenCapture: false,
+    microphone: false,
+    systemAudio: false,
+  };
+
+  // Event listeners for SDK events
+  private eventListeners = new Set<(event: any) => void>();
+
+  /**
+   * Initialize the plugin store
+   */
+  async initialize(): Promise<void> {
+    // 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(): RecallSdkConfig {
+    return { ...this.config };
+  }
+
+  /**
+   * Update plugin configuration
+   */
+  setConfig(updates: Partial<RecallSdkConfig>): void {
+    this.config = { ...this.config, ...updates };
+    console.log('RecallSdkStore: Configuration updated:', this.config);
+  }
+
+  /**
+   * Load configuration from ToDesktop preferences
+   */
+  loadFromPreferences(preferences: Record<string, any>): void {
+    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(): boolean {
+    return this.initialized;
+  }
+
+  /**
+   * Check if plugin is enabled
+   */
+  isEnabled(): boolean {
+    return this.config.enabled;
+  }
+
+  /**
+   * Set SDK initialization status
+   */
+  setSdkInitialized(initialized: boolean): void {
+    this.sdkInitialized = initialized;
+  }
+
+  /**
+   * Check if SDK is initialized
+   */
+  isSdkInitialized(): boolean {
+    return this.sdkInitialized;
+  }
+
+  /**
+   * Set current SDK state
+   */
+  setSdkState(state: 'recording' | 'idle' | 'paused'): void {
+    this.currentSdkState = state;
+  }
+
+  /**
+   * Get current SDK state
+   */
+  getSdkState(): 'recording' | 'idle' | 'paused' {
+    return this.currentSdkState;
+  }
+
+  /**
+   * Add an active meeting
+   */
+  addMeeting(meeting: MeetingWindow): void {
+    this.activeMeetings.set(meeting.id, meeting);
+    console.log(`RecallSdkStore: Added meeting ${meeting.id}:`, meeting);
+  }
+
+  /**
+   * Remove a meeting
+   */
+  removeMeeting(windowId: string): void {
+    this.activeMeetings.delete(windowId);
+    console.log(`RecallSdkStore: Removed meeting ${windowId}`);
+  }
+
+  /**
+   * Get active meeting by window ID
+   */
+  getMeeting(windowId: string): MeetingWindow | undefined {
+    return this.activeMeetings.get(windowId);
+  }
+
+  /**
+   * Get all active meetings
+   */
+  getAllMeetings(): MeetingWindow[] {
+    return Array.from(this.activeMeetings.values());
+  }
+
+  /**
+   * Start a recording
+   */
+  startRecording(windowId: string, uploadToken: string): void {
+    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: string): void {
+    this.activeRecordings.delete(windowId);
+    console.log(`RecallSdkStore: Stopped recording for ${windowId}`);
+  }
+
+  /**
+   * Get active recording by window ID
+   */
+  getRecording(windowId: string): { window: MeetingWindow; uploadToken: string } | undefined {
+    return this.activeRecordings.get(windowId);
+  }
+
+  /**
+   * Get all active recordings
+   */
+  getAllRecordings(): { window: MeetingWindow; uploadToken: string }[] {
+    return Array.from(this.activeRecordings.values());
+  }
+
+  /**
+   * Update permission status
+   */
+  setPermissionStatus(permission: PermissionType, status: string): void {
+    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(): { accessibility: boolean; screenCapture: boolean; microphone: boolean; systemAudio: boolean } {
+    return { ...this.permissions };
+  }
+
+  /**
+   * Check if all required permissions are granted
+   */
+  arePermissionsGranted(): boolean {
+    return (
+      this.permissions.accessibility &&
+      this.permissions.screenCapture &&
+      this.permissions.microphone
+    );
+  }
+
+  /**
+   * Add event listener for SDK events
+   */
+  addEventListener(listener: (event: any) => void): void {
+    this.eventListeners.add(listener);
+  }
+
+  /**
+   * Remove event listener
+   */
+  removeEventListener(listener: (event: any) => void): void {
+    this.eventListeners.delete(listener);
+  }
+
+  /**
+   * Emit event to all listeners
+   */
+  emitEvent(event: any): void {
+    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(): void {
+    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');
+  }
+}
+
+export const recallSdkStore = new RecallSdkStore();

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "composite": true,
+    "types": ["node", "electron"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["dist", "node_modules", "**/*.test.ts", "**/*.spec.ts"]
+}