git-cli-yt 1.1.8 → 1.2.0

package/bin/cli.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 const { execSync, spawn } = require("child_process");
 const path = require("path");

package/main.py

@@ -1,21 +1,21 @@
 import json
 import os
+import queue
 import socket
 import sys
 import threading
 import time
 from pathlib import Path
 
+import av
 from google.auth.transport.requests import Request
+    
 from google.oauth2.credentials import Credentials
 from google_auth_oauthlib.flow import InstalledAppFlow
 from googleapiclient.discovery import build
 from googleapiclient.errors import HttpError
-
-import av
 import numpy as np
 import sounddevice as sd
-import yt_dlp
 from textual.app import App, ComposeResult
 from textual.containers import Horizontal, Vertical
 from textual.widgets import (
@@ -29,10 +29,12 @@ from textual.widgets import (
     ProgressBar,
     Select,
 )
+import yt_dlp
 
-# Tenta carregar variáveis do .env se existir, sem obrigar o usuário a ter um
+# Tenta carregar variáveis do .env se existir
 try:
     from dotenv import load_dotenv
+
     load_dotenv(Path.cwd() / ".env")
     load_dotenv(Path(__file__).resolve().parent / ".env")
 except ImportError:
@@ -40,7 +42,7 @@ except ImportError:
 
 socket.setdefaulttimeout(15)
 
-# Diretório para salvar o token do usuário na pasta de configurações do sistema
+# Diretório para salvar o token do usuário
 CONFIG_DIR = Path.home() / ".config" / "meu-player-tui"
 CONFIG_DIR.mkdir(parents=True, exist_ok=True)
 TOKEN_FILE = CONFIG_DIR / "token.json"
@@ -48,17 +50,14 @@ TOKEN_FILE = CONFIG_DIR / "token.json"
 SCOPES = ["https://www.googleapis.com/auth/youtube.readonly"]
 MUSIC_CATEGORY_ID = "10"
 
-# Credenciais padrão da aplicação Desktop para o fluxo do usuário
 DEFAULT_CLIENT_ID = os.environ.get(
     "GOOGLE_CLIENT_ID",
-    "50790974670-qshvlqkejhu0ksj76v0t0lpcq3krm593.apps.googleusercontent.com"  # Substitua pelas suas credenciais reais do GCP (Desktop App)
+    "50790974670-qshvlqkejhu0ksj76v0t0lpcq3krm593.apps.googleusercontent.com",
 )
 DEFAULT_CLIENT_SECRET = os.environ.get(
-    "GOOGLE_CLIENT_SECRET",
-    "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"  # Substitua pelas suas credenciais reais do GCP (Desktop App)
+    "GOOGLE_CLIENT_SECRET", "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"
 )
 
-
 def get_client_config():
     """Retorna a configuração OAuth 2.0 padrão para aplicação desktop."""
     return {
@@ -73,12 +72,14 @@ def get_client_config():
 
 
 def get_youtube_service(interactive=False):
-    """Obtém a conexão com a API do YouTube para ver as curtidas do usuário."""
+    """Obtém a conexão com a API do YouTube."""
     creds = None
 
     if TOKEN_FILE.exists():
         try:
-            creds = Credentials.from_authorized_user_file(str(TOKEN_FILE), SCOPES)
+            creds = Credentials.from_authorized_user_file(
+                str(TOKEN_FILE), SCOPES
+            )
         except Exception:
             creds = None
 
@@ -115,79 +116,193 @@ def get_youtube_service(interactive=False):
 
 class MusicPlayerApp(App):
     CSS = """
+    $youtube-bg: #0f0f0f;
+    $youtube-panel: #212121;
+    $youtube-panel-dark: #181818;
+    $youtube-hover: #3f3f3f;
+    $youtube-border: #303030;
+    $youtube-text: #f1f1f1;
+    $youtube-muted: #aaaaaa;
+    $youtube-red: #ff0000;
+    $youtube-red-dark: #cc0000;
+
     Screen {
         layout: vertical;
+        background: $youtube-bg;
+        color: $youtube-text;
+    }
+
+    Header {
+        height: 3;
     }
 
     #main {
         height: 1fr;
+        width: 100%;
+        layout: horizontal;
     }
 
     #sidebar {
-        width: 44;
+        width: 28;
         height: 100%;
-        background: $panel;
-        border-right: heavy $accent;
-        padding: 1;
+        background: $youtube-panel-dark;
+        border-right: solid $youtube-border;
+        padding: 1 1;
     }
 
-    #sidebar Input {
+    #sidebar-title {
+        height: 3;
+        content-align: center middle;
+        text-style: bold;
+        color: $youtube-red;
         margin-bottom: 1;
     }
 
-    #auth-buttons {
-        height: 3;
+    .nav-button {
+        width: 100%;
+        margin-bottom: 1;
+        background: $youtube-panel-dark;
+        color: $youtube-text;
+        border: none;
+    }
+
+    .nav-button:hover {
+        background: $youtube-hover;
+    }
+
+    .nav-button.-primary {
+        background: $youtube-red;
+        color: #ffffff;
+    }
+
+    .nav-button.-primary:hover {
+        background: $youtube-red-dark;
+    }
+
+    #nav-spacer {
+        height: 1fr;
+    }
+
+    #content {
+        width: 1fr;
+        height: 100%;
+        padding: 2 3;
+    }
+
+    .page {
+        width: 100%;
+        height: 100%;
+    }
+
+    .page-title {
+        text-style: bold;
+        color: $youtube-text;
         margin-bottom: 1;
     }
 
-    #auth-buttons Button {
-        margin-right: 1;
+    #search_input {
+        width: 100%;
+        margin-bottom: 1;
+        background: $youtube-panel-dark;
+        color: $youtube-text;
+        border: solid $youtube-border;
+    }
+
+    #search_input:focus {
+        border: solid $youtube-text;
+    }
+
+    #search-toolbar {
+        height: auto;
+        margin-bottom: 1;
+    }
+
+    #filter_select {
+        width: 32;
     }
 
     #results_list {
+        width: 100%;
         height: 1fr;
-        border: solid $accent;
+        background: $youtube-bg;
+        border: solid $youtube-border;
+        margin-top: 1;
     }
 
-    #btn_load_more {
+    #liked_results_list {
         width: 100%;
+        height: 1fr;
+        background: $youtube-bg;
+        border: solid $youtube-border;
         margin-top: 1;
     }
 
-    #content {
-        width: 1fr;
-        height: 100%;
+    #btn_load_more, #btn_liked_load_more {
+        width: 100%;
+        margin-top: 1;
+        background: $youtube-panel;
+        color: $youtube-text;
+        border: solid $youtube-border;
+    }
+
+    #btn_load_more:hover, #btn_liked_load_more:hover {
+        background: $youtube-hover;
+    }
+
+    #liked_hint, #login_hint, #settings_hint {
+        color: $youtube-muted;
+    }
+
+    #login-panel {
+        width: 100%;
+        height: auto;
+        border: round $youtube-border;
+        background: $youtube-panel-dark;
         padding: 2;
-        align: center middle;
+    }
+
+    #login-user {
+        margin: 1 0;
+        text-style: bold;
+    }
+
+    #player {
+        height: 11;
+        width: 100%;
+        background: $youtube-panel;
+        border-top: solid $youtube-border;
+        padding: 1 2;
     }
 
     #now-playing {
+        width: 100%;
+        height: 2;
         text-align: center;
         text-style: bold;
-        margin-bottom: 1;
     }
 
     #visualizer {
+        width: 100%;
+        height: 1;
         text-align: center;
-        color: $success;
-        height: 2;
-        margin-bottom: 1;
+        color: $youtube-red;
     }
 
     #progress-container {
-        height: 3;
+        width: 100%;
+        height: 2;
         align: center middle;
-        margin-bottom: 1;
     }
 
     #progress-container ProgressBar {
         width: 1fr;
+        margin: 0 1;
     }
 
     #volume-container {
+        width: 100%;
         height: 3;
         align: center middle;
-        margin-bottom: 1;
     }
 
     #volume-container Button {
@@ -195,6 +310,7 @@ class MusicPlayerApp(App):
     }
 
     #controls {
+        width: 100%;
         height: 3;
         align: center middle;
     }
@@ -204,8 +320,44 @@ class MusicPlayerApp(App):
     }
 
     #status {
-        margin-top: 1;
-        color: $text-muted;
+        width: 100%;
+        height: 1;
+        text-align: center;
+        color: $youtube-muted;
+    }
+
+    .danger-nav {
+        color: $youtube-red;
+    }
+
+    #controls Button {
+        background: $youtube-panel-dark;
+        color: $youtube-text;
+        border: solid $youtube-border;
+    }
+
+    #controls Button:hover {
+        background: $youtube-hover;
+    }
+
+    #controls #btn_toggle.-primary {
+        background: $youtube-red;
+        color: #ffffff;
+        border: none;
+    }
+
+    #controls #btn_toggle.-primary:hover {
+        background: $youtube-red-dark;
+    }
+
+    #controls #btn_stop.-error {
+        background: $youtube-red;
+        color: #ffffff;
+        border: none;
+    }
+
+    #controls #btn_stop.-error:hover {
+        background: $youtube-red-dark;
     }
     """
 
@@ -239,66 +391,190 @@ class MusicPlayerApp(App):
         self.duration_seconds = 0
         self.current_position_seconds = 0
         self.seek_target_seconds = None
+        self.current_page = "home"
 
     def compose(self) -> ComposeResult:
         yield Header()
 
         with Horizontal(id="main"):
             with Vertical(id="sidebar"):
-                yield Label("[bold]Buscar ou Conta[/bold]")
-                yield Input(placeholder="Nome ou artista...", id="search_input")
-
-                with Horizontal(id="auth-buttons"):
-                    yield Button("🔑 Login", id="btn_login", variant="primary")
-                    yield Button("👍 Curtidas", id="btn_liked", variant="default")
-
-                yield Label("[bold]Filtro de Conteúdo:[/bold]")
-                yield Select(
-                    [("🎵 Apenas Músicas", "music"), ("🎬 Todos os Vídeos", "all")],
-                    value="music",
-                    id="filter_select",
-                    allow_blank=False,
-                )
-
-                yield ListView(id="results_list")
-                yield Button("➕ Carregar Mais Músicas", id="btn_load_more", variant="default")
+                yield Label("🎵 MEU PLAYER", id="sidebar-title")
+                yield Button("🏠  Início", id="btn_home", classes="nav-button", variant="primary")
+                yield Button("❤️  Curtidas", id="btn_liked", classes="nav-button")
+                yield Button("👤  Login", id="btn_login", classes="nav-button")
+                yield Button("⚙️  Configurações", id="btn_settings", classes="nav-button")
+                yield Label("", id="nav-spacer")
+                yield Button("🚪  Sair", id="btn_exit", classes="nav-button danger-nav")
 
             with Vertical(id="content"):
-                yield Label("Nenhuma música selecionada", id="now-playing")
-
-                yield Label("░░░░░░░░░░░░░░░░░░░░", id="visualizer")
-
-                # Linha do Tempo e Progresso
-                with Horizontal(id="progress-container"):
-                    yield Label("00:00 ", id="time_current")
-                    yield ProgressBar(id="song_progress", total=100, show_percentage=False)
-                    yield Label(" 00:00", id="time_total")
-
-                # Controle de Volume
-                with Horizontal(id="volume-container"):
-                    yield Button("🔉 -", id="btn_vol_down")
-                    yield Label(" Volume: 80% ", id="vol_label")
-                    yield Button("🔊 +", id="btn_vol_up")
-
-                with Horizontal(id="controls"):
-                    yield Button("⏪ -10s", id="btn_rewind")
-                    yield Button("▶ / ⏸ (Espaço)", id="btn_toggle", variant="primary")
-                    yield Button("⏩ +10s", id="btn_forward")
-                    yield Button("⏹ Parar", id="btn_stop", variant="error")
-
-                yield Label("Status: Pronto.", id="status")
+                with Vertical(id="home_page", classes="page"):
+                    yield Label("Início", classes="page-title")
+                    yield Input(
+                        placeholder="Pesquise por música, artista ou álbum...",
+                        id="search_input",
+                    )
+                    with Horizontal(id="search-toolbar"):
+                        yield Select(
+                            [
+                                ("🎵 Apenas Músicas", "music"),
+                                ("🎬 Todos os Vídeos", "all"),
+                            ],
+                            value="music",
+                            id="filter_select",
+                            allow_blank=False,
+                        )
+                    yield ListView(id="results_list")
+                    yield Button("➕ Carregar mais", id="btn_load_more")
+
+                with Vertical(id="liked_page", classes="page"):
+                    yield Label("Curtidas", classes="page-title")
+                    yield Label(
+                        "Suas músicas curtidas no YouTube.",
+                        id="liked_hint",
+                    )
+                    yield ListView(id="liked_results_list")
+                    yield Button("➕ Carregar mais", id="btn_liked_load_more")
+
+                with Vertical(id="login_page", classes="page"):
+                    yield Label("Login", classes="page-title")
+                    with Vertical(id="login-panel"):
+                        yield Label("Verificando sessão...", id="login-user")
+                        yield Label(
+                            "Conecte sua conta do YouTube para acessar suas curtidas.",
+                            id="login_hint",
+                        )
+                        yield Button("🔑 Entrar com Google", id="btn_login_action", variant="primary")
+                        yield Button("🔄 Trocar conta", id="btn_logout_account")
+
+                with Vertical(id="settings_page", classes="page"):
+                    yield Label("Configurações", classes="page-title")
+                    yield Label("🚧 Em construção...", id="settings_hint")
+
+        with Vertical(id="player"):
+            yield Label("Nenhuma música selecionada", id="now-playing")
+            yield Label("░░░░░░░░░░░░░░░░░░░░", id="visualizer")
+            with Horizontal(id="progress-container"):
+                yield Label("00:00 ", id="time_current")
+                yield ProgressBar(id="song_progress", total=100, show_percentage=False)
+                yield Label(" 00:00", id="time_total")
+            with Horizontal(id="controls"):
+                yield Button("⏪ -10s", id="btn_rewind")
+                yield Button("▶ / ⏸", id="btn_toggle", variant="primary")
+                yield Button("⏩ +10s", id="btn_forward")
+                yield Button("⏹ Parar", id="btn_stop", variant="error")
+                yield Button("🔉 -", id="btn_vol_down")
+                yield Label("Volume: 80%", id="vol_label")
+                yield Button("🔊 +", id="btn_vol_up")
+            yield Label("Status: Pronto.", id="status")
 
         yield Footer()
 
     def on_mount(self) -> None:
+        self._show_page("home")
+
         def auto_auth():
             self.youtube_api = get_youtube_service(interactive=False)
             status = self.query_one("#status", Label)
             if self.youtube_api:
-                self.call_from_thread(status.update, "[green]Sessão de usuário carregada com sucesso![/green]")
+                self.call_from_thread(
+                    status.update,
+                    "[green]Sessão de usuário carregada com sucesso![/green]",
+                )
+                self.call_from_thread(self._update_login_page)
+            else:
+                self.call_from_thread(self._update_login_page)
 
         threading.Thread(target=auto_auth, daemon=True).start()
 
+    def _show_page(self, page: str) -> None:
+        pages = {
+            "home": "#home_page",
+            "liked": "#liked_page",
+            "login": "#login_page",
+            "settings": "#settings_page",
+        }
+        for name, selector in pages.items():
+            self.query_one(selector).display = name == page
+
+        self.current_page = page
+        nav_buttons = {
+            "home": "#btn_home",
+            "liked": "#btn_liked",
+            "login": "#btn_login",
+            "settings": "#btn_settings",
+        }
+        for name, selector in nav_buttons.items():
+            button = self.query_one(selector, Button)
+            button.variant = "primary" if name == page else "default"
+
+        if page == "login":
+            self._update_login_page()
+
+    def _update_login_page(self) -> None:
+        user_label = self.query_one("#login-user", Label)
+        login_button = self.query_one("#btn_login_action", Button)
+        logout_button = self.query_one("#btn_logout_account", Button)
+
+        if not self.youtube_api:
+            user_label.update("Nenhuma conta conectada")
+            login_button.display = True
+            logout_button.display = False
+            return
+
+        user_label.update("Conta conectada. Carregando usuário...")
+        login_button.display = False
+        logout_button.display = True
+
+        def fetch_user():
+            try:
+                response = self.youtube_api.channels().list(
+                    part="snippet",
+                    mine=True,
+                ).execute()
+                items = response.get("items", [])
+                if items:
+                    name = items[0].get("snippet", {}).get("title", "Conta do YouTube")
+                else:
+                    name = "Conta do YouTube"
+                self.call_from_thread(
+                    user_label.update,
+                    f"👤 {name}",
+                )
+            except Exception:
+                self.call_from_thread(user_label.update, "👤 Conta do YouTube conectada")
+
+        threading.Thread(target=fetch_user, daemon=True).start()
+
+    def _logout_youtube(self) -> None:
+        self._stop_audio()
+        try:
+            if TOKEN_FILE.exists():
+                TOKEN_FILE.unlink()
+        except OSError as e:
+            self.query_one("#status", Label).update(
+                f"[red]Erro ao remover sessão: {e}[/red]"
+            )
+            return
+
+        self.youtube_api = None
+        self.query_one("#status", Label).update("Sessão encerrada.")
+        self._update_login_page()
+
+    def _handle_navigation(self, button_id: str) -> None:
+        if button_id == "btn_home":
+            self._show_page("home")
+        elif button_id == "btn_liked":
+            self._show_page("liked")
+            self.last_query = ""
+            self.next_page_token = None
+            self._fetch_liked_videos()
+        elif button_id == "btn_login":
+            self._show_page("login")
+        elif button_id == "btn_settings":
+            self._show_page("settings")
+        elif button_id == "btn_exit":
+            self.exit()
+
     # --- FILTRAGEM E ATUALIZAÇÃO ---
 
     def on_select_changed(self, event: Select.Changed) -> None:
@@ -315,7 +591,8 @@ class MusicPlayerApp(App):
         else:
             self.filtered_results = list(self.raw_results)
 
-        list_view = self.query_one("#results_list", ListView)
+        list_id = "#liked_results_list" if self.current_page == "liked" else "#results_list"
+        list_view = self.query_one(list_id, ListView)
         list_view.clear()
 
         for item in self.filtered_results:
@@ -323,7 +600,9 @@ class MusicPlayerApp(App):
             list_view.append(ListItem(Label(f"{tag} {item['title']}")))
 
         status = self.query_one("#status", Label)
-        status.update(f"[green]Exibindo {len(self.filtered_results)} item(ns).[/green]")
+        status.update(
+            f"[green]Exibindo {len(self.filtered_results)} item(ns).[/green]"
+        )
 
     # --- AUTENTICAÇÃO E CURTIDAS COM PAGINAÇÃO ---
 
@@ -333,9 +612,14 @@ class MusicPlayerApp(App):
 
         try:
             self.youtube_api = get_youtube_service(interactive=True)
-            self.call_from_thread(status.update, "[green]Login realizado com sucesso![/green]")
+            self.call_from_thread(
+                status.update, "[green]Login realizado com sucesso![/green]"
+            )
+            self.call_from_thread(self._update_login_page)
         except Exception as e:
-            self.call_from_thread(status.update, f"[red]Erro na autenticação: {e}[/red]")
+            self.call_from_thread(
+                status.update, f"[red]Erro na autenticação: {e}[/red]"
+            )
 
     def _fetch_liked_videos(self, load_more=False) -> None:
         status = self.query_one("#status", Label)
@@ -364,9 +648,10 @@ class MusicPlayerApp(App):
                     {
                         "title": item["snippet"]["title"],
                         "url": f"https://www.youtube.com/watch?v={item['id']}",
-                        "is_music": item["snippet"].get("categoryId") == MUSIC_CATEGORY_ID,
+                        "is_music": True,
                     }
                     for item in items
+                    if item.get("snippet", {}).get("categoryId") == MUSIC_CATEGORY_ID
                 ]
 
                 if load_more:
@@ -380,7 +665,9 @@ class MusicPlayerApp(App):
 
             except Exception as e:
                 self.is_loading_more = False
-                self.call_from_thread(status.update, f"[red]Erro ao carregar curtidas: {e}[/red]")
+                self.call_from_thread(
+                    status.update, f"[red]Erro ao carregar curtidas: {e}[/red]"
+                )
 
         if not self.is_loading_more:
             self.is_loading_more = True
@@ -405,28 +692,31 @@ class MusicPlayerApp(App):
         ).start()
 
     def _search_youtube(self, query: str, load_more=False) -> None:
