loukai-app 0.3.0

package/src/main/creator/systemChecker.js

@@ -0,0 +1,474 @@
+/**
+ * System Checker - Validates system requirements for the Creator feature
+ *
+ * Checks for:
+ * - Python availability
+ * - PyTorch installation
+ * - Demucs (stem separation)
+ * - Whisper (transcription)
+ * - CREPE (pitch detection)
+ * - FFmpeg (audio processing)
+ * - Downloaded models
+ */
+
+import { existsSync, statSync } from 'fs';
+import { homedir, platform } from 'os';
+import { join } from 'path';
+import { execSync, spawn } from 'child_process';
+
+/**
+ * Get the data directory for loukai creator (Python, models, etc.)
+ * Uses the same base as Electron's userData for consistency
+ */
+export function getCacheDir() {
+  const plat = platform();
+  if (plat === 'darwin') {
+    return join(homedir(), 'Library', 'Application Support', 'loukai', 'creator');
+  } else if (plat === 'win32') {
+    return join(homedir(), 'AppData', 'Local', 'loukai', 'creator');
+  } else {
+    return join(homedir(), '.config', 'loukai', 'creator');
+  }
+}
+
+/**
+ * Get the Python executable path
+ */
+export function getPythonPath() {
+  const cacheDir = getCacheDir();
+  const plat = platform();
+
+  if (plat === 'win32') {
+    return join(cacheDir, 'python', 'python.exe');
+  } else {
+    return join(cacheDir, 'python', 'bin', 'python3');
+  }
+}
+
+/**
+ * Get environment variables for Python processes
+ * Includes cached FFmpeg in PATH so Python scripts can find it
+ */
+export function getPythonEnv() {
+  const cacheDir = getCacheDir();
+  const binDir = join(cacheDir, 'bin');
+
+  // Prepend our bin directory to PATH so cached ffmpeg/ffprobe are found
+  const pathSep = platform() === 'win32' ? ';' : ':';
+  const existingPath = process.env.PATH || process.env.Path || '';
+  const newPath = `${binDir}${pathSep}${existingPath}`;
+
+  return {
+    ...process.env,
+    PATH: newPath,
+    Path: newPath, // Windows uses 'Path'
+    TORCH_HOME: join(cacheDir, 'models', 'torch'),
+    HF_HOME: join(cacheDir, 'models', 'huggingface'),
+    XDG_CACHE_HOME: cacheDir, // For whisper model cache
+  };
+}
+
+/**
+ * Check if a system command is available
+ */
+function checkSystemCommand(command) {
+  try {
+    const plat = platform();
+    const checkCmd = plat === 'win32' ? `where ${command}` : `which ${command}`;
+    execSync(checkCmd, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if Python is installed and get version
+ */
+export function checkPython() {
+  const pythonPath = getPythonPath();
+
+  if (!existsSync(pythonPath)) {
+    return { installed: false, reason: 'not_found' };
+  }
+
+  try {
+    const output = execSync(`"${pythonPath}" --version`, {
+      encoding: 'utf8',
+      timeout: 10000,
+    });
+    const version = output.trim().replace('Python ', '');
+    return { installed: true, version, path: pythonPath };
+  } catch (e) {
+    return { installed: false, reason: 'not_executable', error: e.message };
+  }
+}
+
+/**
+ * Check if a Python package is installed by trying to import it
+ */
+function checkPythonPackage(packageName, versionAttr = '__version__') {
+  const pythonPath = getPythonPath();
+
+  if (!existsSync(pythonPath)) {
+    return { installed: false, reason: 'no_python' };
+  }
+
+  const script = `
+import sys
+try:
+    import ${packageName}
+    version = getattr(${packageName}, '${versionAttr}', 'unknown')
+    print(f"OK:{version}")
+except ImportError as e:
+    print(f"ERROR:{e}")
+`;
+
+  return new Promise((resolve) => {
+    const proc = spawn(pythonPath, ['-c', script], {
+      env: getPythonEnv(),
+      timeout: 30000,
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    proc.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on('close', (_code) => {
+      const output = stdout.trim();
+      if (output.startsWith('OK:')) {
+        const version = output.replace('OK:', '');
+        resolve({ installed: true, version });
+      } else {
+        resolve({ installed: false, reason: 'import_failed', error: output || stderr });
+      }
+    });
+
+    proc.on('error', (err) => {
+      resolve({ installed: false, reason: 'spawn_failed', error: err.message });
+    });
+  });
+}
+
+/**
+ * Check PyTorch and detect GPU availability
+ */
+export function checkPyTorch() {
+  const pythonPath = getPythonPath();
+
+  if (!existsSync(pythonPath)) {
+    return { installed: false, reason: 'no_python' };
+  }
+
+  const script = `
+import sys
+try:
+    import torch
+    version = torch.__version__
+    if torch.cuda.is_available():
+        device = 'cuda'
+    elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available():
+        device = 'mps'
+    else:
+        device = 'cpu'
+    print(f"OK:{version}:{device}")
+except ImportError as e:
+    print(f"ERROR:{e}")
+`;
+
+  return new Promise((resolve) => {
+    const proc = spawn(pythonPath, ['-c', script], {
+      env: getPythonEnv(),
+      timeout: 30000,
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    proc.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on('close', () => {
+      const output = stdout.trim();
+      if (output.startsWith('OK:')) {
+        const [version, device] = output.replace('OK:', '').split(':');
+        resolve({ installed: true, version, device });
+      } else {
+        resolve({ installed: false, reason: 'import_failed', error: output || stderr });
+      }
+    });
+
+    proc.on('error', (err) => {
+      resolve({ installed: false, reason: 'spawn_failed', error: err.message });
+    });
+  });
+}
+
+/**
+ * Check Demucs
+ */
+export function checkDemucs() {
+  return checkPythonPackage('demucs', '__version__');
+}
+
+/**
+ * Check Whisper
+ */
+export function checkWhisper() {
+  return checkPythonPackage('whisper', '__version__');
+}
+
+/**
+ * Check CREPE (torchcrepe)
+ */
+export function checkCrepe() {
+  return checkPythonPackage('torchcrepe', '__version__');
+}
+
+/**
+ * Check SoundFile (audio backend for torchaudio)
+ */
+export function checkSoundFile() {
+  return checkPythonPackage('soundfile', '__version__');
+}
+
+/**
+ * Get the FFmpeg executable path
+ * Returns system ffmpeg if available, otherwise cached version
+ */
+export function getFFmpegPath() {
+  // Check system PATH first
+  if (checkSystemCommand('ffmpeg')) {
+    return 'ffmpeg';
+  }
+
+  // Check cache directory
+  const cacheDir = getCacheDir();
+  const plat = platform();
+  const filename = plat === 'win32' ? 'ffmpeg.exe' : 'ffmpeg';
+  const ffmpegPath = join(cacheDir, 'bin', filename);
+
+  if (existsSync(ffmpegPath)) {
+    return ffmpegPath;
+  }
+
+  // Fallback to assuming it's in PATH
+  return 'ffmpeg';
+}
+
+/**
+ * Check FFmpeg and FFprobe availability
+ * Both binaries are required for Creator functionality
+ */
+export function checkFFmpeg() {
+  const plat = platform();
+  const cacheDir = getCacheDir();
+  const ffmpegFilename = plat === 'win32' ? 'ffmpeg.exe' : 'ffmpeg';
+  const ffprobeFilename = plat === 'win32' ? 'ffprobe.exe' : 'ffprobe';
+
+  let ffmpegFound = false;
+  let ffprobeFound = false;
+  let source = null;
+  let version = null;
+
+  // Check system PATH first
+  if (checkSystemCommand('ffmpeg')) {
+    ffmpegFound = true;
+    source = 'system';
+    try {
+      const output = execSync('ffmpeg -version', { encoding: 'utf8', timeout: 5000 });
+      const versionMatch = output.match(/ffmpeg version (\S+)/);
+      version = versionMatch ? versionMatch[1] : 'unknown';
+    } catch {
+      // Version check failed but ffmpeg exists
+    }
+  }
+
+  if (checkSystemCommand('ffprobe')) {
+    ffprobeFound = true;
+  }
+
+  // If both found in system, we're good
+  if (ffmpegFound && ffprobeFound) {
+    return { installed: true, version, source: 'system' };
+  }
+
+  // Check cache directory for missing binaries
+  const cachedFfmpegPath = join(cacheDir, 'bin', ffmpegFilename);
+  const cachedFfprobePath = join(cacheDir, 'bin', ffprobeFilename);
+
+  if (!ffmpegFound && existsSync(cachedFfmpegPath)) {
+    ffmpegFound = true;
+    source = 'cached';
+  }
+
+  if (!ffprobeFound && existsSync(cachedFfprobePath)) {
+    ffprobeFound = true;
+    source = source || 'cached';
+  }
+
+  // Both must be available
+  if (ffmpegFound && ffprobeFound) {
+    return {
+      installed: true,
+      version,
+      source,
+      ffmpegPath: cachedFfmpegPath,
+      ffprobePath: cachedFfprobePath,
+    };
+  }
+
+  // Report which is missing
+  return {
+    installed: false,
+    ffmpegFound,
+    ffprobeFound,
+    reason:
+      !ffmpegFound && !ffprobeFound
+        ? 'both_missing'
+        : !ffmpegFound
+          ? 'ffmpeg_missing'
+          : 'ffprobe_missing',
+  };
+}
+
+/**
+ * Check if a Whisper model is downloaded
+ */
+export function checkWhisperModel(modelName) {
+  const cacheDir = getCacheDir();
+
+  // Whisper stores models in ~/.cache/whisper/ by default
+  // We redirect via XDG_CACHE_HOME to our cache dir
+  const modelPaths = [
+    join(cacheDir, 'whisper', `${modelName}.pt`),
+    join(homedir(), '.cache', 'whisper', `${modelName}.pt`),
+  ];
+
+  // Expected minimum sizes for models (to detect truncated downloads)
+  const minSizes = {
+    tiny: 70_000_000,
+    base: 130_000_000,
+    small: 450_000_000,
+    medium: 1_400_000_000,
+    large: 2_800_000_000,
+    'large-v2': 2_800_000_000,
+    'large-v3': 2_800_000_000,
+    'large-v3-turbo': 1_500_000_000,
+  };
+
+  for (const modelPath of modelPaths) {
+    if (existsSync(modelPath)) {
+      try {
+        const stats = statSync(modelPath);
+        const minSize = minSizes[modelName] || 0;
+
+        if (stats.size >= minSize) {
+          return { installed: true, path: modelPath, size: stats.size };
+        } else {
+          return { installed: false, reason: 'truncated', size: stats.size, expected: minSize };
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+
+  return { installed: false, reason: 'not_found' };
+}
+
+/**
+ * Check if Demucs model is downloaded
+ */
+export function checkDemucsModel(_modelName = 'htdemucs_ft') {
+  const cacheDir = getCacheDir();
+
+  // Demucs stores models in torch hub cache
+  const checkPaths = [
+    join(cacheDir, 'models', 'torch', 'hub', 'checkpoints'),
+    join(homedir(), '.cache', 'torch', 'hub', 'checkpoints'),
+  ];
+
+  for (const checkPath of checkPaths) {
+    if (existsSync(checkPath)) {
+      // Just check if directory has files - model names vary
+      return { installed: true, path: checkPath };
+    }
+  }
+
+  return { installed: false, reason: 'not_found' };
+}
+
+/**
+ * Perform complete system check
+ */
+export async function checkAllComponents() {
+  const [python, pytorch, soundfile, demucs, whisper, crepe] = await Promise.all([
+    checkPython(),
+    checkPyTorch(),
+    checkSoundFile(),
+    checkDemucs(),
+    checkWhisper(),
+    checkCrepe(),
+  ]);
+
+  const ffmpeg = checkFFmpeg();
+  const whisperModel = checkWhisperModel('large-v3-turbo');
+  const demucsModel = checkDemucsModel('htdemucs_ft');
+
+  const components = {
+    python,
+    pytorch,
+    soundfile,
+    demucs,
+    whisper,
+    crepe,
+    ffmpeg,
+    whisperModel,
+    demucsModel,
+  };
+
+  // Check if all required components are installed
+  const allInstalled =
+    python.installed &&
+    pytorch.installed &&
+    soundfile.installed &&
+    demucs.installed &&
+    whisper.installed &&
+    crepe.installed &&
+    ffmpeg.installed &&
+    whisperModel.installed &&
+    demucsModel.installed;
+
+  return {
+    ...components,
+    allInstalled,
+    cacheDir: getCacheDir(),
+  };
+}
+
+export default {
+  getCacheDir,
+  getPythonPath,
+  getPythonEnv,
+  getFFmpegPath,
+  checkPython,
+  checkPyTorch,
+  checkDemucs,
+  checkWhisper,
+  checkCrepe,
+  checkFFmpeg,
+  checkWhisperModel,
+  checkDemucsModel,
+  checkAllComponents,
+};

package/src/main/handlers/appHandlers.js

@@ -0,0 +1,45 @@
+/**
+ * App IPC Handlers
+ * Handles miscellaneous application operations (app info, song, shell, library, settings)
+ */
+
+import { ipcMain, app, shell } from 'electron';
+import * as libraryService from '../../shared/services/libraryService.js';
+
+/**
+ * Register all app-related IPC handlers
+ * @param {Object} mainApp - Main application instance
+ */
+export function registerAppHandlers(mainApp) {
+  // Get application version
+  ipcMain.handle('app:getVersion', () => {
+    return app.getVersion();
+  });
+
+  // Get current app state snapshot
+  ipcMain.handle('app:getState', () => {
+    return mainApp.appState.getSnapshot();
+  });
+
+  // Get currently loaded song
+  ipcMain.handle('song:getCurrentSong', () => {
+    if (mainApp.currentSong && mainApp.currentSong.metadata) {
+      return {
+        path: mainApp.currentSong.metadata.path || mainApp.currentSong.filePath,
+        title: mainApp.currentSong.metadata.title,
+        artist: mainApp.currentSong.metadata.artist,
+      };
+    }
+    return null;
+  });
+
+  // Open external URL in default browser
+  ipcMain.handle('shell:openExternal', async (event, url) => {
+    await shell.openExternal(url);
+  });
+
+  // Search library for songs
+  ipcMain.handle('library:search', (event, query) => {
+    return libraryService.searchSongs(mainApp, query);
+  });
+}

package/src/main/handlers/audioHandlers.js

@@ -0,0 +1,33 @@
+/**
+ * Audio IPC Handlers
+ * Handles all audio device enumeration and routing
+ */
+
+import { ipcMain } from 'electron';
+import { AUDIO_CHANNELS } from '../../shared/ipcContracts.js';
+
+/**
+ * Register all audio-related IPC handlers
+ * @param {Object} mainApp - Main application instance
+ */
+export function registerAudioHandlers(mainApp) {
+  // Get audio devices
+  ipcMain.handle(AUDIO_CHANNELS.GET_DEVICES, () => {
+    return mainApp.audioEngine ? mainApp.audioEngine.getDevices() : [];
+  });
+
+  // Enumerate audio devices
+  ipcMain.handle(AUDIO_CHANNELS.ENUMERATE_DEVICES, () => {
+    // This will be called from renderer to get real device list
+    return [];
+  });
+
+  // Set audio device
+  ipcMain.handle(AUDIO_CHANNELS.SET_DEVICE, (event, deviceType, deviceId) => {
+    console.log(`🎧 IPC: Setting ${deviceType} device to ${deviceId}`);
+    if (mainApp.audioEngine) {
+      return mainApp.audioEngine.setDevice(deviceType, deviceId);
+    }
+    return false;
+  });
+}

package/src/main/handlers/autotuneHandlers.js

@@ -0,0 +1,28 @@
+/**
+ * Autotune IPC Handlers
+ * Handles autotune audio effect operations
+ */
+
+import { ipcMain } from 'electron';
+
+/**
+ * Register all autotune-related IPC handlers
+ * @param {Object} mainApp - Main application instance
+ */
+export function registerAutotuneHandlers(mainApp) {
+  // Enable/disable autotune
+  ipcMain.handle('autotune:setEnabled', (event, enabled) => {
+    if (mainApp.audioEngine) {
+      return mainApp.audioEngine.setAutotuneEnabled(enabled);
+    }
+    return false;
+  });
+
+  // Update autotune settings
+  ipcMain.handle('autotune:setSettings', (event, settings) => {
+    if (mainApp.audioEngine) {
+      return mainApp.audioEngine.setAutotuneSettings(settings);
+    }
+    return false;
+  });
+}

package/src/main/handlers/canvasHandlers.js

@@ -0,0 +1,84 @@
+/**
+ * Canvas Window IPC Handlers
+ * Handles canvas window management and WebRTC streaming operations
+ */
+
+import { ipcMain } from 'electron';
+
+/**
+ * Register all canvas-related IPC handlers
+ * @param {Object} mainApp - Main application instance
+ */
+export function registerCanvasHandlers(mainApp) {
+  // Open canvas window
+  ipcMain.handle('window:openCanvas', () => {
+    mainApp.createCanvasWindow();
+    return { success: true };
+  });
+
+  // Start canvas streaming
+  ipcMain.handle('canvas:startStreaming', () => {
+    mainApp.startCanvasStreaming();
+    return { success: true };
+  });
+
+  // Stop canvas streaming
+  ipcMain.handle('canvas:stopStreaming', () => {
+    mainApp.stopCanvasStreaming();
+    return { success: true };
+  });
+
+  // Send image data to canvas window
+  ipcMain.handle('canvas:sendImageData', (event, imageDataArray, width, height) => {
+    if (mainApp.canvasWindow && !mainApp.canvasWindow.isDestroyed()) {
+      mainApp.canvasWindow.webContents.send(
+        'canvas:receiveImageData',
+        imageDataArray,
+        width,
+        height
+      );
+    }
+  });
+
+  // Canvas window ready signal
+  ipcMain.on('canvas:childReady', () => {
+    console.log('Child window ready, starting canvas streaming');
+    // Small delay to ensure everything is fully initialized
+    setTimeout(() => {
+      mainApp.startCanvasStreaming();
+    }, 100);
+  });
+
+  // Relay ICE candidates between sender and receiver
+  ipcMain.handle('canvas:sendICECandidate', (event, source, candidate) => {
+    console.log('🧊 Relaying ICE candidate from', source);
+    if (source === 'sender') {
+      // Send to receiver via IPC
+      if (mainApp.canvasWindow && !mainApp.canvasWindow.isDestroyed()) {
+        mainApp.canvasWindow.webContents.send('webrtc:addReceiverICECandidate', candidate);
+      }
+    } else if (source === 'receiver') {
+      // Send to sender via IPC
+      if (mainApp.mainWindow && !mainApp.mainWindow.isDestroyed()) {
+        mainApp.mainWindow.webContents.send('webrtc:addICECandidate', candidate);
+      }
+    }
+  });
+
+  // Toggle canvas window fullscreen
+  ipcMain.handle('canvas:toggleFullscreen', (event, shouldBeFullscreen) => {
+    if (mainApp.canvasWindow && !mainApp.canvasWindow.isDestroyed()) {
+      console.log('🖥️ Toggling canvas window fullscreen:', shouldBeFullscreen);
+      mainApp.canvasWindow.setFullScreen(shouldBeFullscreen);
+      return { success: true, fullscreen: shouldBeFullscreen };
+    }
+    return { success: false, error: 'Canvas window not available' };
+  });
+
+  // Send frame to canvas window
+  ipcMain.handle('canvas:sendFrame', (event, dataUrl) => {
+    if (mainApp.canvasWindow && !mainApp.canvasWindow.isDestroyed()) {
+      mainApp.canvasWindow.webContents.send('canvas:receiveFrame', dataUrl);
+    }
+  });
+}