yum-slop/TaSTT

git clone https://git.yummers.dev/yum-slop/TaSTT

yumSwitch to embedded python9a699c72025-07-24

const { app, BrowserWindow, ipcMain } = require('electron');
const path = require('node:path');
const fs = require('node:fs').promises;
const yaml = require('js-yaml');
const { spawn } = require('child_process');
const https = require('https');
const { CONFIG_SCHEMA, getDefaultConfig } = require('./config-schema.js');

// Detect if we're running in development or production
const isDev = !app.isPackaged;
const APP_ROOT = isDev
  ? path.join(__dirname, '..')  // Development: go up from ui/ to project root
  : process.resourcesPath;       // Production: use Electron's resource path

const CONFIG_PATH = path.join(APP_ROOT, 'config.yaml');

let mainWindow;
let runningProcess = null; // Track the running Python process

// Required DLL files for CUDA/cuDNN support
const REQUIRED_DLLS = [
  'cublas64_12.dll',
  'cublasLt64_12.dll',
  'cudnn64_9.dll',
  'cudnn_adv64_9.dll',
  'cudnn_cnn64_9.dll',
  'cudnn_engines_precompiled64_9.dll',
  'cudnn_engines_runtime_compiled64_9.dll',
  'cudnn_graph64_9.dll',
  'cudnn_heuristic64_9.dll',
  'cudnn_ops64_9.dll'
];

// Helper function to get the correct Python executable from embedded python
function getVenvPython() {
  const pythonPath = path.join(APP_ROOT, 'python', 'python.exe');
  return pythonPath;
}

// Helper function to send Python output to renderer
function sendPythonOutput(message, type = 'stdout') {
  if (mainWindow && !mainWindow.isDestroyed()) {
    mainWindow.webContents.send('python-output', { message, type });
  }
}

// Helper function to create environment with DLL path
function createPythonEnvironment() {
  const dllPath = path.join(APP_ROOT, 'dll');
  const binPath = path.join(APP_ROOT, 'python', 'Scripts');
  const env = {};
  env.PATH = `${dllPath};${binPath}`;
  env.HF_HUB_DISABLE_SYMLINKS_WARNING = '1';
  return env;
}

// Helper function to download a file from URL with progress
function downloadFile(url, outputPath) {
  return new Promise((resolve, reject) => {
    const file = require('fs').createWriteStream(outputPath);
    const fileName = path.basename(outputPath);

    const request = https.get(url, (response) => {
      if (response.statusCode === 200) {
        const totalSize = parseInt(response.headers['content-length'], 10);
        let downloadedSize = 0;
        let lastProgressTime = Date.now();

        response.on('data', (chunk) => {
          downloadedSize += chunk.length;

          // Log progress every 5 seconds
          const now = Date.now();
          if (totalSize && (now - lastProgressTime >= 5000)) {
            const progress = Math.round((downloadedSize / totalSize) * 100);
            const mb = (downloadedSize / 1024 / 1024).toFixed(1);
            const totalMb = (totalSize / 1024 / 1024).toFixed(1);
            sendPythonOutput(`Downloading ${fileName}: ${mb}/${totalMb} MB (${progress}%)`, 'info');
            lastProgressTime = now;
          }
        });

        response.pipe(file);

        file.on('finish', () => {
          file.close();
          resolve();
        });

        file.on('error', (err) => {
          fs.unlink(outputPath).catch(() => {}); // Clean up on error
          reject(err);
        });
      } else {
        file.close();
        fs.unlink(outputPath).catch(() => {}); // Clean up on error
        reject(new Error(`Failed to download: HTTP ${response.statusCode}`));
      }
    });

    request.on('error', (err) => {
      file.close();
      fs.unlink(outputPath).catch(() => {}); // Clean up on error
      reject(err);
    });
  });
}

function shouldFilterMessage(message) {
  // Filter out pydub ffmpeg/avconv warning. It does not actually matter.
  if (message.includes("Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work")) {
    return true;
  }
  return false;
}

