loukai-app 0.3.0

package/src/main/handlers/preferencesHandlers.js

@@ -0,0 +1,46 @@
+/**
+ * Preferences IPC Handlers
+ * Handles user preferences management
+ */
+
+import { ipcMain } from 'electron';
+import * as preferencesService from '../../shared/services/preferencesService.js';
+
+/**
+ * Register all preferences-related IPC handlers
+ * @param {Object} mainApp - Main application instance
+ */
+export function registerPreferencesHandlers(mainApp) {
+  // Update auto-tune preferences
+  ipcMain.handle('preferences:setAutoTune', async (event, prefs) => {
+    try {
+      const result = await preferencesService.updateAutoTunePreferences(mainApp.appState, prefs);
+      return result;
+    } catch (error) {
+      console.error('Failed to update auto-tune preferences:', error);
+      return { success: false, error: error.message };
+    }
+  });
+
+  // Update microphone preferences
+  ipcMain.handle('preferences:setMicrophone', async (event, prefs) => {
+    try {
+      const result = await preferencesService.updateMicrophonePreferences(mainApp.appState, prefs);
+      return result;
+    } catch (error) {
+      console.error('Failed to update microphone preferences:', error);
+      return { success: false, error: error.message };
+    }
+  });
+
+  // Update effects preferences
+  ipcMain.handle('preferences:setEffects', async (event, prefs) => {
+    try {
+      const result = await preferencesService.updateEffectsPreferences(mainApp.appState, prefs);
+      return result;
+    } catch (error) {
+      console.error('Failed to update effects preferences:', error);
+      return { success: false, error: error.message };
+    }
+  });
+}

package/src/main/handlers/queueHandlers.js

@@ -0,0 +1,81 @@
+/**
+ * Queue IPC Handlers
+ * Handles song queue management operations
+ */
+
+import { ipcMain } from 'electron';
+import { QUEUE_CHANNELS } from '../../shared/ipcContracts.js';
+import * as queueService from '../../shared/services/queueService.js';
+
+/**
+ * Register all queue-related IPC handlers
+ * @param {Object} mainApp - Main application instance
+ */
+export function registerQueueHandlers(mainApp) {
+  // Add song to queue (with auto-load and legacy songQueue sync)
+  ipcMain.handle(QUEUE_CHANNELS.ADD_SONG, async (event, queueItem) => {
+    const result = queueService.addSongToQueue(mainApp.appState, queueItem);
+
+    // Update legacy songQueue for compatibility
+    mainApp.songQueue = result.queue;
+
+    // If queue was empty, automatically load and start playing the first song
+    if (result.success && result.wasEmpty) {
+      console.log(`🎵 Queue was empty, auto-loading "${result.queueItem.title}"`);
+      try {
+        // Use the returned queueItem which has the generated ID
+        await mainApp.loadKaiFile(result.queueItem.path, result.queueItem.id);
+        console.log('✅ Successfully auto-loaded song from queue');
+      } catch (error) {
+        console.error('❌ Failed to auto-load song from queue:', error);
+      }
+    }
+
+    return result;
+  });
+
+  // Remove song from queue (with legacy songQueue sync)
+  ipcMain.handle(QUEUE_CHANNELS.REMOVE_SONG, (event, itemId) => {
+    const result = queueService.removeSongFromQueue(mainApp.appState, itemId);
+
+    // Update legacy songQueue for compatibility
+    if (result.success) {
+      mainApp.songQueue = result.queue;
+    }
+
+    return result;
+  });
+
+  // Get queue
+  ipcMain.handle(QUEUE_CHANNELS.GET, () => {
+    return queueService.getQueue(mainApp.appState);
+  });
+
+  // Clear queue (with legacy songQueue sync)
+  ipcMain.handle(QUEUE_CHANNELS.CLEAR, () => {
+    const result = queueService.clearQueue(mainApp.appState);
+
+    // Update legacy songQueue for compatibility
+    mainApp.songQueue = [];
+
+    return result;
+  });
+
+  // Reorder queue (with legacy songQueue sync)
+  ipcMain.handle('queue:reorderQueue', (event, songId, newIndex) => {
+    const result = queueService.reorderQueue(mainApp.appState, songId, newIndex);
+
+    // Update legacy songQueue for compatibility
+    if (result.success) {
+      mainApp.songQueue = result.queue;
+    }
+
+    return result;
+  });
+
+  // Load song from queue by ID
+  ipcMain.handle('queue:load', async (event, itemId) => {
+    const result = await queueService.loadFromQueue(mainApp, itemId);
+    return result;
+  });
+}

