mytunes-pro 1.5.2__py3-none-any.whl → 1.9.3__py3-none-any.whl

mytunes/app.py

@@ -16,9 +16,18 @@ import unicodedata
 import socket
 import locale
 import signal
+import warnings
+# Suppress urllib3 warning about LibreSSL compatibility
+warnings.filterwarnings("ignore", message=".*urllib3 v2 only supports OpenSSL 1.1.1+.*")
+import webbrowser
+import tempfile
+import shutil
+import pusher
+import requests
+
 
 # Ensure Unicode support
-locale.setlocale(locale.LC_ALL, '')
+# locale.setlocale(locale.LC_ALL, '')
 
 # === [Configuration] ===
 DATA_FILE = os.path.expanduser("~/.pymusic_data.json")
@@ -26,7 +35,7 @@ MPV_SOCKET = "/tmp/mpv_socket"
 LOG_FILE = "/tmp/mytunes_mpv.log"
 PID_FILE = "/tmp/mytunes_mpv.pid"
 APP_NAME = "MyTunes Pro"
-APP_VERSION = "1.5.2"
+APP_VERSION = "1.9.3"
 
 # === [Strings & Localization] ===
 STRINGS = {
@@ -45,8 +54,9 @@ STRINGS = {
         "stopped": "⏹ 정지됨",
         "fav_added": "★ 즐겨찾기에 추가됨",
         "fav_removed": "☆ 즐겨찾기 해제됨",
-        "header_help": "[S/1]검색 [F/2]즐겨찾기 [R/3]기록 [M/4]메인 [A/5]즐찾추가 [SPC]재생/정지 [Vol]+/- [Q/6]이전",
-        "help_guide": "[j/k]이동 [En]선택 [h/q]뒤로 [S/1]검색 [F/2]즐겨찾기 [R/3]기록 [M/4]메인 [A/5]즐찾추가 [SPC]재생/정지",
+        "header_r1": "[S/1]검색 [F/2]즐겨찾기 [R/3]기록 [M/4]메인 [A/5]즐겨찾기추가 [Q/6]뒤로",
+        "header_r2": "[F7]유튜브 [F8]라이브 [F9]라이브공유 [SPC]Play/Stop [+/-]볼륨 [<>]빨리감기",
+        "help_guide": "[j/k]이동 [En]선택 [h/q]뒤로 [S/1]검색 [F/2]즐겨찾기 [R/3]기록 [M/4]메인 [F7]유튜브 [F8]라이브 [F9]라이브공유",
         "menu_main": "☰ 메인 메뉴",
         "menu_search_results": "⌕ YouTube 음악 검색",
         "menu_favorites": "★ 나의 즐겨찾기",
@@ -73,8 +83,9 @@ STRINGS = {
         "stopped": "⏹ Stopped",
         "fav_added": "★ Added to Favorites",
         "fav_removed": "☆ Removed from Favorites",
-        "header_help": "[S/1]Search [F/2]Favs [R/3]Hist [M/4]Main [A/5]Add Fav [SPC]Play/Pause [Vol]+/- [Q/6]Back",
-        "help_guide": "[j/k]Move [En]Select [h/q]Back [S/1]Srch [F/2]Fav [R/3]Hist [M/4]Main [A/5]Add Fav [SPC]P/P",
+        "header_r1": "[S/1]Srch [F/2]Favs [R/3]Hist [M/4]Main [A/5]AddFav [Q/6]Back",
+        "header_r2": "[F7]YT [F8]Live [F9]LiveShare [SPC]Play/Stop [+/-]Vol [<>]Seek",
+        "help_guide": "[j/k]Move [En]Select [h/q]Back [S/1]Srch [F/2]Fav [R/3]Hist [M/4]Main [F7]YT [F8]Live [F9]Share",
         "menu_main": "☰ Main Menu",
         "menu_search_results": "⌕ Search YouTube Music",
         "menu_favorites": "★ My Favorites",
@@ -94,16 +105,22 @@ class DataManager:
         self.data = self.load_data()
         self.favorites_set = {f['url'] for f in self.data.get('favorites', []) if 'url' in f}
         
+        # Auto-fetch country if missing
+        if 'country' not in self.data:
+             threading.Thread(target=self.fetch_country, daemon=True).start()
+
+        
     def load_data(self):
         if not os.path.exists(DATA_FILE):
-            return {"history": [], "favorites": [], "language": "ko", "resume": {}}
+            return {"history": [], "favorites": [], "language": "ko", "resume": {}, "search_results_history": []}
         try:
             with open(DATA_FILE, "r", encoding="utf-8") as f:
                 data = json.load(f)
                 if "resume" not in data: data["resume"] = {}
+                if "search_results_history" not in data: data["search_results_history"] = []
                 return data
         except Exception:
-            return {"history": [], "favorites": [], "language": "ko", "resume": {}}
+            return {"history": [], "favorites": [], "language": "ko", "resume": {}, "search_results_history": []}
 
     def save_data(self):
         with open(DATA_FILE, "w", encoding="utf-8") as f:
@@ -140,6 +157,78 @@ class DataManager:
     def is_favorite(self, url):
         return url in self.favorites_set
 
+    def fetch_country(self):
+        """Fetch country code asynchronously and save."""
+        apis = [
+            ('https://ipapi.co/json/', 'country_code'),
+            ('http://ip-api.com/json/', 'countryCode'),
+            ('https://ipwho.is/', 'country_code')
+        ]
+        
+        for url, key in apis:
+            try:
+                resp = requests.get(url, timeout=3)
+                if resp.status_code == 200:
+                    country = resp.json().get(key)
+                    if country:
+                        self.data['country'] = country
+                        self.save_data()
+                        return
+            except:
+                continue
+        
+        # Fallback to Locale
+        try:
+            loc, _ = locale.getdefaultlocale()
+            if loc:
+                country = loc.split('_')[-1]
+                self.data['country'] = country
+                self.save_data()
+                return
+        except: pass
+        
+        # Final Fallback
+        if 'country' not in self.data:
+            self.data['country'] = 'UN'
+            self.save_data()
+
+    def get_country(self):
+        # If it's US or UN, maybe it was a mistake or fallback, try to refresh once per session?
+        # Actually, let's just use what's there but allow re-fetch if requested.
+        return self.data.get('country', 'UN')
+
+
+    def get_search_history(self):
+        return self.data.get('search_results_history', [])
+
+    def add_search_results(self, items):
+        """Add new search results to history, deduping and limiting to 200."""
+        history = self.data.get('search_results_history', [])
+        
+        # Create a set of existing URLs for fast lookup if needed, 
+        # but since we want to bring duplicates to top or merge, 
+        # let's just filter out any incoming items that are already in history?
+        # Requirement: "Accumulate actual result items... Dedup... Latest first"
+        
+        # Strategy: Prepend new items. Remove duplicates based on URL.
+        # 1. Combine new + old
+        combined = items + history
+        
+        # 2. Dedup (keep first occurrence)
+        seen_urls = set()
+        unique_history = []
+        for item in combined:
+            url = item.get('url')
+            if url and url not in seen_urls:
+                seen_urls.add(url)
+                unique_history.append(item)
+            elif not url: # Should not happen for valid items
+                unique_history.append(item)
+        
+        # 3. Limit to 200
+        self.data['search_results_history'] = unique_history[:200]
+        self.save_data()
+
 # === [Player Logic with Advanced IPC] ===
 class Player:
     def __init__(self):
@@ -156,10 +245,12 @@ class Player:
         # self.cleanup_orphaned_mpv() # Moved to play() per user request
         
     def cleanup_orphaned_mpv(self):
-        # User requested revert to aggressive pkill for reliability
-        # This ensures any previous background instances are killed
+        # Precise pkill to avoid matching the main TUI process
+        # Matches 'mpv ' (with space) or 'mpv' as exact process name
         try:
-            subprocess.run(["pkill", "-f", "mpv"], stderr=subprocess.DEVNULL)
+            subprocess.run(["pkill", "-x", "mpv"], stderr=subprocess.DEVNULL)
+            # Second pass for variants or sub-arguments if needed
+            subprocess.run(["pkill", "-f", "mpv --video=no"], stderr=subprocess.DEVNULL)
         except: pass
         
     def play(self, url, start_pos=0):
@@ -242,7 +333,6 @@ class Player:
             try:
                 self.current_proc.terminate()
                 self.current_proc.wait(timeout=1)
-                self.current_proc.wait(timeout=1)
             except:
                 # If terminate fails, try socket quit
                 try: self.send_cmd(["quit"])
@@ -351,6 +441,19 @@ class MyTunesApp:
             signal.signal(signal.SIGHUP, self.handle_disconnect)
         except: pass
 
+        # Pusher Client
+        try:
+            self.pusher = pusher.Pusher(
+                app_id='2106370',
+                key='44e3d7e4957944c867ec',
+                secret='0be8e65a287bbccc7369',
+                cluster='ap3',
+                ssl=True
+            )
+        except: self.pusher = None
+        self.sent_history = {}
+
+
     def handle_disconnect(self, signum, frame):
         """Auto-background if terminal disconnects."""
         self.stop_on_exit = False
@@ -517,14 +620,24 @@ class MyTunesApp:
             if self.selection_idx > 0:
                 self.selection_idx -= 1
                 if self.selection_idx < self.scroll_offset: self.scroll_offset = self.selection_idx
+            elif current_list:
+                # v1.8.5 - Wrapping: Top to Bottom
+                self.selection_idx = len(current_list) - 1
+                h, _ = self.stdscr.getmaxyx()
+                # Maintain scroll consistency (h - 10 matches draw() layout)
+                list_area_height = h - 10
+                self.scroll_offset = max(0, self.selection_idx - list_area_height + 1)
         elif key == curses.KEY_DOWN or k_char in ['j', 'ㅓ']:
             if self.selection_idx < len(current_list) - 1:
                 self.selection_idx += 1
                 h, _ = self.stdscr.getmaxyx()
-                # Use h - 10 to match inner_h in draw() (h - footer_h(5) - header_top(3) - borders(2))
                 list_area_height = h - 10
                 if self.selection_idx >= self.scroll_offset + list_area_height:
                     self.scroll_offset = self.selection_idx - list_area_height + 1
+            elif current_list:
+                # v1.8.5 - Wrapping: Bottom to Top
+                self.selection_idx = 0
+                self.scroll_offset = 0
 
         # Enter / Select: Enter Only (L moved to Forward)
         elif key == '\n' or key == 10 or key == 13:
@@ -582,11 +695,47 @@ class MyTunesApp:
             self.player.seek(30)
             self.status_msg = "Forward 30s"
             
-        # ESC: Background Play (Exit but keep music)
         elif key == 27:
             self.stop_on_exit = False
             self.running = False
             
+        # Share Track (F9): Real-time Publish
+        elif key == curses.KEY_F9:
+            if current_list and 0 <= self.selection_idx < len(current_list):
+                target_item = current_list[self.selection_idx]
+                url = target_item.get('url')
+                title = target_item.get('title', 'Unknown Title')
+                
+                if url:
+                    # If it's US, try to re-fetch country info one more time (maybe misdetected)
+                    if self.dm.get_country() == 'US':
+                        threading.Thread(target=self.dm.fetch_country, daemon=True).start()
+
+                    # Dedup Check: Using a time-based cooldown (e.g. 5 seconds) for same URL
+                    last_sent_time = self.sent_history.get(url, 0)
+                    if time.time() - last_sent_time < 5:
+                        self.status_msg = "⚠️  Already Shared Recently!"
+                    else:
+                        try:
+                            # Send to Pusher
+                            payload = {
+                                "title": title,
+                                "url": url,
+                                "duration": target_item.get('duration', '--:--'),
+                                "country": self.dm.get_country(),
+                                "timestamp": time.time()
+                            }
+                            if self.pusher:
+                                self.pusher.trigger('mytunes-global', 'share-track', payload)
+                                self.sent_history[url] = time.time()
+                                safe_title = self.truncate(title, 50)
+                                self.status_msg = f"🚀 Shared: {safe_title}..."
+                            else:
+                                self.status_msg = "❌ Pusher Error"
+                        except Exception as e:
+                            self.status_msg = f"❌ Share Failed: {str(e)}"
+
+            
         # Add to Favorites: A, ㅁ, 5
         elif k_char in ['a', 'A', 'ㅁ', '5']:
             if current_list and 0 <= self.selection_idx < len(current_list):
@@ -596,6 +745,121 @@ class MyTunesApp:
                     is_added = self.dm.toggle_favorite(target_item)
                     self.status_msg = self.t("fav_added") if is_added else self.t("fav_removed")
 
+        # Open in Browser (YouTube): F7
+        elif key == curses.KEY_F7:
+            if current_list and 0 <= self.selection_idx < len(current_list):
+                target_item = current_list[self.selection_idx]
+                url = target_item.get('url')
+                if url:
+                    if self.is_remote():
+                        self.show_copy_dialog("YouTube", url)
+                    else:
+                        # v1.8.4 - Use standard webbrowser library for maximum stability on F7
+                        self.status_msg = "🌐 Opening YouTube in Browser..."
+                        threading.Thread(target=webbrowser.open, args=(url,), daemon=True).start()
+
+        # Open Live Station (F8): App Mode with Optimized Flags (v1.8.6)
+        elif key == curses.KEY_F8:
+            live_url = "https://mytunes.postgresql.co.kr/live/"
+            if self.is_remote():
+                self.show_copy_dialog("Live Station", live_url)
+                return
+
+            # v1.9.2 - Critical WSL Fix: Disable Profile Isolation
+            # Executing cmd.exe or managing paths in WSL has proven unstable due to environment differences.
+            # We explicitly DISABLE profile isolation in WSL, using the default Chrome profile data.
+            # This ensures stability at the cost of session isolation.
+            if self.is_wsl():
+                temp_user_data = None
+            else:
+                temp_user_data = os.path.join(tempfile.gettempdir(), f"mytunes_v190_{int(time.time() / 10)}")
+
+            # Optimized Flag Set (Context7 Research)
+            flags = [
+                f"--app={live_url}", 
+                "--window-size=712,800", 
+                "--window-position=100,100",
+                "--no-first-run",
+                "--no-default-browser-check",
+                "--disable-default-apps",
+                "--disable-infobars",
+                "--disable-translate",
+                "--disable-features=Translation",
+                "--disable-save-password-bubble",
+                "--autoplay-policy=no-user-gesture-required",
+                "--new-window",
+                "--disable-extensions"
+            ]
+            
+            # Only add user-data-dir if we have a valid path (Non-WSL)
+            if temp_user_data:
+                flags.append(f"--user-data-dir={temp_user_data}")
+            
+            launched = False
+            # v1.8.4 - Subprocess Isolation (start_new_session) to prevent crashes on WSL/Linux
+            # 1. macOS
+            if sys.platform == 'darwin':
+                browsers = ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome", "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"]
+                for b_path in browsers:
+                    if os.path.exists(b_path):
+                        try:
+                            # Use -na to open a fresh instance
+                            subprocess.Popen(["open", "-na", b_path, "--args"] + flags, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                            launched = True; break
+                        except: pass
+            
+            # 2. Windows Native
+            elif sys.platform == 'win32':
+                win_paths = [
+                    os.path.join(os.environ.get('PROGRAMFILES', ''), 'Google\\Chrome\\Application\\chrome.exe'),
+                    os.path.join(os.environ.get('PROGRAMFILES(X86)', ''), 'Google\\Chrome\\Application\\chrome.exe'),
+                    os.path.join(os.environ.get('LOCALAPPDATA', ''), 'Google\\Chrome\\Application\\chrome.exe'),
+                ]
+                for p in win_paths:
+                    if p and os.path.exists(p):
+                        try:
+                            subprocess.Popen([p] + flags, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                            launched = True; break
+                        except: pass
+            
+            # 3. WSL / Linux (Direct path with session isolation)
+            elif self.is_wsl():
+                wsl_paths = [
+                    "/mnt/c/Program Files/Google/Chrome/Application/chrome.exe",
+                    "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
+                    "/mnt/c/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe",
+                ]
+                for p in wsl_paths:
+                    if os.path.exists(p):
+                        try:
+                            # CRITICAL: start_new_session=True isolates the browser from the TUI process group
+                            # This prevents the TUI from dying when navigating or if the browser has shell issues.
+                            subprocess.Popen([p] + flags, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True)
+                            launched = True; break
+                        except: pass
+                
+                if not launched:
+                    try:
+                        # Fallback for WSL to CMD (path is already converted upstream)
+                        subprocess.Popen(["cmd.exe", "/c", f"start chrome --app={live_url} --user-data-dir={temp_user_data}"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, start_new_session=True)
+                        launched = True
+                    except: pass
+
+            # 4. Native Linux
+            else:
+                for b in ['google-chrome', 'google-chrome-stable', 'brave-browser', 'chromium-browser', 'chromium']:
+                    p = shutil.which(b)
+                    if p:
+                        try:
+                            subprocess.Popen([p] + flags, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL); launched = True; break
+                        except: pass
+
+            if launched:
+                self.status_msg = "📡 Opening Live Popup (712x800)..."
+            else:
+                webbrowser.open(live_url)
+                self.status_msg = "📡 Opening Live Station (Browser)..."
+
     def ask_resume(self, saved_time, track_title):
         self.stdscr.nodelay(False) # Blocking input for dialog
         h, w = self.stdscr.getmaxyx()
@@ -654,6 +918,61 @@ class MyTunesApp:
         self.stdscr.refresh()
         return res
 
+    def is_remote(self):
+        return 'SSH_CONNECTION' in os.environ or 'SSH_CLIENT' in os.environ
+
+    def is_wsl(self):
+        try:
+            if sys.platform != 'linux': return False
+            if os.path.exists('/proc/version'):
+                with open('/proc/version', 'r') as f:
+                    return 'microsoft' in f.read().lower()
+            return False
+        except: return False
+
+    def show_copy_dialog(self, title, url):
+        """Show a dialog with the URL for manual copying in remote sessions."""
+        self.stdscr.nodelay(False)
+        h, w = self.stdscr.getmaxyx()
+        box_h, box_w = 8, min(80, w - 4)
+        box_y, box_x = (h - box_h) // 2, (w - box_w) // 2
+        
+        try:
+            win = curses.newwin(box_h, box_w, box_y, box_x)
+            win.keypad(True)
+            try: win.bkgd(' ', curses.color_pair(1))
+            except: pass
+            
+            win.attron(curses.color_pair(1)); win.box()
+            
+            # Title
+            header = " Remote Link " if self.lang == 'en' else " 원격 링크 "
+            win.addstr(0, 2, header, curses.A_BOLD | curses.color_pair(3))
+            
+            # Content
+            lbl = "Open this URL in your local browser:" if self.lang == 'en' else "아래 주소를 로컬 브라우저에서여세요:"
+            win.addstr(2, 3, lbl, curses.color_pair(1))
+            
+            # URL (Truncate if needed but try to show mostly)
+            disp_url = self.truncate(url, box_w - 6)
+            win.addstr(3, 3, disp_url, curses.color_pair(5) | curses.A_BOLD)
+            
+            # Exit instruction
+            exit_msg = "[Enter/ESC] Close" if self.lang == 'en' else "[Enter/ESC] 닫기"
+            win.addstr(6, box_w - len(exit_msg) - 2, exit_msg, curses.color_pair(1))
+            
+            win.refresh()
+            curses.flushinp()
+            
+            # Wait for key
+            while True:
+                k = win.getch()
+                if k in [10, 13, curses.KEY_ENTER, 27, ord(' ')]: 
+                    break
+        except: pass
+        finally:
+            self.stdscr.timeout(200) # Restore non-blocking
+
     def activate_selection(self, items):
         if not items: return
         item = items[self.selection_idx]
@@ -814,12 +1133,41 @@ class MyTunesApp:
         return "".join(chars).strip()
 
     def prompt_search(self):
-        curses.flushinp() # Clear any buffered keys
+        curses.flushinp()
+        
+        orig_view = self.view_stack[-1]
+        orig_results = list(self.search_results)
+        
+        # Show search history in background using existing 'search' view
+        history = self.dm.get_search_history()
+        if history:
+            self.search_results = history
+            self.selection_idx = 0
+            self.scroll_offset = 0
+            if self.view_stack[-1] != "search":
+                self.view_stack.append("search")
+            self.status_msg = "" # Clear "List is empty" etc.
+            self.draw()
+
         query = self.input_dialog(self.t("search_label"), self.t("search_prompt"))
+        
+        # Handling query result
+        # Note: If user pressed ESC, input_dialog returns "" (per current implementation)
+        # But wait, input_dialog logic: "ESC -> chars = []; break; return "".join(chars).strip()"
+        # So ESC and empty Enter both return "". 
+        # I should check if it's possible to distinguish.
+        
         if query:
             self.status_msg = self.t("searching")
             self.draw()
             self.perform_search(query)
+        else:
+            # Revert if no query and we were just previewing history
+            # But requirement 2: "If Enter with no query, preserve previous search results"
+            # This is tricky because ESC and empty Enter currently both return "".
+            # I will assume "" means "keep current view (history)".
+            # If the user wants to CANCEL and go back to Main, they might need ESC.
+            pass
 
     def perform_search(self, query, page=1):
         try:
@@ -897,8 +1245,16 @@ class MyTunesApp:
                     if self.view_stack[-1] != "search":
                         self.view_stack.append("search")
                     self.selection_idx = 0; self.scroll_offset = 0
+                    
+                    # SAVE to History (Exclude load_more_btn)
+                    items_to_save = [x for x in new if x.get('id') != 'load_more_btn']
+                    self.dm.add_search_results(items_to_save)
+                    
                 else:
                     self.search_results.extend(new)
+                    # Also save subsequent pages to history
+                    items_to_save = [x for x in new if x.get('id') != 'load_more_btn']
+                    self.dm.add_search_results(items_to_save)
                 
                 self.search_page = page
                 self.status_msg = f"Search Done. ({len(self.search_results)-1})" # -1 for button
@@ -925,14 +1281,23 @@ class MyTunesApp:
             self.stdscr.addstr(0, 0, "Window too small!")
             return
 
-        # Header (3 lines)
-        self.draw_box(self.stdscr, 0, 0, 3, w, APP_NAME)
+        # Header (4 lines)
+        self.draw_box(self.stdscr, 0, 0, 4, w, APP_NAME)
         title = self.t("title", APP_VERSION)
-        help_txt = self.t("header_help")
-        gap = w - 4 - self.get_display_width(title) - self.get_display_width(help_txt)
-        if gap < 2: gap = 2
-        hdr_txt = f"{title}{' '*gap}{help_txt}"
-        self.stdscr.addstr(1, 2, self.truncate(hdr_txt, w-4), curses.color_pair(1) | curses.A_BOLD)
+        
+        # Row 1: Nav
+        r1 = self.t("header_r1")
+        gap1 = w - 4 - self.get_display_width(title) - self.get_display_width(r1)
+        if gap1 < 2: gap1 = 2
+        line1 = f"{title}{' '*gap1}{r1}"
+        self.stdscr.addstr(1, 2, self.truncate(line1, w-4), curses.color_pair(1) | curses.A_BOLD)
+
+        # Row 2: Actions
+        r2 = self.t("header_r2")
+        gap2 = w - 4 - self.get_display_width(r2)
+        if gap2 < 2: gap2 = 2
+        line2 = f"{' '*gap2}{r2}"
+        self.stdscr.addstr(2, 2, self.truncate(line2, w-4), curses.color_pair(1) | curses.A_BOLD)
 
         # Footer (5 lines)
         footer_h = 5
@@ -977,7 +1342,7 @@ class MyTunesApp:
                 self.stdscr.addstr(h - 2, 2, f"📢 {msg}", attr)
 
         # List Area (Remaining Middle)
-        list_top = 3
+        list_top = 4
         list_h = h - footer_h - list_top
         self.draw_box(self.stdscr, list_top, 0, list_h, w)
         
@@ -1082,11 +1447,20 @@ class MyTunesApp:
 
     def run(self):
         while self.running:
-            self.loop_count = (self.loop_count + 1) % 1000
-            self.update_playback_state()
-            self.check_autoplay()
-            self.draw()
-            self.handle_input()
+            try:
+                self.loop_count = (self.loop_count + 1) % 1000
+                self.update_playback_state()
+                self.check_autoplay()
+                self.draw()
+                self.handle_input()
+            except Exception as e:
+                # v1.8.4 - Global resilience: Catch and log loop errors instead of crashing
+                try: 
+                    with open("/tmp/mytunes_error.log", "a") as f:
+                        f.write(f"[{time.ctime()}] Loop Error: {str(e)}\n")
+                except: pass
+                # Small sleep to prevent infinite tight loop on persistent error
+                time.sleep(0.1)
         
         if self.stop_on_exit:
             self.player.stop()