loukai-app 0.3.0

package/src/main/handlers/creatorHandlers.js

@@ -0,0 +1,159 @@
+/**
+ * Creator IPC Handlers
+ * Handles AI tool installation and karaoke file creation
+ *
+ * Uses shared creatorService for logic - same service is used by HTTP routes
+ */
+
+import { ipcMain, dialog } from 'electron';
+import { CREATOR_CHANNELS } from '../../shared/ipcContracts.js';
+import * as creatorService from '../../shared/services/creatorService.js';
+import * as llmService from '../creator/llmService.js';
+
+/**
+ * Register all creator-related IPC handlers
+ * @param {Object} mainApp - Main application instance
+ */
+export function registerCreatorHandlers(mainApp) {
+  // Check all components
+  ipcMain.handle(CREATOR_CHANNELS.CHECK_COMPONENTS, () => {
+    return creatorService.checkComponents();
+  });
+
+  // Get installation status
+  ipcMain.handle(CREATOR_CHANNELS.GET_STATUS, () => {
+    return creatorService.getStatus();
+  });
+
+  // Install components
+  ipcMain.handle(CREATOR_CHANNELS.INSTALL_COMPONENTS, async () => {
+    const result = await creatorService.installComponents((progress) => {
+      mainApp.sendToRenderer(CREATOR_CHANNELS.INSTALL_PROGRESS, progress);
+    });
+
+    if (!result.success) {
+      mainApp.sendToRenderer(CREATOR_CHANNELS.INSTALL_ERROR, {
+        error: result.error,
+      });
+    }
+
+    return result;
+  });
+
+  // Cancel installation
+  ipcMain.handle(CREATOR_CHANNELS.CANCEL_INSTALL, () => {
+    return creatorService.cancelInstall();
+  });
+
+  // Search lyrics from LRCLIB
+  ipcMain.handle(CREATOR_CHANNELS.SEARCH_LYRICS, (_event, title, artist) => {
+    return creatorService.findLyrics(title, artist);
+  });
+
+  // Prepare Whisper context with vocabulary hints
+  ipcMain.handle(
+    CREATOR_CHANNELS.PREPARE_WHISPER_CONTEXT,
+    (_event, title, artist, existingLyrics) => {
+      return creatorService.getWhisperContext(title, artist, existingLyrics);
+    }
+  );
+
+  // Select audio/video file (Electron-only - uses native dialog)
+  ipcMain.handle(CREATOR_CHANNELS.SELECT_FILE, async () => {
+    try {
+      const result = await dialog.showOpenDialog(mainApp.mainWindow, {
+        title: 'Select Audio or Video File',
+        properties: ['openFile'],
+        filters: [
+          {
+            name: 'Audio/Video Files',
+            extensions: [
+              'mp3',
+              'wav',
+              'flac',
+              'ogg',
+              'm4a',
+              'aac',
+              'mp4',
+              'mkv',
+              'avi',
+              'mov',
+              'webm',
+            ],
+          },
+          { name: 'Audio Files', extensions: ['mp3', 'wav', 'flac', 'ogg', 'm4a', 'aac'] },
+          { name: 'Video Files', extensions: ['mp4', 'mkv', 'avi', 'mov', 'webm'] },
+          { name: 'All Files', extensions: ['*'] },
+        ],
+      });
+
+      if (result.canceled || result.filePaths.length === 0) {
+        return { success: false, cancelled: true };
+      }
+
+      // Use shared service to get file info
+      return creatorService.getFileInfo(result.filePaths[0]);
+    } catch (error) {
+      console.error('File selection failed:', error);
+      return { success: false, error: error.message };
+    }
+  });
+
+  // Start conversion
+  ipcMain.handle(CREATOR_CHANNELS.START_CONVERSION, async (_event, options) => {
+    // Track if we're saving to songs folder (outputDir is set)
+    const savedToSongsFolder = Boolean(options.outputDir);
+
+    const result = await creatorService.startConversion(
+      options,
+      (progress) => {
+        mainApp.sendToRenderer(CREATOR_CHANNELS.CONVERSION_PROGRESS, progress);
+      },
+      (consoleLine) => {
+        mainApp.sendToRenderer(CREATOR_CHANNELS.CONVERSION_CONSOLE, { line: consoleLine });
+      },
+      mainApp.settings // Pass settings manager for LLM
+    );
+
+    if (result.success) {
+      mainApp.sendToRenderer(CREATOR_CHANNELS.CONVERSION_COMPLETE, {
+        outputPath: result.outputPath,
+        duration: result.duration,
+        stems: result.stems,
+        hasLyrics: result.hasLyrics,
+        hasPitch: result.hasPitch,
+        llmStats: result.llmStats,
+        savedToSongsFolder,
+      });
+    } else if (!result.cancelled) {
+      mainApp.sendToRenderer(CREATOR_CHANNELS.CONVERSION_ERROR, {
+        error: result.error,
+      });
+    }
+
+    return result;
+  });
+
+  // Cancel conversion
+  ipcMain.handle(CREATOR_CHANNELS.CANCEL_CONVERSION, () => {
+    return creatorService.stopConversion();
+  });
+
+  // Get LLM settings
+  ipcMain.handle(CREATOR_CHANNELS.GET_LLM_SETTINGS, () => {
+    return llmService.getLLMSettings(mainApp.settings);
+  });
+
+  // Save LLM settings
+  ipcMain.handle(CREATOR_CHANNELS.SAVE_LLM_SETTINGS, (_event, settings) => {
+    llmService.saveLLMSettings(mainApp.settings, settings);
+    return { success: true };
+  });
+
+  // Test LLM connection
+  ipcMain.handle(CREATOR_CHANNELS.TEST_LLM_CONNECTION, (_event, settings) => {
+    return llmService.testLLMConnection(settings);
+  });
+
+  console.log('✅ Creator handlers registered');
+}