-        offset = len(self.raw_results) + 1 if load_more else 1
+        count = 15
+        search_query = f"ytsearch{count}:{query}"
 
         ydl_opts = {
-            "format": "bestaudio/best/best",
             "quiet": True,
-            "playliststart": offset,
-            "playlistend": offset + 15,
-            "default_search": f"ytsearch{offset + 15}",
-            "noplaylist": True,
+            "extract_flat": True,
+            "no_warnings": True,
+            "nocheckcertificate": True,
+            "extractor_args": {
+                "youtube": {"player_client": ["mweb", "web", "android"]}
+            },
         }
 
         try:
             with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                info = ydl.extract_info(query, download=False)
-                entries = info.get("entries", [])
+                info = ydl.extract_info(search_query, download=False)
+                entries = info.get("entries", []) if info else []
 
                 new_entries = [
                     {
-                        "title": entry.get("title"),
-                        "url": entry.get("webpage_url") or entry.get("url"),
+                        "title": entry.get("title", "Sem título"),
+                        "url": entry.get("url")
+                        or f"https://www.youtube.com/watch?v={entry.get('id')}",
                         "duration": entry.get("duration", 0),
-                        "is_music": entry.get("categories") and "Music" in entry.get("categories") or True,
+                        "is_music": True,
                     }
                     for entry in entries
                     if entry
@@ -456,7 +746,9 @@ class MusicPlayerApp(App):
         elif self.last_source_type == "search" and self.last_query:
             self.is_loading_more = True
             threading.Thread(
-                target=self._search_youtube, args=(self.last_query, True), daemon=True
+                target=self._search_youtube,
+                args=(self.last_query, True),
+                daemon=True,
             ).start()
 
     # --- REPRODUÇÃO E ÁUDIO ---
@@ -476,6 +768,10 @@ class MusicPlayerApp(App):
 
         self._stop_audio()
 
+        self.current_position_seconds = 0
+        self.duration_seconds = 0
+        self.seek_target_seconds = None
+
         now_playing.update(f"[bold cyan]Tocando:[/bold cyan] {track['title']}")
         status.update("[yellow]Obtendo áudio...[/yellow]")
 
@@ -486,81 +782,150 @@ class MusicPlayerApp(App):
             self.stop_event.clear()
             self.pause_event.set()
 
+            pcm_buffer = bytearray()
+            pcm_lock = threading.Lock()
+            played_samples = 0
+
+            def audio_callback(outdata, frames, time_info, status_flags):
+                nonlocal pcm_buffer, played_samples
+                bytes_needed = frames * 2 * 4  # frames * 2 canais * 4 bytes (float32)
+
+                with pcm_lock:
+                    if len(pcm_buffer) >= bytes_needed:
+                        chunk = pcm_buffer[:bytes_needed]
+                        pcm_buffer = pcm_buffer[bytes_needed:]
+                        outdata[:] = np.frombuffer(chunk, dtype=np.float32).reshape(
+                            frames, 2
+                        )
+                        if self.pause_event.is_set():
+                            played_samples += frames
+                    else:
+                        outdata.fill(0)
+
             while retry_count <= max_retries and not self.stop_event.is_set():
                 try:
                     ydl_opts = {
-                        "format": "bestaudio/best",
+                        "format": "bestaudio/best/b",
                         "quiet": True,
+                        "no_warnings": True,
                         "nocheckcertificate": True,
+                        "extractor_args": {
+                            "youtube": {"player_client": ["mweb", "web", "android"]}
+                        },
                     }
 
                     with yt_dlp.YoutubeDL(ydl_opts) as ydl:
                         info = ydl.extract_info(track["url"], download=False)
                         direct_url = info["url"]
                         self.duration_seconds = info.get("duration", 0)
+                        headers = info.get("http_headers", {})
+
+                    headers_str = "".join([f"{k}: {v}\r\n" for k, v in headers.items()])
 
                     container_options = {
-                        "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
+                        "user_agent": headers.get(
+                            "User-Agent",
+                            "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
+                        ),
+                        "headers": headers_str,
                         "reconnect": "1",
                         "reconnect_streamed": "1",
                         "reconnect_delay_max": "5",
                     }
 
                     container = av.open(direct_url, options=container_options)
-                    audio_stream = next(s for s in container.streams if s.type == "audio")
-                    sample_rate = audio_stream.codec_context.sample_rate or 48000
-                    time_base = float(audio_stream.time_base)
 
-                    if self.current_position_seconds > 0:
-                        target_pts = int(self.current_position_seconds / time_base)
-                        container.seek(target_pts, stream=audio_stream)
+                    audio_stream = next(
+                        (s for s in container.streams if s.type == "audio"), None
+                    )
+
+                    if audio_stream is None:
+                        raise ValueError("Nenhuma faixa de áudio encontrada no fluxo do vídeo.")
 
-                    resampler = av.AudioResampler(format="fltp", layout="stereo", rate=sample_rate)
+                    sample_rate = (
+                        audio_stream.codec_context.sample_rate or 48000
+                    )
+                    time_base = float(audio_stream.time_base)
+
+                    resampler = av.AudioResampler(
+                        format="fltp", layout="stereo", rate=sample_rate
+                    )
 
                     with sd.OutputStream(
-                        samplerate=sample_rate, channels=2, dtype="float32"
-                    ) as output_stream:
+                        samplerate=sample_rate,
+                        channels=2,
+                        dtype="float32",
+                        callback=audio_callback,
+                        blocksize=1024,
+                    ):
                         self.is_playing = True