package/src/main/handlers/rendererHandlers.js

@@ -0,0 +1,63 @@
+/**
+ * Renderer IPC Handlers
+ * Handles renderer process state updates (playback, mixer, effects)
+ */
+
+import { ipcMain } from 'electron';
+
+/**
+ * Register all renderer state update IPC handlers
+ * @param {Object} mainApp - Main application instance
+ */
+export function registerRendererHandlers(mainApp) {
+  // Renderer playback state updates (legacy - keeping for compatibility)
+  ipcMain.on('renderer:playbackState', (event, state) => {
+    // Store the renderer playback state for position broadcasting
+    mainApp.rendererPlaybackState = state;
+
+    // Broadcast to web admin clients for real-time position updates
+    if (mainApp.webServer) {
+      mainApp.webServer.broadcastPlaybackState(state);
+    }
+  });
+
+  // Renderer state updates to AppState
+  ipcMain.on('renderer:updatePlaybackState', (event, updates) => {
+    mainApp.appState.updatePlaybackState(updates);
+
+    // Also broadcast immediately to web admin for responsive updates
+    if (mainApp.webServer && updates) {
+      // Broadcast the updates directly - they already contain position/duration
+      mainApp.webServer.broadcastPlaybackState(updates);
+    }
+  });
+
+  // Renderer song loaded event
+  ipcMain.on('renderer:songLoaded', (event, songData) => {
+    // Preserve queueItemId and format if they exist in current song (renderer doesn't know about them)
+    const existingQueueItemId = mainApp.appState.state.currentSong?.queueItemId;
+    const existingFormat = mainApp.appState.state.currentSong?.format;
+    const updatedSongData = {
+      ...songData,
+      queueItemId: existingQueueItemId || songData.queueItemId || null,
+      format: existingFormat || songData.format || 'kai',
+    };
+
+    mainApp.appState.setCurrentSong(updatedSongData);
+    // Also update legacy currentSong for compatibility
+    mainApp.currentSong = {
+      metadata: songData,
+      filePath: songData.path,
+    };
+  });
+
+  // Renderer mixer state updates
+  ipcMain.on('renderer:updateMixerState', (event, mixerState) => {
+    mainApp.appState.updateMixerState(mixerState);
+  });
+
+  // Renderer effects state updates
+  ipcMain.on('renderer:updateEffectsState', (event, effectsState) => {
+    mainApp.appState.updateEffectsState(effectsState);
+  });
+}

package/src/main/handlers/settingsHandlers.js

@@ -0,0 +1,42 @@
+/**
+ * Settings IPC Handlers
+ * Handles application settings persistence
+ * Uses unified settingsService for consistent behavior
+ */
+
+import { ipcMain } from 'electron';
+import { SETTINGS_CHANNELS } from '../../shared/ipcContracts.js';
+import {
+  getSetting,
+  setSetting,
+  getAllSettings,
+  setSettings,
+} from '../../shared/services/settingsService.js';
+
+/**
+ * Register all settings-related IPC handlers
+ * @param {Object} _mainApp - Main application instance (unused, kept for signature consistency)
+ */
+export function registerSettingsHandlers(_mainApp) {
+  console.log('📡 Registering settings handlers...');
+
+  // Get setting - uses settingsService which applies defaults
+  ipcMain.handle(SETTINGS_CHANNELS.GET, (event, key, defaultValue) => {
+    return getSetting(key, defaultValue);
+  });
+
+  // Set setting - uses settingsService for persistence, AppState sync, and broadcast
+  ipcMain.handle(SETTINGS_CHANNELS.SET, (event, key, value) => {
+    return setSetting(key, value);
+  });
+
+  // Get all settings - merged with defaults
+  ipcMain.handle(SETTINGS_CHANNELS.GET_ALL, () => {
+    return getAllSettings();
+  });
+
+  // Update batch - uses settingsService
+  ipcMain.handle(SETTINGS_CHANNELS.UPDATE_BATCH, (event, updates) => {
+    return setSettings(updates);
+  });
+}