package/src/main/handlers/editorHandlers.js

@@ -0,0 +1,98 @@
+/**
+ * Editor IPC Handlers
+ * Handles song editing operations (KAI and M4A formats)
+ */
+
+import { ipcMain } from 'electron';
+
+/**
+ * Register all editor-related IPC handlers
+ * @param {Object} mainApp - Main application instance
+ */
+export function registerEditorHandlers(mainApp) {
+  // Load song file for editing (KAI or M4A)
+  ipcMain.handle('editor:loadKai', async (event, filePath) => {
+    try {
+      console.log('Load song file for editing:', filePath);
+
+      const editorService = await import('../../shared/services/editorService.js');
+      const result = await editorService.loadSong(filePath);
+
+      console.log(
+        `${result.format.toUpperCase()} file loaded for editing, has lyrics:`,
+        result.kaiData.lyrics?.length || 0
+      );
+
+      return {
+        success: true,
+        data: result.kaiData,
+        format: result.format, // Include format in response
+      };
+    } catch (error) {
+      console.error('Failed to load song file for editing:', error);
+      return { success: false, error: error.message };
+    }
+  });
+
+  // Save song file (KAI or M4A)
+  ipcMain.handle('editor:saveKai', async (event, kaiData, originalPath) => {
+    try {
+      console.log('Save song file request:', originalPath);
+      console.log('Updated lyrics:', kaiData.lyrics?.length || 0, 'lines');
+
+      // Determine format from file extension
+      const lowerPath = originalPath.toLowerCase();
+      let format;
+      if (lowerPath.endsWith('.kai')) {
+        format = 'kai';
+      } else if (lowerPath.endsWith('.m4a') || lowerPath.endsWith('.mp4')) {
+        format = 'm4a-stems';
+      } else {
+        throw new Error('Unsupported file format');
+      }
+
+      const editorService = await import('../../shared/services/editorService.js');
+      const _result = await editorService.saveSong(originalPath, {
+        format: format,
+        metadata: kaiData.song || kaiData.metadata || {},
+        lyrics: kaiData.lyrics,
+      });
+
+      console.log(`${format.toUpperCase()} file saved successfully`);
+      return { success: true };
+    } catch (error) {
+      console.error('Failed to save song file:', error);
+      return { success: false, error: error.message };
+    }
+  });
+
+  // Reload song file in player (KAI or M4A)
+  ipcMain.handle('editor:reloadKai', async (event, filePath) => {
+    try {
+      console.log('Reload song file request:', filePath);
+
+      // Determine format and call appropriate loader
+      const lowerPath = filePath.toLowerCase();
+      let result;
+
+      if (lowerPath.endsWith('.kai')) {
+        result = await mainApp.loadKaiFile(filePath);
+      } else if (lowerPath.endsWith('.m4a') || lowerPath.endsWith('.mp4')) {
+        result = await mainApp.loadM4AFile(filePath);
+      } else {
+        throw new Error('Unsupported file format');
+      }
+
+      if (result && result.success) {
+        console.log('Song file reloaded successfully');
+        return { success: true };
+      } else {
+        console.error('Failed to reload song file');
+        return { success: false, error: 'Failed to reload file' };
+      }
+    } catch (error) {
+      console.error('Failed to reload song file:', error);
+      return { success: false, error: error.message };
+    }
+  });
+}