-                        self.call_from_thread(status.update, "[green]Reproduzindo ♪[/green]")
+                        self.call_from_thread(
+                            status.update, "[green]Reproduzindo ♪[/green]"
+                        )
 
-                        for packet in container.demux(audio_stream):
+                        last_ui_update = 0
+
+                        for frame in container.decode(audio_stream):
                             if self.stop_event.is_set():
                                 break
 
+                            # Controla a velocidade de decodificação para não sobrecarregar o buffer
+                            max_buffer_bytes = sample_rate * 2 * 4 * 3  # ~3 segundos de áudio
+                            while len(pcm_buffer) > max_buffer_bytes and not self.stop_event.is_set():
+                                time.sleep(0.05)
+
                             if self.seek_target_seconds is not None:
-                                target_pts = int(self.seek_target_seconds / time_base)
+                                target_pts = int(
+                                    self.seek_target_seconds / time_base
+                                )
                                 container.seek(target_pts, stream=audio_stream)
-                                self.current_position_seconds = self.seek_target_seconds
+                                played_samples = int(self.seek_target_seconds * sample_rate)
+                                with pcm_lock:
+                                    pcm_buffer.clear()
                                 self.seek_target_seconds = None
-                                continue
-
-                            for frame in packet.decode():
-                                if self.stop_event.is_set():
-                                    break
 