// Helper function to setup process event handlers
function setupProcessHandlers(process) {
  process.stdout.on('data', (data) => {
    const text = data.toString();
    sendPythonOutput(text.trimEnd(), 'stdout');
  });

  process.stderr.on('data', (data) => {
    const text = data.toString();
    if (!shouldFilterMessage(text)) {
      sendPythonOutput(text.trimEnd(), 'stderr');
    }
  });

  process.on('error', (error) => {
    sendPythonOutput(`Process error: ${error.message}`, 'stderr');
    runningProcess = null;
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('process-stopped');
    }
  });

  process.on('close', (code) => {
    sendPythonOutput(`Process exited with code ${code}`, 'info');
    runningProcess = null;
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('process-stopped');
    }
  });
}

// Helper function to execute Python commands using embedded python
function executePythonCommand(args, options = {}) {
  return new Promise((resolve, reject) => {
    const pythonPath = getVenvPython();
    const commandStr = `${pythonPath} ${args.join(' ')}`;
    sendPythonOutput(`> ${commandStr}`, 'info');

    const spawnOptions = {
      ...options,
      env: createPythonEnvironment()
    };

    const pythonProcess = spawn(pythonPath, args, spawnOptions);

    let stdout = '';
    let stderr = '';

    pythonProcess.stdout.on('data', (data) => {
      const text = data.toString();
      stdout += text;
      sendPythonOutput(text.trimEnd(), 'stdout');
    });

    pythonProcess.stderr.on('data', (data) => {
      const text = data.toString();
      stderr += text;
      // Filter out specific warning messages
      if (!shouldFilterMessage(text)) {
        sendPythonOutput(text.trimEnd(), 'stderr');
      }
    });

    pythonProcess.on('error', (error) => {
      sendPythonOutput(`Failed to start Python process: ${error.message}`, 'stderr');
      reject({ error: error.message, stdout, stderr });
    });

    pythonProcess.on('close', (code) => {
      if (code !== 0) {
        sendPythonOutput(`Process exited with code ${code}`, 'stderr');
        reject({ code, stdout, stderr });
      } else {
        resolve({ stdout, stderr });
      }
    });
  });
}

function createWindow () {
  mainWindow = new BrowserWindow({
    width: 1000,
    height: 800,
    icon: path.join(APP_ROOT, 'Images', 'favicon.ico'),
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
      contextIsolation: true,
      nodeIntegration: false
    }
  });

  mainWindow.loadFile('index.html');
}

// Replace the DEFAULT_CONFIG constant with:
const DEFAULT_CONFIG = getDefaultConfig();

// IPC handlers
ipcMain.handle('load-config', async () => {
  try {
    const fileContent = await fs.readFile(CONFIG_PATH, 'utf8');
    return yaml.load(fileContent);
  } catch (error) {
    if (error.code === 'ENOENT') {
      // Config file doesn't exist, create it with defaults
      console.error('Config file not found, creating with defaults...');
      try {
        const yamlContent = yaml.dump(DEFAULT_CONFIG, { lineWidth: -1 });
        await fs.writeFile(CONFIG_PATH, yamlContent, 'utf8');
        console.error('Created config.yaml with default values');
        return DEFAULT_CONFIG;
      } catch (writeError) {
        console.error('Error creating default config:', writeError);
        // Return defaults even if we can't write the file
        return DEFAULT_CONFIG;
      }
    }
    console.error('Error loading config:', error);
    throw error;
  }
});

ipcMain.handle('save-config', async (event, config) => {
  try {
    const yamlContent = yaml.dump(config, { lineWidth: -1 });
    await fs.writeFile(CONFIG_PATH, yamlContent, 'utf8');
    return { success: true };
  } catch (error) {
    console.error('Error saving config:', error);
    throw error;
  }
});