package/src/main/handlers/effectsHandlers.js

@@ -0,0 +1,100 @@
+/**
+ * Effects IPC Handlers
+ * Handles all visual effects management operations
+ */
+
+import { ipcMain } from 'electron';
+import * as effectsService from '../../shared/services/effectsService.js';
+
+/**
+ * Register all effects-related IPC handlers
+ * @param {Object} mainApp - Main application instance
+ */
+export function registerEffectsHandlers(mainApp) {
+  // Get list of all effects
+  ipcMain.handle('effects:getList', async () => {
+    try {
+      // Send message to renderer to get effects list
+      return await mainApp.sendToRendererAndWait('effects:getList');
+    } catch (error) {
+      console.error('Failed to get effects list:', error);
+      return [];
+    }
+  });
+
+  // Get currently selected effect
+  ipcMain.handle('effects:getCurrent', async () => {
+    try {
+      return await mainApp.sendToRendererAndWait('effects:getCurrent');
+    } catch (error) {
+      console.error('Failed to get current effect:', error);
+      return null;
+    }
+  });
+
+  // Get list of disabled effects
+  ipcMain.handle('effects:getDisabled', async () => {
+    try {
+      return await mainApp.sendToRendererAndWait('effects:getDisabled');
+    } catch (error) {
+      console.error('Failed to get disabled effects:', error);
+      return [];
+    }
+  });
+
+  // Select an effect
+  ipcMain.handle('effects:select', (event, effectName) => {
+    try {
+      // Update AppState so web admin and other clients can see current effect
+      mainApp.appState.updateEffectsState({ current: effectName });
+      return { success: true };
+    } catch (error) {
+      console.error('Failed to select effect:', error);
+      return { success: false, error: error.message };
+    }
+  });
+
+  // Toggle effect enabled/disabled
+  ipcMain.handle('effects:toggle', (event, effectName, enabled) => {
+    try {
+      mainApp.sendToRenderer('effects:toggle', { effectName, enabled });
+      return { success: true };
+    } catch (error) {
+      console.error('Failed to toggle effect:', error);
+      return { success: false, error: error.message };
+    }
+  });
+
+  // Go to next effect
+  ipcMain.handle('effects:next', async () => {
+    try {
+      const result = await effectsService.nextEffect(mainApp);
+      return result;
+    } catch (error) {
+      console.error('Failed to go to next effect:', error);
+      return { success: false, error: error.message };
+    }
+  });
+
+  // Go to previous effect
+  ipcMain.handle('effects:previous', async () => {
+    try {
+      const result = await effectsService.previousEffect(mainApp);
+      return result;
+    } catch (error) {
+      console.error('Failed to go to previous effect:', error);
+      return { success: false, error: error.message };
+    }
+  });
+
+  // Select random effect
+  ipcMain.handle('effects:random', async () => {
+    try {
+      const result = await effectsService.randomEffect(mainApp);
+      return result;
+    } catch (error) {
+      console.error('Failed to select random effect:', error);
+      return { success: false, error: error.message };
+    }
+  });
+}