-                                self.pause_event.wait()
+                                resampler = av.AudioResampler(
+                                    format="fltp",
+                                    layout="stereo",
+                                    rate=sample_rate,
+                                )
+                                continue
 
-                                if frame.pts is not None:
-                                    self.current_position_seconds = frame.pts * time_base
+                            self.pause_event.wait()
 
-                                resampled_frames = resampler.resample(frame)
-                                if not resampled_frames:
-                                    continue
+                            resampled_frames = resampler.resample(frame)
+                            if not resampled_frames:
+                                continue
 
-                                for r_frame in resampled_frames:
-                                    audio_array = r_frame.to_ndarray()
+                            for r_frame in resampled_frames:
+                                if self.stop_event.is_set():
+                                    break
 
-                                    if audio_array.ndim == 1:
-                                        audio_array = np.vstack((audio_array, audio_array))
+                                audio_array = r_frame.to_ndarray()
+                                if audio_array.ndim == 1:
+                                    audio_array = np.vstack((audio_array, audio_array))
 
-                                    audio_array = audio_array * self.volume
-                                    audio_data = np.ascontiguousarray(audio_array.T, dtype=np.float32)
+                                audio_array = audio_array * self.volume
+                                audio_data = np.ascontiguousarray(audio_array.T, dtype=np.float32)
 