ipcMain.handle('reset-config', async () => {
  try {
    // Check if the file exists first
    try {
      await fs.access(CONFIG_PATH);
      // File exists, delete it
      await fs.unlink(CONFIG_PATH);
      console.error('Config file deleted successfully');
      return { success: true, message: 'Configuration reset to defaults' };
    } catch (error) {
      if (error.code === 'ENOENT') {
        // Config file doesn't exist, that's fine
        return { success: true, message: 'Configuration already at defaults' };
      }
      throw error;
    }
  } catch (error) {
    console.error('Error resetting config:', error);
    throw new Error(`Failed to reset configuration: ${error.message}`);
  }
});

ipcMain.handle('deleteVenvIndicatorFile', async () => {
  const venvMarkerPath = path.join(APP_ROOT, '.venv_is_set_up');
  try {
    await fs.unlink(venvMarkerPath);
    return { success: true, message: '.venv_is_set_up deleted successfully.' };
  } catch (error) {
    if (error.code === 'ENOENT') {
      return { success: true, message: '.venv_is_set_up not found.' };
    }
    console.error('Error deleting .venv_is_set_up file:', error);
    sendPythonOutput(`Error deleting .venv_is_set_up: ${error.message}`, 'stderr');
    throw error;
  }
});

// Generic function to ensure required files are present
async function ensureRequiredFiles(config) {
  const {
    directoryName,
    requiredFiles,
    downloadBaseUrl,
    resourceType
  } = config;

  const targetPath = path.join(APP_ROOT, directoryName);

  try {
    // Check if target directory exists, create it if not
    try {
      await fs.access(targetPath);
      sendPythonOutput(`${resourceType} directory exists`, 'info');
    } catch (error) {
      if (error.code === 'ENOENT') {
        sendPythonOutput(`Creating ${resourceType} directory...`, 'info');
        await fs.mkdir(targetPath, { recursive: true });
        sendPythonOutput(`${resourceType} directory created`, 'info');
      } else {
        throw error;
      }
    }

    // Check each required file
    const missingFiles = [];
    for (const fileName of requiredFiles) {
      const filePath = path.join(targetPath, fileName);
      try {
        await fs.access(filePath);
        sendPythonOutput(`✓ ${fileName} exists`, 'info');
      } catch (error) {
        if (error.code === 'ENOENT') {
          missingFiles.push(fileName);
          sendPythonOutput(`✗ ${fileName} missing`, 'info');
        } else {
          throw error;
        }
      }
    }

    // Download missing files
    if (missingFiles.length > 0) {
      sendPythonOutput(`Downloading ${missingFiles.length} missing ${resourceType} file${missingFiles.length > 1 ? 's' : ''}...`, 'info');

      for (const fileName of missingFiles) {
        const filePath = path.join(targetPath, fileName);
        const downloadUrl = `${downloadBaseUrl}/${fileName}`;

        try {
          sendPythonOutput(`Downloading ${fileName}...`, 'info');
          await downloadFile(downloadUrl, filePath);
          sendPythonOutput(`✓ Downloaded ${fileName}`, 'info');
        } catch (downloadError) {
          sendPythonOutput(`✗ Failed to download ${fileName}: ${downloadError.message}`, 'stderr');
          throw new Error(`Failed to download ${fileName}: ${downloadError.message}`);
        }
      }

      sendPythonOutput(`All missing ${resourceType} files downloaded successfully`, 'info');
    } else {
      sendPythonOutput(`All required ${resourceType} files are present`, 'info');
    }

    return {
      success: true,
      message: `${resourceType} setup complete. ${missingFiles.length} file${missingFiles.length > 1 ? 's' : ''} downloaded.`,
      downloadedFiles: missingFiles
    };
  } catch (error) {
    console.error(`Error setting up ${resourceType} files:`, error);
    throw new Error(`${resourceType} setup failed: ${error.message}`);
  }
}