package/src/main/handlers/fileHandlers.js

@@ -0,0 +1,45 @@
+/**
+ * File IPC Handlers
+ * Handles file operations like open dialogs and file loading
+ */
+
+import { ipcMain, dialog } from 'electron';
+import { validateSongPath } from '../utils/pathValidator.js';
+
+/**
+ * Register all file-related IPC handlers
+ * @param {Object} mainApp - Main application instance
+ */
+export function registerFileHandlers(mainApp) {
+  // Open file dialog to select karaoke file (M4A or KAI)
+  ipcMain.handle('file:openKai', async () => {
+    const result = await dialog.showOpenDialog(mainApp.mainWindow, {
+      filters: [
+        { name: 'Karaoke Files', extensions: ['m4a', 'kai'] },
+        { name: 'M4A Stems (recommended)', extensions: ['m4a'] },
+        { name: 'KAI Files (legacy)', extensions: ['kai'] },
+      ],
+      properties: ['openFile'],
+    });
+
+    if (!result.canceled && result.filePaths.length > 0) {
+      return await mainApp.loadKaiFile(result.filePaths[0]);
+    }
+    return null;
+  });
+
+  // Load KAI file from path (with path traversal protection)
+  ipcMain.handle('file:loadKaiFromPath', async (event, filePath) => {
+    // Get the songs folder from settings
+    const songsFolder = mainApp.settings?.getSongsFolder?.();
+    
+    // Validate the path is within the songs directory
+    const validation = validateSongPath(filePath, songsFolder);
+    if (!validation.valid) {
+      console.error('🚫 Path validation failed:', validation.error, filePath);
+      return { error: validation.error };
+    }
+
+    return await mainApp.loadKaiFile(validation.resolvedPath);
+  });
+}

package/src/main/handlers/index.js

@@ -0,0 +1,78 @@
+/**
+ * IPC Handler Registration
+ * Central registration point for all IPC handlers
+ */
+
+console.log('📦 Loading handler modules...');
+
+import { registerAudioHandlers } from './audioHandlers.js';
+console.log('✓ audioHandlers');
+import { registerMixerHandlers } from './mixerHandlers.js';
+console.log('✓ mixerHandlers');
+import { registerPlayerHandlers } from './playerHandlers.js';
+console.log('✓ playerHandlers');
+import { registerLibraryHandlers } from './libraryHandlers.js';
+console.log('✓ libraryHandlers');
+import { registerSettingsHandlers } from './settingsHandlers.js';
+console.log('✓ settingsHandlers');
+import { registerQueueHandlers } from './queueHandlers.js';
+console.log('✓ queueHandlers');
+import { registerWebServerHandlers } from './webServerHandlers.js';
+console.log('✓ webServerHandlers');
+import { registerCanvasHandlers } from './canvasHandlers.js';
+console.log('✓ canvasHandlers');
+import { registerEffectsHandlers } from './effectsHandlers.js';
+console.log('✓ effectsHandlers');
+import { registerEditorHandlers } from './editorHandlers.js';
+console.log('✓ editorHandlers');
+import { registerPreferencesHandlers } from './preferencesHandlers.js';
+console.log('✓ preferencesHandlers');
+import { registerFileHandlers } from './fileHandlers.js';
+console.log('✓ fileHandlers');
+import { registerRendererHandlers } from './rendererHandlers.js';
+console.log('✓ rendererHandlers');
+import { registerAppHandlers } from './appHandlers.js';
+console.log('✓ appHandlers');
+import { registerAutotuneHandlers } from './autotuneHandlers.js';
+console.log('✓ autotuneHandlers');
+import { registerCreatorHandlers } from './creatorHandlers.js';
+console.log('✓ creatorHandlers');
+
+/**
+ * Register all IPC handlers
+ * @param {Object} mainApp - Main application instance
+ */
+export function registerAllHandlers(mainApp) {
+  console.log('📡 Registering IPC handlers...');
+
+  try {
+    // Core handlers
+    registerAudioHandlers(mainApp);
+    registerMixerHandlers(mainApp);
+    registerPlayerHandlers(mainApp);
+    registerLibraryHandlers(mainApp);
+    registerSettingsHandlers(mainApp);
+    registerQueueHandlers(mainApp);
+
+    // Feature handlers
+    registerWebServerHandlers(mainApp);
+    registerCanvasHandlers(mainApp);
+    registerEffectsHandlers(mainApp);
+    registerEditorHandlers(mainApp);
+    registerPreferencesHandlers(mainApp);
+    registerAutotuneHandlers(mainApp);
+
+    // System handlers
+    registerFileHandlers(mainApp);
+    registerRendererHandlers(mainApp);
+    registerAppHandlers(mainApp);
+
+    // Creator handlers
+    registerCreatorHandlers(mainApp);
+
+    console.log('✅ All IPC handlers registered');
+  } catch (error) {
+    console.error('❌ Failed to register IPC handlers:', error);
+    throw error;
+  }
+}