package/src/main/handlers/webServerHandlers.js

@@ -0,0 +1,105 @@
+/**
+ * Web Server IPC Handlers
+ * Handles all web server management operations
+ */
+
+import { ipcMain } from 'electron';
+import bcrypt from 'bcryptjs';
+import * as serverSettingsService from '../../shared/services/serverSettingsService.js';
+import * as requestsService from '../../shared/services/requestsService.js';
+
+/**
+ * Register all web server-related IPC handlers
+ * @param {Object} mainApp - Main application instance
+ */
+export function registerWebServerHandlers(mainApp) {
+  console.log('📡 Registering web server handlers...');
+
+  // Get web server port
+  ipcMain.handle('webServer:getPort', () => {
+    return mainApp.getWebServerPort();
+  });
+
+  // Get web server URL
+  ipcMain.handle('webServer:getUrl', () => {
+    // console.log('🔍 webServer:getUrl called', { hasWebServer: Boolean(mainApp.webServer) });
+    return mainApp.webServer?.getServerUrl() || null;
+  });
+
+  // Get web server settings
+  ipcMain.handle('webServer:getSettings', () => {
+    if (mainApp.webServer) {
+      const result = serverSettingsService.getServerSettings(mainApp.webServer);
+      return result.success ? result.settings : null;
+    }
+    return null;
+  });
+
+  // Update web server settings
+  ipcMain.handle('webServer:updateSettings', (event, settings) => {
+    if (mainApp.webServer) {
+      return serverSettingsService.updateServerSettings(mainApp.webServer, settings);
+    }
+    return { success: false, error: 'Web server not available' };
+  });
+
+  // Get song requests
+  ipcMain.handle('webServer:getSongRequests', () => {
+    if (mainApp.webServer) {
+      const result = requestsService.getRequests(mainApp.webServer);
+      return result.success ? result.requests : [];
+    }
+    return [];
+  });
+
+  // Approve song request
+  ipcMain.handle('webServer:approveRequest', async (event, requestId) => {
+    if (mainApp.webServer) {
+      return await requestsService.approveRequest(mainApp.webServer, requestId);
+    }
+    return { success: false, error: 'Web server not available' };
+  });
+
+  // Reject song request
+  ipcMain.handle('webServer:rejectRequest', async (event, requestId) => {
+    if (mainApp.webServer) {
+      return await requestsService.rejectRequest(mainApp.webServer, requestId);
+    }
+    return { success: false, error: 'Web server not available' };
+  });
+
+  // Refresh web server songs cache
+  ipcMain.handle('webServer:refreshCache', async () => {
+    try {
+      if (mainApp.webServer) {
+        await mainApp.webServer.refreshSongsCache();
+        return { success: true };
+      } else {
+        return { error: 'Web server not available' };
+      }
+    } catch (error) {
+      return { error: error.message };
+    }
+  });
+
+  // Set admin password (hashed with bcrypt)
+  ipcMain.handle('webServer:setAdminPassword', async (event, password) => {
+    try {
+      const saltRounds = 10;
+      const hashedPassword = await bcrypt.hash(password, saltRounds);
+      await mainApp.settings.set('server.adminPasswordHash', hashedPassword);
+      return { success: true };
+    } catch (error) {
+      console.error('Failed to set admin password:', error);
+      return { success: false, error: error.message };
+    }
+  });
+
+  // Clear all song requests
+  ipcMain.handle('webServer:clearAllRequests', () => {
+    if (mainApp.webServer) {
+      return requestsService.clearRequests(mainApp.webServer);
+    }
+    return { success: false, error: 'Web server not available' };
+  });
+}