-                                    output_stream.write(audio_data)
+                                with pcm_lock:
+                                    pcm_buffer.extend(audio_data.tobytes())
 
-                                    rms = np.sqrt(np.mean(audio_data ** 2))
+                                # Atualização da interface sincronizada por tempo real de reprodução
+                                current_time = time.time()
+                                if current_time - last_ui_update >= 0.2:
+                                    self.current_position_seconds = played_samples / sample_rate
+                                    rms = np.sqrt(np.mean(audio_data**2)) if len(audio_data) > 0 else 0
                                     self.call_from_thread(self._update_playback_ui, rms)
+                                    last_ui_update = current_time
+
+                        # Aguarda consumir os últimos bytes de áudio no buffer antes de finalizar
+                        while len(pcm_buffer) > 0 and not self.stop_event.is_set():
+                            self.current_position_seconds = played_samples / sample_rate
+                            self.call_from_thread(self._update_playback_ui, 0)
+                            time.sleep(0.1)
 
+                    container.close()
                     break
 
                 except (av.FFmpegError, OSError, Exception) as e:
@@ -571,21 +936,27 @@ class MusicPlayerApp(App):
                     if retry_count <= max_retries:
                         self.call_from_thread(
                             status.update,
-                            f"[yellow]Conexão perdida. Reconectando ({retry_count}/{max_retries})...[/yellow]",
+                            f"[yellow]Reconectando ({retry_count}/{max_retries})...[/yellow]",
                         )
                         time.sleep(1)
                     else:
                         self.is_playing = False