// Update the install-requirements handler
ipcMain.handle('install-requirements', async () => {
  const requirementsPath = path.join(APP_ROOT, 'app', 'requirements.txt');
  const venvMarkerPath = path.join(APP_ROOT, '.venv_is_set_up');

  try {
    // Check if venv is already set up
    try {
      await fs.access(venvMarkerPath);
      return { success: true, message: 'Virtual environment already set up' };
    } catch (error) {
      // Marker doesn't exist, proceed with setup
    }

    // Check if requirements.txt exists
    await fs.access(requirementsPath);

    await executePythonCommand(['-m', 'pip', 'install', '-r', requirementsPath]);

    await ensureRequiredFiles({
      directoryName: 'dll',
      requiredFiles: REQUIRED_DLLS,
      downloadBaseUrl: 'https://yummers.dev/tastt/dll',
      resourceType: 'DLL'
    });

    await fs.mkdir(path.join(APP_ROOT, 'Models'), { recursive: true });

    await fs.writeFile(venvMarkerPath, new Date().toISOString(), 'utf8');
    sendPythonOutput('Created .venv_is_set_up marker file', 'info');

    return { success: true, message: 'Requirements and dependencies installed successfully' };
  } catch (error) {
    console.error('Error installing requirements:', error);
    if (error.code === 'ENOENT') {
      throw new Error('requirements.txt not found');
    }

    const errorDetails = error.stderr || error.stdout || error.message || error.error || 'Unknown error';
    throw new Error(`Installation failed: ${errorDetails}`);
  }
});

ipcMain.handle('get-microphones', async () => {
  const scriptPath = path.join(APP_ROOT, 'app', 'list_microphones.py');

  try {
    const result = await executePythonCommand([scriptPath]);
    const microphones = JSON.parse(result.stdout.trim());
    return microphones;
  } catch (error) {
    console.error('Failed to get microphones:', error);
    throw new Error(`Failed to get microphones: ${error.stderr || error.error || 'Unknown error'}`);
  }
});

// Helper function to safely delete directory contents
async function clearDirectory(dirPath, dirName) {
  try {
    await fs.access(dirPath);
    sendPythonOutput(`Clearing ${dirName} directory...`, 'info');

    const files = await fs.readdir(dirPath);
    let deletedCount = 0;

    for (const file of files) {
      const filePath = path.join(dirPath, file);

      try {
        await fs.rm(filePath, { recursive: true, force: true });
        sendPythonOutput(`✗ Deleted file ${file}`, 'info');

        deletedCount++;
      } catch (deleteError) {
        sendPythonOutput(`Warning: Could not delete ${file}: ${deleteError.message}`, 'stderr');
        // Continue with other files even if one fails
      }
    }

    sendPythonOutput(`${dirName} directory cleared`, 'info');
    return deletedCount;
  } catch (error) {
    if (error.code === 'ENOENT') {
      sendPythonOutput(`${dirName} directory doesn't exist, skipping`, 'info');
      return 0;
    } else {
      sendPythonOutput(`Error clearing ${dirName} directory: ${error.message}`, 'stderr');
      throw error;
    }
  }
}