package/src/main/handlers/libraryHandlers.js

@@ -0,0 +1,96 @@
+/**
+ * Library IPC Handlers
+ * Handles song library management operations
+ */
+
+import { ipcMain, dialog } from 'electron';
+import fsPromises from 'fs/promises';
+import { LIBRARY_CHANNELS } from '../../shared/ipcContracts.js';
+import * as libraryService from '../../shared/services/libraryService.js';
+
+/**
+ * Register all library-related IPC handlers
+ * @param {Object} mainApp - Main application instance
+ */
+export function registerLibraryHandlers(mainApp) {
+  // Get songs folder
+  ipcMain.handle(LIBRARY_CHANNELS.GET_SONGS_FOLDER, () => {
+    return libraryService.getSongsFolder(mainApp);
+  });
+
+  // Set songs folder
+  ipcMain.handle(LIBRARY_CHANNELS.SET_SONGS_FOLDER, async () => {
+    const result = await dialog.showOpenDialog(mainApp.mainWindow, {
+      properties: ['openDirectory'],
+    });
+
+    if (result.canceled || result.filePaths.length === 0) {
+      return { success: false, folder: null };
+    }
+
+    const folder = result.filePaths[0];
+    await mainApp.setSongsFolderAndScan(folder);
+
+    return { success: true, folder };
+  });
+
+  // Scan folder (with cache updates)
+  ipcMain.handle(LIBRARY_CHANNELS.SCAN_FOLDER, async () => {
+    const result = await libraryService.scanLibrary(mainApp, (progress) => {
+      mainApp.sendToRenderer('library:scanProgress', progress);
+    });
+
+    if (result.success) {
+      // Update all caches (mainApp, webServer, disk)
+      await libraryService.updateLibraryCache(mainApp, result.files);
+    }
+
+    return result;
+  });
+
+  // Sync library (with cache updates)
+  ipcMain.handle(LIBRARY_CHANNELS.SYNC_LIBRARY, async () => {
+    const result = await libraryService.syncLibrary(mainApp, (progress) => {
+      mainApp.sendToRenderer('library:scanProgress', progress);
+    });
+
+    if (result.success) {
+      // Update all caches (mainApp, webServer, disk)
+      await libraryService.updateLibraryCache(mainApp, result.files);
+
+      // Return with 'songs' key for renderer compatibility
+      return {
+        ...result,
+        songs: result.files,
+      };
+    }
+
+    return result;
+  });
+
+  // Get cached songs
+  ipcMain.handle(LIBRARY_CHANNELS.GET_CACHED_SONGS, () => {
+    return libraryService.getCachedSongs(mainApp);
+  });
+
+  // Get song info (with file size)
+  ipcMain.handle(LIBRARY_CHANNELS.GET_SONG_INFO, async (event, filePath) => {
+    const result = await libraryService.getSongInfo(mainApp, filePath);
+
+    // For compatibility with existing code, wrap result if needed
+    if (result.success && result.song) {
+      // Get file size if not already present
+      if (!result.song.fileSize) {
+        try {
+          const stats = await fsPromises.stat(filePath);
+          result.song.fileSize = stats.size;
+        } catch {
+          result.song.fileSize = 0;
+        }
+      }
+      return result.song;
+    }
+
+    return result;
+  });
+}