-                        self.call_from_thread(status.update, f"[red]Erro ao tocar: {e}[/red]")
+                        self.call_from_thread(
+                            status.update, f"[red]Erro ao tocar: {e}[/red]"
+                        )
 
             self.is_playing = False
             self.call_from_thread(self._reset_playback_ui)
 
-        self.stream_thread = threading.Thread(target=stream_worker, daemon=True)
+        self.stream_thread = threading.Thread(
+            target=stream_worker, daemon=True
+        )
         self.stream_thread.start()
 
     def _update_playback_ui(self, rms_volume: float) -> None:
-        curr_str = time.strftime("%M:%S", time.gmtime(self.current_position_seconds))
+        curr_str = time.strftime(
+            "%M:%S", time.gmtime(self.current_position_seconds)
+        )
         tot_str = time.strftime("%M:%S", time.gmtime(self.duration_seconds))
 
         self.query_one("#time_current", Label).update(f"{curr_str} ")
@@ -593,7 +964,10 @@ class MusicPlayerApp(App):
 
         progress_bar = self.query_one("#song_progress", ProgressBar)
         if self.duration_seconds > 0:
-            progress_bar.progress = (self.current_position_seconds / self.duration_seconds) * 100
+            progress_bar.progress = min(
+                100.0,
+                (self.current_position_seconds / self.duration_seconds) * 100,
+            )
 
         bars = [" ", " ", "▂", "▃", "▄", "▅", "▆", "▇", "█"]
         level = min(int(rms_volume * 35), len(bars) - 1)