ipcMain.handle('reset-venv', async () => {
  const venvMarkerPath = path.join(APP_ROOT, '.venv_is_set_up');

  try {
    sendPythonOutput('Starting virtual environment reset...', 'info');

    // Delete the venv marker file first
    try {
      await fs.unlink(venvMarkerPath);
      sendPythonOutput('Deleted .venv_is_set_up marker file', 'info');
    } catch (error) {
      if (error.code !== 'ENOENT') {
        sendPythonOutput(`Warning: Could not delete marker file: ${error.message}`, 'stderr');
      }
    }

    // Get list of installed packages
    sendPythonOutput('Getting list of installed packages...', 'info');
    const freezeResult = await executePythonCommand(['-m', 'pip', 'freeze']);
    const installedPackages = freezeResult.stdout.trim();

    let uninstalledPackages = [];

    if (!installedPackages) {
      sendPythonOutput('No packages found to uninstall', 'info');
    } else {
      // Parse package names and filter out core packages
      const packageLines = installedPackages.split('\n').filter(line => line.trim());
      const packageNames = packageLines
        .map(line => line.split('==')[0].trim())
        .filter(name => name && !name.startsWith('#'));

      const corePackages = ['pip', 'setuptools', 'wheel'];
      const packagesToUninstall = packageNames.filter(name => !corePackages.includes(name.toLowerCase()));

      if (packagesToUninstall.length === 0) {
        sendPythonOutput('Only core packages found, nothing to uninstall', 'info');
      } else {
        sendPythonOutput(`Uninstalling ${packagesToUninstall.length} packages...`, 'info');

        const uninstallArgs = ['-m', 'pip', 'uninstall', '-y', ...packagesToUninstall];
        await executePythonCommand(uninstallArgs);
        uninstalledPackages = packagesToUninstall;
      }
    }

    // Clear downloaded files
    sendPythonOutput('Clearing downloaded files...', 'info');

    const dllPath = path.join(APP_ROOT, 'dll');
    const modelsPath = path.join(APP_ROOT, 'Models');
    const binPath = path.join(APP_ROOT, 'bin');

    const deletedDlls = await clearDirectory(dllPath, 'DLL');
    const deletedModels = await clearDirectory(modelsPath, 'Models');
    const deletedBins = await clearDirectory(binPath, 'Binary');

    const totalDeletedFiles = deletedDlls + deletedModels + deletedBins;

    sendPythonOutput('Virtual environment reset successfully!', 'info');

    return {
      success: true,
      message: `Virtual environment reset complete. Uninstalled ${uninstalledPackages.length} packages and deleted ${totalDeletedFiles} downloaded files.`,
      uninstalledPackages,
      deletedFiles: {
        dlls: deletedDlls,
        models: deletedModels,
        binaries: deletedBins,
        total: totalDeletedFiles
      }
    };
  } catch (error) {
    console.error('Error resetting virtual environment:', error);
    throw new Error(`Virtual environment reset failed: ${error.message}`);
  }
});

// Add handlers for starting and stopping the process
ipcMain.handle('start-process', async () => {
  if (runningProcess) {
    throw new Error('Process is already running');
  }

  const scriptPath = path.join(APP_ROOT, 'app', 'hi.py');
  const args = [scriptPath, '--config', CONFIG_PATH];

  try {
    const pythonPath = getVenvPython();
    sendPythonOutput(`Starting process: ${path.basename(pythonPath)} ${args.join(' ')}`, 'info');

    runningProcess = spawn(pythonPath, args, { env: createPythonEnvironment() });
    setupProcessHandlers(runningProcess);

    return { success: true };
  } catch (error) {
    runningProcess = null;
    throw error;
  }
});

ipcMain.handle('stop-process', async () => {
  if (!runningProcess) {
    sendPythonOutput('No process to stop', 'info');
    return { success: true, forcefullyKilled: false };
  }

  return new Promise((resolve) => {
    let forcefullyKilled = false;

    // Set up a timeout to force kill after 10 seconds
    const killTimeout = setTimeout(() => {
      if (runningProcess) {
        sendPythonOutput('Process did not stop gracefully, forcing termination...', 'stderr');
        forcefullyKilled = true;
        runningProcess.kill('SIGKILL');
      }
    }, 10000);

    // Listen for the process to exit
    runningProcess.once('exit', (code, signal) => {
      clearTimeout(killTimeout);
      runningProcess = null;

      if (forcefullyKilled) {
        sendPythonOutput('Process forcefully terminated', 'info');
      } else {
        sendPythonOutput('Process stopped gracefully', 'info');
      }

      resolve({ success: true, forcefullyKilled });
    });

    // Send termination signal
    sendPythonOutput('Stopping process gracefully...', 'info');
    runningProcess.kill('SIGTERM');
  });
});

ipcMain.handle('get-process-state', () => {
  return { isRunning: runningProcess !== null };
});

// Clean up on app quit
app.on('before-quit', () => {
  if (runningProcess) {
    runningProcess.kill();
  }
});

app.whenReady().then(() => {
  createWindow();

  app.on('activate', function () {
    if (BrowserWindow.getAllWindows().length === 0) createWindow();
  });
});

app.on('window-all-closed', function () {
  app.quit();
});