karaoke-gen 0.75.53__py3-none-any.whl → 0.76.20__py3-none-any.whl

karaoke_gen/audio_fetcher.py

@@ -264,6 +264,36 @@ class AudioFetcher(ABC):
         """
         pass
 
+    @abstractmethod
+    def download_from_url(
+        self,
+        url: str,
+        output_dir: str,
+        output_filename: Optional[str] = None,
+        artist: Optional[str] = None,
+        title: Optional[str] = None,
+    ) -> AudioFetchResult:
+        """
+        Download audio directly from a URL (e.g., YouTube URL).
+
+        This bypasses the search step and downloads directly from the provided URL.
+        Useful when the user provides a specific YouTube URL rather than artist/title.
+
+        Args:
+            url: The URL to download from (e.g., YouTube video URL)
+            output_dir: Directory to save the downloaded file
+            output_filename: Optional filename (without extension)
+            artist: Optional artist name for metadata
+            title: Optional title for metadata
+
+        Returns:
+            AudioFetchResult with the downloaded file path
+
+        Raises:
+            DownloadError: If download fails
+        """
+        pass
+
 
 class FlacFetchAudioFetcher(AudioFetcher):
     """
@@ -645,6 +675,94 @@ class FlacFetchAudioFetcher(AudioFetcher):
         except Exception as e:
             raise DownloadError(f"Failed to download {artist} - {title}: {e}") from e
 
