The open-source AI voice studio. Clone, dictate, create.
Fix server binary build, watchdog logging, pedalboard import, window close loop
Jamie Pinef1963740b4dc
diff --git a/backend/build_binary.py b/backend/build_binary.pyindex 9ce7db87..223170aa 100644--- a/backend/build_binary.py+++ b/backend/build_binary.py@@ -10,6 +10,7 @@ import PyInstaller.__main__import argparseimport osimport platform+import sysfrom pathlib import Path@@ -62,6 +63,10 @@ def build_server(cuda=False):'--hidden-import', 'backend.utils.hf_progress','--hidden-import', 'backend.utils.validation','--hidden-import', 'backend.cuda_download',+ '--hidden-import', 'backend.effects',+ '--hidden-import', 'backend.utils.effects',+ '--hidden-import', 'backend.versions',+ '--hidden-import', 'pedalboard','--hidden-import', 'torch','--hidden-import', 'transformers','--hidden-import', 'fastapi',@@ -91,9 +96,10 @@ def build_server(cuda=False):'--hidden-import', 'torch.backends.cudnn',])else:- # Exclude NVIDIA CUDA packages from CPU-only builds to keep binary under 4GB.- # On Linux, pip may pull CUDA-enabled PyTorch by default which includes ~3GB- # of NVIDIA shared libraries that PyInstaller would bundle.+ # Exclude NVIDIA CUDA packages from CPU-only builds to keep binary small.+ # When building from a venv with CUDA torch installed, PyInstaller would+ # bundle ~3GB of NVIDIA shared libraries. We exclude both the Python+ # modules and the binary DLLs.nvidia_packages = ['nvidia', 'nvidia.cublas', 'nvidia.cuda_cupti', 'nvidia.cuda_nvrtc','nvidia.cuda_runtime', 'nvidia.cudnn', 'nvidia.cufft', 'nvidia.curand',@@ -127,7 +133,12 @@ def build_server(cuda=False):elif not cuda:print("Building for non-Apple Silicon platform - PyTorch only")+ dist_dir = str(backend_dir / 'dist')+ build_dir = str(backend_dir / 'build')+args.extend([+ '--distpath', dist_dir,+ '--workpath', build_dir,'--noconfirm','--clean',])@@ -135,12 +146,78 @@ def build_server(cuda=False):# Change to backend directoryos.chdir(backend_dir)+ # For CPU builds on Windows, ensure we're using CPU-only torch.+ # If CUDA torch is installed (local dev), swap to CPU torch before building,+ # then restore CUDA torch after. This prevents PyInstaller from bundling+ # ~3GB of CUDA DLLs into the CPU binary.+ restore_cuda = False+ if not cuda and platform.system() == "Windows":+ import subprocess+ result = subprocess.run(+ [sys.executable, "-c", "import torch; print(torch.version.cuda or '')"],+ capture_output=True, text=True+ )+ has_cuda_torch = bool(result.stdout.strip())+ if has_cuda_torch:+ print("CUDA torch detected — installing CPU torch for CPU build...")+ subprocess.run(+ [sys.executable, "-m", "pip", "install", "torch", "torchvision", "torchaudio",+ "--index-url", "https://download.pytorch.org/whl/cpu", "--force-reinstall", "-q"],+ check=True+ )+ restore_cuda = True+# Run PyInstallerPyInstaller.__main__.run(args)++ # Restore CUDA torch if we swapped it out+ if restore_cuda:+ print("Restoring CUDA torch...")+ import subprocess+ subprocess.run(+ [sys.executable, "-m", "pip", "install", "torch", "torchvision", "torchaudio",+ "--index-url", "https://download.pytorch.org/whl/cu126", "--force-reinstall", "-q"],+ check=True+ )print(f"Binary built in {backend_dir / 'dist' / binary_name}")+def _get_cuda_dll_excludes():+ """Get list of CUDA DLL filenames to exclude from CPU builds.++ When building locally with CUDA torch installed, PyInstaller bundles ~3GB of+ CUDA DLLs from torch/lib/. Returns a list of DLL filenames to exclude.+ """+ try:+ import torch+ torch_lib = Path(torch.__file__).parent / 'lib'+ except ImportError:+ return []++ cuda_prefixes = (+ 'torch_cuda', 'cublas', 'cublasLt', 'cudnn', 'cusparse', 'cufft',+ 'cusolver', 'cusolverMg', 'curand', 'nvrtc', 'nvJitLink', 'nccl',+ 'nvperf', 'nvrtc-builtins',+ )++ exclude_dlls = []+ if torch_lib.exists():+ for f in torch_lib.iterdir():+ if f.suffix == '.dll' and any(f.name.startswith(p) for p in cuda_prefixes):+ exclude_dlls.append(f.name)++ if exclude_dlls:+ total_mb = sum(+ (torch_lib / dll).stat().st_size+ for dll in exclude_dlls+ if (torch_lib / dll).exists()+ ) / 1024 / 1024+ print(f"CPU build: will exclude {len(exclude_dlls)} CUDA DLLs ({total_mb:.0f} MB)")++ return exclude_dlls++if __name__ == '__main__':parser = argparse.ArgumentParser(description="Build voicebox-server binary")parser.add_argument(diff --git a/backend/server.py b/backend/server.pyindex dc2b0da1..2cf6d212 100644--- a/backend/server.py+++ b/backend/server.py@@ -51,7 +51,7 @@ except Exception as e:logger.error(f"Failed to import required modules: {e}", exc_info=True)sys.exit(1)-def _start_parent_watchdog(parent_pid):+def _start_parent_watchdog(parent_pid, data_dir=None):"""Monitor parent process and exit if it dies.This is the clean shutdown mechanism: instead of the Tauri app trying to@@ -63,17 +63,44 @@ def _start_parent_watchdog(parent_pid):import threadingimport time+ # Set up a file logger so we can debug in production+ watchdog_logger = logging.getLogger("watchdog")+ if data_dir:+ try:+ log_dir = os.path.join(data_dir, "logs")+ os.makedirs(log_dir, exist_ok=True)+ fh = logging.FileHandler(os.path.join(log_dir, "watchdog.log"))+ fh.setFormatter(logging.Formatter('%(asctime)s - %(message)s'))+ watchdog_logger.addHandler(fh)+ except Exception:+ pass+ watchdog_logger.setLevel(logging.INFO)+def _is_pid_alive(pid):"""Check if a process with the given PID exists (cross-platform)."""try:if sys.platform == "win32":import ctypeskernel32 = ctypes.windll.kernel32- SYNCHRONIZE = 0x00100000- handle = kernel32.OpenProcess(SYNCHRONIZE, False, pid)+ PROCESS_QUERY_LIMITED_INFORMATION = 0x1000+ handle = kernel32.OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, False, pid)if handle:+ # Check if process has actually exited+ STILL_ACTIVE = 259+ exit_code = ctypes.c_ulong()+ result = kernel32.GetExitCodeProcess(handle, ctypes.byref(exit_code))kernel32.CloseHandle(handle)- return True+ if result and exit_code.value == STILL_ACTIVE:+ return True+ watchdog_logger.info(f"PID {pid}: exited with code {exit_code.value}")+ return False+ # OpenProcess failed — check if it's an access error (process exists+ # but we can't open it) vs process not found+ error = ctypes.GetLastError()+ ACCESS_DENIED = 5+ if error == ACCESS_DENIED:+ return True # process exists, we just can't open it+ watchdog_logger.info(f"PID {pid}: OpenProcess failed, error={error}")return Falseelse:os.kill(pid, 0)@@ -82,13 +109,19 @@ def _start_parent_watchdog(parent_pid):return Falsedef _watch():- logger.info(f"Parent watchdog started, monitoring PID {parent_pid}")+ watchdog_logger.info(f"Parent watchdog started, monitoring PID {parent_pid}, server PID {os.getpid()}")+ # Verify parent is alive before starting the loop+ alive = _is_pid_alive(parent_pid)+ watchdog_logger.info(f"Parent PID {parent_pid} initial check: alive={alive}")+ if not alive:+ watchdog_logger.warning(f"Parent PID {parent_pid} not found on first check — disabling watchdog")+ returnwhile True:if not _is_pid_alive(parent_pid):- logger.info(f"Parent process {parent_pid} no longer exists, shutting down...")+ watchdog_logger.info(f"Parent process {parent_pid} gone, shutting down server...")os.kill(os.getpid(), signal.SIGTERM)return- time.sleep(1)+ time.sleep(2)t = threading.Thread(target=_watch, daemon=True)t.start()@@ -139,9 +172,13 @@ if __name__ == "__main__":os.environ["VOICEBOX_BACKEND_VARIANT"] = "cpu"logger.info("Backend variant: CPU")- # Start parent process watchdog if requested+ # Register parent watchdog to start after server is fully readyif args.parent_pid is not None:- _start_parent_watchdog(args.parent_pid)+ _parent_pid = args.parent_pid+ _data_dir = args.data_dir+ @app.on_event("startup")+ async def _on_startup():+ _start_parent_watchdog(_parent_pid, _data_dir)logger.info(f"Parsed arguments: host={args.host}, port={args.port}, data_dir={args.data_dir}")diff --git a/justfile b/justfileindex 108becc8..9788123a 100644--- a/justfile+++ b/justfile@@ -189,8 +189,10 @@ build-server: _ensure-venv[windows]build-server: _ensure-venv+ $ErrorActionPreference = "Stop"; \$env:PATH = "{{ venv_bin }};$env:PATH"; \& "{{ python }}" backend/build_binary.py; \+ if ($LASTEXITCODE -ne 0) { throw "build_binary.py failed with exit code $LASTEXITCODE" }; \$triple = (rustc --print host-tuple); \Copy-Item "backend/dist/voicebox-server.exe" "{{ tauri_dir }}/src-tauri/binaries/voicebox-server-$triple.exe" -Force; \Write-Host "Copied sidecar: voicebox-server-$triple.exe"diff --git a/tauri/src-tauri/src/main.rs b/tauri/src-tauri/src/main.rsindex ad1bb126..939bb962 100644--- a/tauri/src-tauri/src/main.rs+++ b/tauri/src-tauri/src/main.rs@@ -708,9 +708,17 @@ pub fn run() {play_audio_to_devices,stop_audio_playback])- .on_window_event(|window, event| {+ .on_window_event({+ let closing = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));+ move |window, event| {if let WindowEvent::CloseRequested { api, .. } = event {- // Prevent automatic close+ // If we're already in the close flow, let it proceed+ if closing.load(std::sync::atomic::Ordering::SeqCst) {+ return;+ }+ closing.store(true, std::sync::atomic::Ordering::SeqCst);++ // Prevent automatic close so frontend can clean upapi.prevent_close();// Emit event to frontend to check setting and stop server if needed@@ -718,42 +726,34 @@ pub fn run() {if let Err(e) = app_handle.emit("window-close-requested", ()) {eprintln!("Failed to emit window-close-requested event: {}", e);- // If event emission fails, allow close anywaywindow.close().ok();return;}// Set up listener for frontend responselet window_for_close = window.clone();+ let closing_for_timeout = closing.clone();let (tx, mut rx) = mpsc::unbounded_channel::<()>();- // Listen for response from frontend using window's listen methodlet listener_id = window.listen("window-close-allowed", move |_| {- // Frontend has checked setting and stopped server if needed- // Signal that we can closelet _ = tx.send(());});- // Wait for frontend response or timeout- // Use tauri::async_runtime::spawn instead of tokio::spawn to avoid- // panics when the Tokio runtime is being dropped during app shutdowntauri::async_runtime::spawn(async move {tokio::select! {_ = rx.recv() => {- // Frontend responded, close windowwindow_for_close.close().ok();}_ = tokio::time::sleep(tokio::time::Duration::from_secs(5)) => {- // Timeout - close anywayeprintln!("Window close timeout, closing anyway");window_for_close.close().ok();}}- // Clean up listenerwindow_for_close.unlisten(listener_id);+ closing_for_timeout.store(false, std::sync::atomic::Ordering::SeqCst);});}- })+ }}).build(tauri::generate_context!()).expect("error while building tauri application").run(|app, event| {