package/src/main/handlers/mixerHandlers.js

@@ -0,0 +1,64 @@
+/**
+ * Mixer IPC Handlers
+ * Handles all mixer control operations
+ */
+
+import { ipcMain } from 'electron';
+import { MIXER_CHANNELS } from '../../shared/ipcContracts.js';
+import * as mixerService from '../../shared/services/mixerService.js';
+
+/**
+ * Register all mixer-related IPC handlers
+ * @param {Object} mainApp - Main application instance
+ */
+export function registerMixerHandlers(mainApp) {
+  // Set master gain
+  ipcMain.handle(MIXER_CHANNELS.SET_MASTER_GAIN, (event, bus, gainDb) => {
+    return mixerService.setMasterGain(mainApp, bus, gainDb);
+  });
+
+  // Toggle master mute
+  ipcMain.handle(MIXER_CHANNELS.TOGGLE_MASTER_MUTE, (event, bus) => {
+    return mixerService.toggleMasterMute(mainApp, bus);
+  });
+
+  // Toggle stem mute
+  ipcMain.handle('mixer:toggleMute', (event, stemId, bus) => {
+    if (mainApp.audioEngine) {
+      return mainApp.audioEngine.toggleMute(stemId, bus);
+    }
+    return false;
+  });
+
+  // Toggle stem solo
+  ipcMain.handle('mixer:toggleSolo', (event, stemId) => {
+    if (mainApp.audioEngine) {
+      return mainApp.audioEngine.toggleSolo(stemId);
+    }
+    return false;
+  });
+
+  // Set stem gain
+  ipcMain.handle('mixer:setGain', (event, stemId, gainDb) => {
+    if (mainApp.audioEngine) {
+      return mainApp.audioEngine.setGain(stemId, gainDb);
+    }
+    return false;
+  });
+
+  // Apply mixer preset
+  ipcMain.handle('mixer:applyPreset', (event, presetId) => {
+    if (mainApp.audioEngine) {
+      return mainApp.audioEngine.applyPreset(presetId);
+    }
+    return false;
+  });
+
+  // Recall mixer scene
+  ipcMain.handle('mixer:recallScene', (event, sceneId) => {
+    if (mainApp.audioEngine) {
+      return mainApp.audioEngine.recallScene(sceneId);
+    }
+    return false;
+  });
+}

package/src/main/handlers/playerHandlers.js

@@ -0,0 +1,39 @@
+/**
+ * Player IPC Handlers
+ * Handles playback control operations
+ */
+
+import { ipcMain } from 'electron';
+import { PLAYER_CHANNELS } from '../../shared/ipcContracts.js';
+import * as playerService from '../../shared/services/playerService.js';
+
+/**
+ * Register all player-related IPC handlers
+ * @param {Object} mainApp - Main application instance
+ */
+export function registerPlayerHandlers(mainApp) {
+  // Play
+  ipcMain.handle(PLAYER_CHANNELS.PLAY, () => {
+    return playerService.play(mainApp);
+  });
+
+  // Pause
+  ipcMain.handle(PLAYER_CHANNELS.PAUSE, () => {
+    return playerService.pause(mainApp);
+  });
+
+  // Seek
+  ipcMain.handle(PLAYER_CHANNELS.SEEK, (event, positionSec) => {
+    return playerService.seek(mainApp, positionSec);
+  });
+
+  // Restart
+  ipcMain.handle(PLAYER_CHANNELS.RESTART, () => {
+    return playerService.restart(mainApp);
+  });
+
+  // Next
+  ipcMain.handle(PLAYER_CHANNELS.NEXT, () => {
+    return playerService.playNext(mainApp);
+  });
+}