+    def download_from_url(
+        self,
+        url: str,
+        output_dir: str,
+        output_filename: Optional[str] = None,
+        artist: Optional[str] = None,
+        title: Optional[str] = None,
+    ) -> AudioFetchResult:
+        """
+        Download audio directly from a URL (e.g., YouTube URL).
+
+        Uses flacfetch's download_by_id() method which supports direct YouTube downloads.
+
+        Args:
+            url: The URL to download from (e.g., YouTube video URL)
+            output_dir: Directory to save the downloaded file
+            output_filename: Optional filename (without extension)
+            artist: Optional artist name for metadata
+            title: Optional title for metadata
+
+        Returns:
+            AudioFetchResult with the downloaded file path
+
+        Raises:
+            DownloadError: If download fails
+        """
+        import re
+
+        manager = self._get_manager()
+
+        # Ensure output directory exists
+        os.makedirs(output_dir, exist_ok=True)
+
+        # Detect source type from URL
+        source_name = "YouTube"  # Default to YouTube for now
+        source_id = None
+
+        # Extract YouTube video ID from URL
+        youtube_patterns = [
+            r'(?:youtube\.com/watch\?v=|youtu\.be/)([a-zA-Z0-9_-]{11})',
+            r'youtube\.com/embed/([a-zA-Z0-9_-]{11})',
+            r'youtube\.com/v/([a-zA-Z0-9_-]{11})',
+        ]
+        for pattern in youtube_patterns:
+            match = re.search(pattern, url)
+            if match:
+                source_id = match.group(1)
+                break
+
+        if not source_id:
+            # For other URLs, use the full URL as the source_id
+            source_id = url
+
+        # Generate filename if not provided
+        if output_filename is None:
+            if artist and title:
+                output_filename = f"{artist} - {title}"
+            else:
+                output_filename = source_id
+
+        self.logger.info(f"Downloading from URL: {url}")
+
+        try:
+            filepath = manager.download_by_id(
+                source_name=source_name,
+                source_id=source_id,
+                output_path=output_dir,
+                output_filename=output_filename,
+                download_url=url,  # Pass full URL for direct download
+            )
+
+            if not filepath:
+                raise DownloadError(f"Download returned no file path for URL: {url}")
+
+            self.logger.info(f"Downloaded to: {filepath}")
+
+            return AudioFetchResult(
+                filepath=filepath,
+                artist=artist or "",
+                title=title or "",
+                provider=source_name,
+                duration=None,  # Could extract from yt-dlp info if needed
+                quality=None,
+            )
+
+        except Exception as e:
+            raise DownloadError(f"Failed to download from URL {url}: {e}") from e
+
     def _interruptible_search(self, manager, query) -> list:
         """
         Run search in a way that can be interrupted by Ctrl+C.
@@ -1548,6 +1666,106 @@ class RemoteFlacFetchAudioFetcher(AudioFetcher):
                 print("\nCancelled")
                 raise UserCancelledError("Selection cancelled by user (Ctrl+C)")
 
+    def download_from_url(
+        self,
+        url: str,
+        output_dir: str,
+        output_filename: Optional[str] = None,
+        artist: Optional[str] = None,
+        title: Optional[str] = None,
+    ) -> AudioFetchResult:
+        """
+        Download audio directly from a URL (e.g., YouTube URL).
+
+        For YouTube URLs, this uses local flacfetch since YouTube downloads
+        don't require the remote flacfetch infrastructure (no torrents).
+
+        Args:
+            url: The URL to download from (e.g., YouTube video URL)
+            output_dir: Directory to save the downloaded file
+            output_filename: Optional filename (without extension)
+            artist: Optional artist name for metadata
+            title: Optional title for metadata
+
+        Returns:
+            AudioFetchResult with the downloaded file path
+
+        Raises:
+            DownloadError: If download fails
+        """
+        import re
+
+        self.logger.info(f"[RemoteFlacFetcher] Downloading from URL: {url}")
+        self.logger.info("[RemoteFlacFetcher] Using local flacfetch for YouTube download (no remote API needed)")
+
+        try:
+            # Use local flacfetch for YouTube downloads - no need for remote API
+            # This avoids needing yt-dlp directly in karaoke-gen
+            from flacfetch.core.manager import FetchManager
+            from flacfetch.providers.youtube import YoutubeProvider
+            from flacfetch.downloaders.youtube import YoutubeDownloader
+
+            # Create a minimal local manager for YouTube downloads
+            manager = FetchManager()
+            manager.add_provider(YoutubeProvider())
+            manager.register_downloader("YouTube", YoutubeDownloader())
+
+            # Ensure output directory exists
+            os.makedirs(output_dir, exist_ok=True)
+
+            # Extract video ID from URL
+            source_id = None
+            youtube_patterns = [
+                r'(?:youtube\.com/watch\?v=|youtu\.be/)([a-zA-Z0-9_-]{11})',
+                r'youtube\.com/embed/([a-zA-Z0-9_-]{11})',
+                r'youtube\.com/v/([a-zA-Z0-9_-]{11})',
+            ]
+            for pattern in youtube_patterns:
+                match = re.search(pattern, url)
+                if match:
+                    source_id = match.group(1)
+                    break
+
+            if not source_id:
+                source_id = url
+
+            # Generate filename if not provided
+            if output_filename is None:
+                if artist and title:
+                    output_filename = f"{artist} - {title}"
+                else:
+                    output_filename = source_id
+
+            # Use flacfetch's download_by_id for direct URL download
+            filepath = manager.download_by_id(
+                source_name="YouTube",
+                source_id=source_id,
+                output_path=output_dir,
+                output_filename=output_filename,
+                download_url=url,
+            )
+
+            if not filepath:
+                raise DownloadError(f"Download returned no file path for URL: {url}")
+
+            self.logger.info(f"[RemoteFlacFetcher] Downloaded to: {filepath}")
+
+            return AudioFetchResult(
+                filepath=filepath,
+                artist=artist or "",
+                title=title or "",
+                provider="YouTube",
+                duration=None,
+                quality=None,
+            )
+
+        except ImportError as e:
+            raise DownloadError(
+                f"flacfetch is required for URL downloads but import failed: {e}"
+            ) from e
+        except Exception as e:
+            raise DownloadError(f"Failed to download from URL {url}: {e}") from e
+
 
 # Alias for shorter name
 RemoteFlacFetcher = RemoteFlacFetchAudioFetcher

karaoke_gen/karaoke_gen.py

@@ -31,6 +31,12 @@ from .video_generator import VideoGenerator
 from .video_background_processor import VideoBackgroundProcessor
 from .audio_fetcher import create_audio_fetcher, AudioFetcherError, NoResultsError, UserCancelledError
 
+# Import lyrics_transcriber components for post-review countdown and video rendering
+from lyrics_transcriber.output.countdown_processor import CountdownProcessor
+from lyrics_transcriber.output.generator import OutputGenerator
+from lyrics_transcriber.types import CorrectionResult
+from lyrics_transcriber.core.config import OutputConfig as LyricsOutputConfig
+
 
 class KaraokePrep:
     def __init__(
@@ -482,41 +488,56 @@ class KaraokePrep:
                     self.logger.info(f"Found existing media files matching extractor '{self.extractor}', skipping download/conversion.")
 
                 elif getattr(self, '_use_audio_fetcher', False):
-                    # Use flacfetch to search and download audio
-                    self.logger.info(f"Using flacfetch to search and download: {self.artist} - {self.title}")
-                    
                     try:
-                        # Search and download audio using the AudioFetcher
-                        fetch_result = self.audio_fetcher.search_and_download(
-                            artist=self.artist,
-                            title=self.title,
-                            output_dir=track_output_dir,
-                            output_filename=f"{artist_title} (flacfetch)",
-                            auto_select=self.auto_download,
-                        )
-                        
-                        # Update extractor to reflect the actual provider used
-                        self.extractor = f"flacfetch-{fetch_result.provider}"
-                        
+                        # Check if this is a URL download or search+download
+                        if getattr(self, '_use_url_download', False):
+                            # Direct URL download (e.g., YouTube URL)
+                            self.logger.info(f"Using flacfetch to download from URL: {self.url}")
+
+                            fetch_result = self.audio_fetcher.download_from_url(
+                                url=self.url,
+                                output_dir=track_output_dir,
+                                output_filename=f"{artist_title} (youtube)" if artist_title != "Unknown - Unknown" else None,
+                                artist=self.artist,
+                                title=self.title,
+                            )
+
+                            # Update extractor to reflect the source
+                            self.extractor = "youtube"
+                        else:
+                            # Use flacfetch to search and download audio
+                            self.logger.info(f"Using flacfetch to search and download: {self.artist} - {self.title}")
+
+                            fetch_result = self.audio_fetcher.search_and_download(
+                                artist=self.artist,
+                                title=self.title,
+                                output_dir=track_output_dir,
+                                output_filename=f"{artist_title} (flacfetch)",
+                                auto_select=self.auto_download,
+                            )
+
+                            # Update extractor to reflect the actual provider used
+                            self.extractor = f"flacfetch-{fetch_result.provider}"
+
                         # Set up the output paths
                         output_filename_no_extension = os.path.join(track_output_dir, f"{artist_title} ({self.extractor})")
-                        
+
                         # Copy/move the downloaded file to the expected location
                         processed_track["input_media"] = self.file_handler.download_audio_from_fetcher_result(
                             fetch_result.filepath, output_filename_no_extension
                         )
-                        
+
                         self.logger.info(f"Audio downloaded from {fetch_result.provider}: {processed_track['input_media']}")
-                        
+
                         # Convert to WAV for audio processing
                         self.logger.info("Converting downloaded audio to WAV for processing...")
                         processed_track["input_audio_wav"] = self.file_handler.convert_to_wav(
                             processed_track["input_media"], output_filename_no_extension
                         )
-                        
+
                         # No still image for audio-only downloads
                         processed_track["input_still_image"] = None
-                        
+
                     except UserCancelledError:
                         # User cancelled - propagate up to CLI for graceful exit
                         raise
@@ -692,6 +713,112 @@ class KaraokePrep:
 
                 self.logger.info("=== Parallel Processing Complete ===")
 
+            # === POST-TRANSCRIPTION: Add countdown and render video ===
+            # Since lyrics_processor.py now always defers countdown and video rendering,
+            # we handle it here after human review is complete. This ensures the review UI
+            # shows accurate, unshifted timestamps (same behavior as cloud backend).
+            if processed_track.get("lyrics") and self.render_video:
+                self.logger.info("=== Processing Countdown and Video Rendering ===")
+
+                from .utils import sanitize_filename
+                sanitized_artist = sanitize_filename(self.artist)
+                sanitized_title = sanitize_filename(self.title)
+                lyrics_dir = os.path.join(track_output_dir, "lyrics")
+
+                # Find the corrections JSON file
+                corrections_filename = f"{sanitized_artist} - {sanitized_title} (Lyrics Corrections).json"
+                corrections_filepath = os.path.join(lyrics_dir, corrections_filename)
+
+                if os.path.exists(corrections_filepath):
+                    self.logger.info(f"Loading corrections from: {corrections_filepath}")
+
+                    with open(corrections_filepath, 'r', encoding='utf-8') as f:
+                        corrections_data = json.load(f)
+
+                    # Convert to CorrectionResult
+                    correction_result = CorrectionResult.from_dict(corrections_data)
+                    self.logger.info(f"Loaded CorrectionResult with {len(correction_result.corrected_segments)} segments")
+
+                    # Get the audio file path
+                    audio_path = processed_track["input_audio_wav"]
+
+                    # Add countdown intro if needed (songs that start within 3 seconds)
+                    self.logger.info("Processing countdown intro (if needed)...")
+                    cache_dir = os.path.join(track_output_dir, "cache")
+                    os.makedirs(cache_dir, exist_ok=True)
+
+                    countdown_processor = CountdownProcessor(
+                        cache_dir=cache_dir,
+                        logger=self.logger,
+                    )
+
+                    correction_result, audio_path, padding_added, padding_seconds = countdown_processor.process(
+                        correction_result=correction_result,
+                        audio_filepath=audio_path,
+                    )
+
+                    # Update processed_track with countdown info
+                    processed_track["countdown_padding_added"] = padding_added
+                    processed_track["countdown_padding_seconds"] = padding_seconds
+                    if padding_added:
+                        processed_track["padded_vocals_audio"] = audio_path
+                        self.logger.info(
+                            f"=== COUNTDOWN PADDING ADDED ===\n"
+                            f"Added {padding_seconds}s padding to audio and shifted timestamps.\n"
+                            f"Instrumental tracks will be padded after separation to maintain sync."
+                        )
+                    else:
+                        self.logger.info("No countdown needed - song starts after 3 seconds")
+
+                    # Save the updated corrections with countdown timestamps
+                    updated_corrections_data = correction_result.to_dict()
+                    with open(corrections_filepath, 'w', encoding='utf-8') as f:
+                        json.dump(updated_corrections_data, f, indent=2)
+                    self.logger.info(f"Saved countdown-adjusted corrections to: {corrections_filepath}")
+
+                    # Render video with lyrics
+                    self.logger.info("Rendering karaoke video with synchronized lyrics...")
+
+                    output_config = LyricsOutputConfig(
+                        output_dir=lyrics_dir,
+                        cache_dir=cache_dir,
+                        output_styles_json=self.style_params_json,
+                        render_video=True,
+                        generate_cdg=False,
+                        generate_plain_text=True,
+                        generate_lrc=True,
+                        video_resolution="4k",
+                        subtitle_offset_ms=self.subtitle_offset_ms,
+                    )
+
+                    output_generator = OutputGenerator(output_config, self.logger)
+                    output_prefix = f"{sanitized_artist} - {sanitized_title}"
+
+                    outputs = output_generator.generate_outputs(
+                        transcription_corrected=correction_result,
+                        audio_filepath=audio_path,
+                        output_prefix=output_prefix,
+                    )
+
+                    # Copy video to expected location in parent directory
+                    if outputs and outputs.get("video_filepath"):
+                        source_video = outputs["video_filepath"]
+                        dest_video = os.path.join(track_output_dir, f"{artist_title} (With Vocals).mkv")
+                        shutil.copy2(source_video, dest_video)
+                        self.logger.info(f"Video rendered successfully: {dest_video}")
+                        processed_track["with_vocals_video"] = dest_video
+
+                        # Update ASS filepath for video background processing
+                        if outputs.get("ass_filepath"):
+                            processed_track["ass_filepath"] = outputs["ass_filepath"]
+                    else:
+                        self.logger.warning("Video rendering did not produce expected output")
+                else:
+                    self.logger.warning(f"Corrections file not found: {corrections_filepath}")
+                    self.logger.warning("Skipping countdown processing and video rendering")
+            elif not self.render_video:
+                self.logger.info("Video rendering disabled - skipping countdown and video generation")
+
             # Apply video background if requested and lyrics were processed
             if self.video_background_processor and processed_track.get("lyrics"):
                 self.logger.info("=== Processing Video Background ===")
@@ -991,17 +1118,56 @@ class KaraokePrep:
 
         return tracks
 
+    def _is_url(self, string: str) -> bool:
+        """Check if a string is a URL."""
+        return string is not None and (string.startswith("http://") or string.startswith("https://"))
+
     async def process(self):
         if self.input_media is not None and os.path.isdir(self.input_media):
             self.logger.info(f"Input media {self.input_media} is a local folder, processing each file individually...")
             return await self.process_folder()
         elif self.input_media is not None and os.path.isfile(self.input_media):
             self.logger.info(f"Input media {self.input_media} is a local file, audio download will be skipped")
+            return [await self.prep_single_track()]
+        elif self.input_media is not None and self._is_url(self.input_media):
+            # URL provided - download directly via flacfetch
+            self.logger.info(f"Input media {self.input_media} is a URL, downloading via flacfetch...")
+
+            # Extract video ID for metadata if it's a YouTube URL
+            video_id = None
+            youtube_patterns = [
+                r'(?:youtube\.com/watch\?v=|youtu\.be/)([a-zA-Z0-9_-]{11})',
+                r'youtube\.com/embed/([a-zA-Z0-9_-]{11})',
+                r'youtube\.com/v/([a-zA-Z0-9_-]{11})',
+            ]
+            for pattern in youtube_patterns:
+                match = re.search(pattern, self.input_media)
+                if match:
+                    video_id = match.group(1)
+                    break
+
+            # Set up the extracted_info for metadata consistency
+            self.extracted_info = {
+                "title": f"{self.artist} - {self.title}" if self.artist and self.title else video_id or "Unknown",
+                "artist": self.artist or "",
+                "track_title": self.title or "",
+                "extractor_key": "youtube",
+                "id": video_id or self.input_media,
+                "url": self.input_media,
+                "source": "youtube",
+            }
+            self.extractor = "youtube"
+            self.url = self.input_media
+
+            # Mark that we need to use audio fetcher for URL download
+            self._use_audio_fetcher = True
+            self._use_url_download = True  # New flag for URL-based download
+
             return [await self.prep_single_track()]
         elif self.artist and self.title:
             # No input file provided - use flacfetch to search and download audio
             self.logger.info(f"No input file provided, using flacfetch to search for: {self.artist} - {self.title}")
-            
+
             # Set up the extracted_info for metadata consistency
             self.extracted_info = {
                 "title": f"{self.artist} - {self.title}",
@@ -1014,13 +1180,12 @@ class KaraokePrep:
             }
             self.extractor = "flacfetch"
             self.url = None  # URL will be determined by flacfetch
-            
+
             # Mark that we need to use audio fetcher for download
             self._use_audio_fetcher = True
-            
+
             return [await self.prep_single_track()]
         else:
             raise ValueError(
-                "Either a local file path or both artist and title must be provided. "
-                "URL-based input has been replaced with flacfetch audio fetching."
+                "Either a local file path, a URL, or both artist and title must be provided."
             )

karaoke_gen/lyrics_processor.py

@@ -364,41 +364,30 @@ class LyricsProcessor:
         self.logger.info(f"  rapidapi_key: {env_config.get('rapidapi_key')[:3] + '...' if env_config.get('rapidapi_key') else 'None'}")
         self.logger.info(f"  lyrics_file: {self.lyrics_file}")
 
-        # Detect if we're running in a serverless environment (Modal)
-        # Modal sets specific environment variables we can check for
-        is_serverless = (
-            os.getenv("MODAL_TASK_ID") is not None or 
-            os.getenv("MODAL_FUNCTION_NAME") is not None or
-            os.path.exists("/.modal")  # Modal creates this directory in containers
-        )
-        
-        # In serverless environment, disable interactive review even if skip_transcription_review=False
-        # This preserves CLI behavior while fixing serverless hanging
-        enable_review_setting = not self.skip_transcription_review and not is_serverless
-        
-        if is_serverless and not self.skip_transcription_review:
-            self.logger.info("Detected serverless environment - disabling interactive review to prevent hanging")
-        
-        # In serverless environment, disable video generation during Phase 1 to save compute
-        # Video will be generated in Phase 2 after human review
-        serverless_render_video = render_video and not is_serverless
-        
-        if is_serverless and render_video:
-            self.logger.info("Detected serverless environment - deferring video generation until after review")
-        
+        # Always defer countdown and video rendering to a later phase.
+        # This ensures the review UI (both local and cloud) shows original timing
+        # without the 3-second countdown shift. The caller is responsible for:
+        # - Local CLI: karaoke_gen.py adds countdown and renders video after transcription
+        # - Cloud backend: render_video_worker.py adds countdown and renders video
+        #
+        # This design ensures consistent behavior regardless of environment,
+        # and the review UI always shows accurate, unshifted timestamps.
+        self.logger.info("Deferring countdown and video rendering to post-review phase")
+
         output_config = OutputConfig(
             output_styles_json=self.style_params_json,
             output_dir=lyrics_dir,
-            render_video=serverless_render_video,  # Disable video in serverless Phase 1
+            render_video=False,  # Always defer - caller handles video rendering after countdown
             fetch_lyrics=True,
             run_transcription=not self.skip_transcription,
             run_correction=True,
             generate_plain_text=True,
             generate_lrc=True,
-            generate_cdg=False,  # Also defer CDG generation to Phase 2 
+            generate_cdg=False,  # CDG generation disabled (not currently supported)
             video_resolution="4k",
-            enable_review=enable_review_setting,
+            enable_review=not self.skip_transcription_review,  # Honor the caller's setting
             subtitle_offset_ms=self.subtitle_offset_ms,
+            add_countdown=False,  # Always defer - caller handles countdown after review
         )
 
         # Add this log entry to debug the OutputConfig

karaoke_gen/utils/__init__.py

@@ -1,9 +1,35 @@
 import re
 
+# Unicode character replacements for ASCII-safe filenames
+# These characters cause issues with HTTP headers (latin-1 encoding) and some filesystems
+UNICODE_REPLACEMENTS = {
+    # Curly/smart quotes -> straight quotes
+    "\u2018": "'",  # LEFT SINGLE QUOTATION MARK
+    "\u2019": "'",  # RIGHT SINGLE QUOTATION MARK (the one causing the bug)
+    "\u201A": "'",  # SINGLE LOW-9 QUOTATION MARK
+    "\u201B": "'",  # SINGLE HIGH-REVERSED-9 QUOTATION MARK
+    "\u201C": '"',  # LEFT DOUBLE QUOTATION MARK
+    "\u201D": '"',  # RIGHT DOUBLE QUOTATION MARK
+    "\u201E": '"',  # DOUBLE LOW-9 QUOTATION MARK
+    "\u201F": '"',  # DOUBLE HIGH-REVERSED-9 QUOTATION MARK
+    # Other common problematic characters
+    "\u2013": "-",  # EN DASH
+    "\u2014": "-",  # EM DASH
+    "\u2026": "...",  # HORIZONTAL ELLIPSIS
+    "\u00A0": " ",  # NON-BREAKING SPACE
+}
+
+
 def sanitize_filename(filename):
     """Replace or remove characters that are unsafe for filenames."""
     if filename is None:
         return None
+
+    # First, normalize Unicode characters that cause HTTP header encoding issues
+    # (e.g., curly quotes from macOS/Word that can't be encoded in latin-1)
+    for unicode_char, ascii_replacement in UNICODE_REPLACEMENTS.items():
+        filename = filename.replace(unicode_char, ascii_replacement)
+
     # Replace problematic characters with underscores
     for char in ["\\", "/", ":", "*", "?", '"', "<", ">", "|"]:
         filename = filename.replace(char, "_")

karaoke_gen/utils/cli_args.py

@@ -242,9 +242,17 @@ def create_parser(prog: str = "karaoke-gen") -> argparse.ArgumentParser:
 
     # Style Configuration
     style_group = parser.add_argument_group("Style Configuration")
+    style_group.add_argument(
+        "--theme",
+        help="Optional: Theme ID for pre-made styles stored in GCS (e.g., 'nomad', 'default'). "
+             "When using a theme, CDG/TXT are enabled by default. "
+             "Example: --theme=nomad",
+    )
     style_group.add_argument(
         "--style_params_json",
-        help="Optional: Path to JSON file containing style configuration. Example: --style_params_json='/path/to/style_params.json'",
+        help="Optional: Path to JSON file containing style configuration. "
+             "Takes precedence over --theme if both are provided. "
+             "Example: --style_params_json='/path/to/style_params.json'",
     )
     style_group.add_argument(
         "--style_override",

karaoke_gen/utils/gen_cli.py

@@ -320,7 +320,7 @@ async def async_main():
         # Check if user provided a custom value (not the default hosted URL)
         default_hosted_urls = [
             'https://gen.nomadkaraoke.com/lyrics',
-            'https://lyrics.nomadkaraoke.com'
+            'https://gen.nomadkaraoke.com/lyrics/'
         ]
         if args.review_ui_url.rstrip('/') not in [url.rstrip('/') for url in default_hosted_urls]:
             # User explicitly wants a specific URL (e.g., Vite dev server)