@@ -611,10 +985,14 @@ class MusicPlayerApp(App):
     # --- CONTROLES E ATALHOS ---
 
     def _stop_audio(self) -> None:
+        """Interrompe e encerra síncronamente qualquer thread de reprodução em execução."""
         self.stop_event.set()
         self.pause_event.set()
+
         if self.stream_thread and self.stream_thread.is_alive():
-            self.stream_thread.join(timeout=1.0)
+            if threading.current_thread() != self.stream_thread:
+                self.stream_thread.join(timeout=2.0)
+
         self.is_playing = False
 
     def action_toggle_play(self) -> None:
@@ -639,13 +1017,24 @@ class MusicPlayerApp(App):
 
     def on_button_pressed(self, event: Button.Pressed) -> None:
         b_id = event.button.id
-        if b_id == "btn_toggle":
+        if b_id in {"btn_home", "btn_liked", "btn_login", "btn_settings", "btn_exit"}:
+            self._handle_navigation(b_id)
+        elif b_id == "btn_login_action":
+            self._show_page("login")
+            threading.Thread(
+                target=self._authenticate_youtube, daemon=True
+            ).start()
+        elif b_id == "btn_logout_account":
+            self._logout_youtube()
+        elif b_id == "btn_toggle":
             self.toggle_audio()
         elif b_id == "btn_stop":
             self._stop_audio()
             self._reset_playback_ui()
             self.query_one("#status", Label).update("Reprodução parada.")
-            self.query_one("#now-playing", Label).update("Nenhuma música selecionada")
+            self.query_one("#now-playing", Label).update(
+                "Nenhuma música selecionada"
+            )
         elif b_id == "btn_vol_up":
             self._adjust_volume(0.1)
         elif b_id == "btn_vol_down":
@@ -654,13 +1043,7 @@ class MusicPlayerApp(App):
             self._seek(-10)
         elif b_id == "btn_forward":
             self._seek(10)
-        elif b_id == "btn_login":
-            threading.Thread(target=self._authenticate_youtube, daemon=True).start()
-        elif b_id == "btn_liked":
-            self.last_query = ""
-            self.next_page_token = None
-            self._fetch_liked_videos()
-        elif b_id == "btn_load_more":
+        elif b_id in {"btn_load_more", "btn_liked_load_more"}:
             self._load_more_content()
 
     def toggle_audio(self) -> None:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-cli-yt",
-  "version": "1.1.8",
+  "version": "1.2.0",
   "description": "YouTube TUI Player executável via NPX",
   "main": "bin/cli.js",
   "bin": {