Medios-Macina/cmdnats/pipe.py

from typing import Any, Dict, Sequence, List, Optional
import sys
import json
import platform
import socket
import re
import subprocess
from urllib.parse import urlparse
from pathlib import Path
from cmdlets._shared import Cmdlet, CmdletArg, parse_cmdlet_args
from helper.logger import log, debug
from result_table import ResultTable
from helper.mpv_ipc import get_ipc_pipe_path, MPVIPCClient
import pipeline as ctx
from helper.download import is_url_supported_by_ytdlp

from helper.local_library import LocalLibrarySearchOptimizer
from config import get_local_storage_path, get_hydrus_access_key, get_hydrus_url
from hydrus_health_check import get_cookies_file_path

def _send_ipc_command(command: Dict[str, Any], silent: bool = False) -> Optional[Any]:
    """Send a command to the MPV IPC pipe and return the response."""
    try:
        ipc_pipe = get_ipc_pipe_path()
        client = MPVIPCClient(socket_path=ipc_pipe)
        
        if not client.connect():
            return None  # MPV not running
        
        response = client.send_command(command)
        client.disconnect()
        return response
    except Exception as e:
        if not silent:
            debug(f"IPC Error: {e}", file=sys.stderr)
        return None

def _get_playlist(silent: bool = False) -> Optional[List[Dict[str, Any]]]:
    """Get the current playlist from MPV. Returns None if MPV is not running."""
    cmd = {"command": ["get_property", "playlist"], "request_id": 100}
    resp = _send_ipc_command(cmd, silent=silent)
    if resp is None:
        return None
    if resp.get("error") == "success":
        return resp.get("data", [])
    return []

def _extract_title_from_item(item: Dict[str, Any]) -> str:
    """Extract a clean title from an MPV playlist item, handling memory:// M3U hacks."""
    title = item.get("title")
    filename = item.get("filename") or ""
    
    # Special handling for memory:// M3U playlists (used to pass titles via IPC)
    if "memory://" in filename and "#EXTINF:" in filename:
        try:
            # Extract title from #EXTINF:-1,Title
            # Use regex to find title between #EXTINF:-1, and newline
            match = re.search(r"#EXTINF:-1,(.*?)(?:\n|\r|$)", filename)
            if match:
                extracted_title = match.group(1).strip()
                if not title or title == "memory://":
                    title = extracted_title
            
            # If we still don't have a title, try to find the URL in the M3U content
            if not title:
                lines = filename.splitlines()
                for line in lines:
                    line = line.strip()
                    if line and not line.startswith('#') and not line.startswith('memory://'):
                        # Found the URL, use it as title
                        return line
        except Exception:
            pass
            
    return title or filename or "Unknown"


def _extract_target_from_memory_uri(text: str) -> Optional[str]:
    """Extract the real target URL/path from a memory:// M3U payload."""
    if not isinstance(text, str) or not text.startswith("memory://"):
        return None
    for line in text.splitlines():
        line = line.strip()
        if not line or line.startswith('#') or line.startswith('memory://'):
            continue
        return line
    return None


def _infer_store_from_playlist_item(item: Dict[str, Any]) -> str:
    """Infer a friendly store label from an MPV playlist entry."""
    name = item.get("filename") if isinstance(item, dict) else None
    target = str(name or "")

    # Unwrap memory:// M3U wrapper
    memory_target = _extract_target_from_memory_uri(target)
    if memory_target:
        target = memory_target

    lower = target.lower()
    if lower.startswith("magnet:"):
        return "magnet"
    if lower.startswith("hydrus://"):
        return "hydrus"

    # Windows / UNC paths
    if re.match(r"^[a-z]:[\\/]", target, flags=re.IGNORECASE) or target.startswith("\\\\"):
        return "local"

    # file:// URLs
    if lower.startswith("file://"):
        return "local"

    parsed = urlparse(target)
    host = (parsed.netloc or "").lower()
    path = parsed.path or ""

    if not host:
        return ""

    host_no_port = host.split(":", 1)[0]
    host_stripped = host_no_port[4:] if host_no_port.startswith("www.") else host_no_port

    if "youtube" in host_stripped or "youtu.be" in target.lower():
        return "youtube"
    if "soundcloud" in host_stripped:
        return "soundcloud"
    if "bandcamp" in host_stripped:
        return "bandcamp"
    if "get_files" in path or host_stripped in {"127.0.0.1", "localhost"}:
        return "hydrus"
    if re.match(r"^\d+\.\d+\.\d+\.\d+$", host_stripped) and "get_files" in path:
        return "hydrus"

    parts = host_stripped.split('.')
    if len(parts) >= 2:
        return parts[-2] or host_stripped
    return host_stripped


def _format_playlist_location(name: str, max_len: int = 48) -> str:
    """Format playlist filename/URL for display while keeping backend untouched."""
    target = name or ""
    memory_target = _extract_target_from_memory_uri(target)
    if memory_target:
        target = memory_target

    lower = target.lower()
    # Local paths: show basename only
    if re.match(r"^[a-z]:[\\/]", target, flags=re.IGNORECASE) or target.startswith("\\\\"):
        target = Path(target).name
    elif lower.startswith("file://"):
        parsed = urlparse(target)
        target = Path(parsed.path or "").name or target
    else:
        parsed = urlparse(target)
        host = parsed.netloc or ""
        if host:
            host_no_port = host.split(":", 1)[0]
            host_no_port = host_no_port[4:] if host_no_port.startswith("www.") else host_no_port
            tail = parsed.path.split('/')[-1] if parsed.path else ""
            if tail:
                target = f"{host_no_port}/{tail}"
            else:
                target = host_no_port

    if len(target) > max_len:
        return target[: max_len - 3] + "..."
    return target


def _build_hydrus_header(config: Dict[str, Any]) -> Optional[str]:
    """Return header string for Hydrus auth if configured."""
    try:
        key = get_hydrus_access_key(config)
    except Exception:
        key = None
    if not key:
        return None
    return f"Hydrus-Client-API-Access-Key: {key}"


def _build_ytdl_options(config: Optional[Dict[str, Any]], hydrus_header: Optional[str]) -> Optional[str]:
    """Compose ytdl-raw-options string including cookies and optional Hydrus header."""
    opts: List[str] = []
    try:
        cookies_path = get_cookies_file_path()
    except Exception:
        cookies_path = None
    if cookies_path:
        opts.append(f"cookies={cookies_path.replace('\\', '/')}")
    else:
        opts.append("cookies-from-browser=chrome")
    if hydrus_header:
        opts.append(f"add-header={hydrus_header}")
    return ",".join(opts) if opts else None


def _is_hydrus_target(target: str, hydrus_url: Optional[str]) -> bool:
    if not target:
        return False
    lower = target.lower()
    if "hydrus://" in lower:
        return True
    parsed = urlparse(target)
    host = (parsed.netloc or "").lower()
    path = parsed.path or ""
    if hydrus_url:
        try:
            hydrus_host = urlparse(hydrus_url).netloc.lower()
            if hydrus_host and hydrus_host in host:
                return True
        except Exception:
            pass
    if "get_files" in path or "file?hash=" in path:
        return True
    if re.match(r"^\d+\.\d+\.\d+\.\d+$", host) and "get_files" in path:
        return True
    return False

def _ensure_ytdl_cookies() -> None:
    """Ensure yt-dlp options are set correctly for this session."""
    from pathlib import Path
    cookies_path = get_cookies_file_path()
    if cookies_path:
        # Check if file exists and has content (use forward slashes for path checking)
        check_path = cookies_path.replace('\\', '/')
        file_obj = Path(cookies_path)
        if file_obj.exists():
            file_size = file_obj.stat().st_size
            debug(f"Cookies file verified: {check_path} ({file_size} bytes)")
        else:
            debug(f"WARNING: Cookies file does not exist: {check_path}", file=sys.stderr)
    else:
        debug("No cookies file configured")

def _monitor_mpv_logs(duration: float = 3.0) -> None:
    """Monitor MPV logs for a short duration to capture errors."""
    try:
        client = MPVIPCClient()
        if not client.connect():
            debug("Failed to connect to MPV for log monitoring", file=sys.stderr)
            return
            
        # Request log messages
        client.send_command({"command": ["request_log_messages", "warn"]})
        
        import time
        start_time = time.time()
        while time.time() - start_time < duration:
            # We need to read raw lines from the socket
            if client.is_windows:
                try:
                    line = client.sock.readline()
                    if line:
                        try:
                            msg = json.loads(line)
                            if msg.get("event") == "log-message":
                                text = msg.get("text", "").strip()
                                prefix = msg.get("prefix", "")
                                level = msg.get("level", "")
                                if "ytdl" in prefix or level == "error":
                                    debug(f"[MPV {prefix}] {text}", file=sys.stderr)
                        except json.JSONDecodeError:
                            pass
                except Exception:
                    break
            else:
                # Unix socket handling (simplified)
                break
            time.sleep(0.05)
            
        client.disconnect()
    except Exception:
        pass
def _queue_items(items: List[Any], clear_first: bool = False, config: Optional[Dict[str, Any]] = None) -> bool:
    """Queue items to MPV, starting it if necessary.
    
    Args:
        items: List of items to queue
        clear_first: If True, the first item will replace the current playlist
        
    Returns:
        True if MPV was started, False if items were queued via IPC.
    """
    # Just verify cookies are configured, don't try to set via IPC
    _ensure_ytdl_cookies()

    hydrus_header = _build_hydrus_header(config or {})
    ytdl_opts = _build_ytdl_options(config, hydrus_header)
    hydrus_url = None
    try:
        hydrus_url = get_hydrus_url(config) if config is not None else None
    except Exception:
        hydrus_url = None

    for i, item in enumerate(items):
        # Extract URL/Path
        target = None
        title = None
        
        if isinstance(item, dict):
            target = item.get("target") or item.get("url") or item.get("path") or item.get("filename")
            title = item.get("title") or item.get("name")
        elif hasattr(item, "target"):
            target = item.target
            title = getattr(item, "title", None)
        elif isinstance(item, str):
            target = item
        
        if target:
            # Check if it's a yt-dlp supported URL
            is_ytdlp = False
            if target.startswith("http") and is_url_supported_by_ytdlp(target):
                is_ytdlp = True

            # Use memory:// M3U hack to pass title to MPV
            # Skip for yt-dlp URLs to ensure proper handling
            if title and not is_ytdlp:
                # Sanitize title for M3U (remove newlines)
                safe_title = title.replace('\n', ' ').replace('\r', '')
                m3u_content = f"#EXTM3U\n#EXTINF:-1,{safe_title}\n{target}"
                target_to_send = f"memory://{m3u_content}"
            else:
                target_to_send = target

            mode = "append"
            if clear_first and i == 0:
                mode = "replace"

            # If this is a Hydrus target, set header property and yt-dlp headers before loading
            if hydrus_header and _is_hydrus_target(target_to_send, hydrus_url):
                header_cmd = {"command": ["set_property", "http-header-fields", hydrus_header], "request_id": 199}
                _send_ipc_command(header_cmd, silent=True)
                if ytdl_opts:
                    ytdl_cmd = {"command": ["set_property", "ytdl-raw-options", ytdl_opts], "request_id": 197}
                    _send_ipc_command(ytdl_cmd, silent=True)

            cmd = {"command": ["loadfile", target_to_send, mode], "request_id": 200}
            resp = _send_ipc_command(cmd)
            
            if resp is None:
                # MPV not running (or died)
                # Start MPV with remaining items
                _start_mpv(items[i:], config=config)
                return True
            elif resp.get("error") == "success":
                # Also set property for good measure
                if title:
                    title_cmd = {"command": ["set_property", "force-media-title", title], "request_id": 201}
                    _send_ipc_command(title_cmd)
                debug(f"Queued: {title or target}")
            else:
                error_msg = str(resp.get('error'))
                debug(f"Failed to queue item: {error_msg}", file=sys.stderr)
    return False

def _run(result: Any, args: Sequence[str], config: Dict[str, Any]) -> int:
    """Manage and play items in the MPV playlist via IPC."""
    
    parsed = parse_cmdlet_args(args, CMDLET)
    
    # Initialize mpv_started flag
    mpv_started = False
    
    # Handle positional index argument if provided
    index_arg = parsed.get("index")
    url_arg = parsed.get("url")
    
    # If index_arg is provided but is not an integer, treat it as a URL
    # This allows .pipe "http://..." without -url flag
    if index_arg is not None:
        try:
            int(index_arg)
        except ValueError:
            # Not an integer, treat as URL if url_arg is not set
            if not url_arg:
                url_arg = index_arg
                index_arg = None
    
    clear_mode = parsed.get("clear")
    list_mode = parsed.get("list")
    play_mode = parsed.get("play")
    pause_mode = parsed.get("pause")
    save_mode = parsed.get("save")
    load_mode = parsed.get("load")
    current_mode = parsed.get("current")
    
    # Handle --current flag: emit currently playing item to pipeline
    if current_mode:
        items = _get_playlist()
        if items is None:
            debug("MPV is not running or not accessible.", file=sys.stderr)
            return 1
        
        # Find the currently playing item
        current_item = None
        for item in items:
            if item.get("current", False):
                current_item = item
                break
        
        if current_item is None:
            debug("No item is currently playing.", file=sys.stderr)
            return 1
        
        # Build result object with file info
        title = _extract_title_from_item(current_item)
        filename = current_item.get("filename", "")
        
        # Emit the current item to pipeline
        result_obj = {
            'file_path': filename,
            'title': title,
            'cmdlet_name': '.pipe',
            'source': 'pipe',
            '__pipe_index': items.index(current_item),
        }
        
        ctx.emit(result_obj)
        debug(f"Emitted current item: {title}")
        return 0
    
    # Handle URL queuing
    mpv_started = False
    if url_arg:
        mpv_started = _queue_items([url_arg])
        # Auto-play the URL when it's queued via .pipe "url" (without explicit flags)
        # unless other flags are present
        if not (clear_mode or play_mode or pause_mode or save_mode or load_mode):
            if mpv_started:
                # MPV was just started, wait a moment for it to be ready, then play first item
                import time
                time.sleep(0.5)
                index_arg = "1"  # 1-based index for first item
                play_mode = True
            else:
                # MPV was already running, get playlist and play the newly added item
                playlist = _get_playlist(silent=True)
                if playlist and len(playlist) > 0:
                    # Auto-play the last item in the playlist (the one we just added)
                    # Use 1-based indexing
                    index_arg = str(len(playlist))
                    play_mode = True
                else:
                    # Fallback: just list the playlist if we can't determine index
                    list_mode = True

    # Handle Save Playlist
    if save_mode:
        playlist_name = index_arg or f"Playlist {subprocess.check_output(['date', '/t'], shell=True).decode().strip()}"
        # If index_arg was used for name, clear it so it doesn't trigger index logic
        if index_arg:
            index_arg = None
            
        items = _get_playlist()
        if not items:
            debug("Cannot save: MPV playlist is empty or MPV is not running.")
            return 1
            
        # Clean up items for saving (remove current flag, etc)
        clean_items = []
        for item in items:
            # If title was extracted from memory://, we should probably save the original filename 
            # if it's a URL, or reconstruct a clean object.
            # Actually, _extract_title_from_item handles the display title.
            # But for playback, we need the 'filename' (which might be memory://...)
            # If we save 'memory://...', it will work when loaded back.
            clean_items.append(item)

        # Use config from context or load it
        config_data = config if config else {}
        
        storage_path = get_local_storage_path(config_data)
        if not storage_path:
            debug("Local storage path not configured.")
            return 1

        with LocalLibrarySearchOptimizer(storage_path) as db:
            if db.save_playlist(playlist_name, clean_items):
                debug(f"Playlist saved as '{playlist_name}'")
                return 0
            else:
                debug(f"Failed to save playlist '{playlist_name}'")
                return 1

    # Handle Load Playlist
    current_playlist_name = None
    if load_mode:
        # Use config from context or load it
        config_data = config if config else {}
        
        storage_path = get_local_storage_path(config_data)
        if not storage_path:
            debug("Local storage path not configured.")
            return 1

        with LocalLibrarySearchOptimizer(storage_path) as db:
            if index_arg:
                try:
                    pl_id = int(index_arg)
                    
                    # Handle Delete Playlist (if -clear is also passed)
                    if clear_mode:
                        if db.delete_playlist(pl_id):
                            debug(f"Playlist ID {pl_id} deleted.")
                            # Clear index_arg so we fall through to list mode and show updated list
                            index_arg = None
                            # Don't return, let it list the remaining playlists
                        else:
                            debug(f"Failed to delete playlist ID {pl_id}.")
                            return 1
                    else:
                        # Handle Load Playlist
                        result = db.get_playlist_by_id(pl_id)
                        if result is None:
                            debug(f"Playlist ID {pl_id} not found.")
                            return 1
                        
                        name, items = result
                        current_playlist_name = name
                        
                        # Queue items (replacing current playlist)
                        if items:
                            _queue_items(items, clear_first=True)
                        else:
                            # Empty playlist, just clear
                            _send_ipc_command({"command": ["playlist-clear"]}, silent=True)
                        
                        # Switch to list mode to show the result
                        list_mode = True
                        index_arg = None
                        # Fall through to list logic
                    
                except ValueError:
                    debug(f"Invalid playlist ID: {index_arg}")
                    return 1
            
            # If we deleted or didn't have an index, list playlists
            if not index_arg:
                playlists = db.get_playlists()
                
                if not playlists:
                    debug("No saved playlists found.")
                    return 0
                    
                table = ResultTable("Saved Playlists")
                for i, pl in enumerate(playlists):
                    item_count = len(pl.get('items', []))
                    row = table.add_row()
                    # row.add_column("ID", str(pl['id'])) # Hidden as per user request
                    row.add_column("Name", pl['name'])
                    row.add_column("Items", str(item_count))
                    row.add_column("Updated", pl['updated_at'])
                    
                    # Set the playlist items as the result object for this row
                    # When user selects @N, they get the list of items
                    # We also set the source command to .pipe -load <ID> so it loads it
                    table.set_row_selection_args(i, ["-load", str(pl['id'])])
                
                table.set_source_command(".pipe")
                
                # Register results
                ctx.set_last_result_table_overlay(table, [p['items'] for p in playlists])
                ctx.set_current_stage_table(table)
                
                print(table)
                return 0

    # Handle Play/Pause commands (but skip if we have index_arg to play a specific item)
    if play_mode and index_arg is None:
        cmd = {"command": ["set_property", "pause", False], "request_id": 103}
        resp = _send_ipc_command(cmd)
        if resp and resp.get("error") == "success":
            debug("Resumed playback")
            return 0
        else:
            debug("Failed to resume playback (MPV not running?)", file=sys.stderr)
            return 1
            
    if pause_mode:
        cmd = {"command": ["set_property", "pause", True], "request_id": 104}
        resp = _send_ipc_command(cmd)
        if resp and resp.get("error") == "success":
            debug("Paused playback")
            return 0
        else:
            debug("Failed to pause playback (MPV not running?)", file=sys.stderr)
            return 1
            
    # Handle Clear All command (no index provided)
    if clear_mode and index_arg is None:
        cmd = {"command": ["playlist-clear"], "request_id": 105}
        resp = _send_ipc_command(cmd)
        if resp and resp.get("error") == "success":
            debug("Playlist cleared")
            return 0
        else:
            debug("Failed to clear playlist (MPV not running?)", file=sys.stderr)
            return 1
    
    # Handle piped input (add to playlist)
    # Skip adding if -list is specified (user just wants to see current playlist)
    if result and not list_mode and not url_arg:
        # If result is a list of items, add them to playlist
        items_to_add = []
        if isinstance(result, list):
            items_to_add = result
        elif isinstance(result, dict):
            items_to_add = [result]
        
        if _queue_items(items_to_add, config=config):
            mpv_started = True
        
        if items_to_add:
            # If we added items, we might want to play the first one if nothing is playing?
            # For now, just list the playlist
            pass

    # Get playlist from MPV
    items = _get_playlist()
    
    if items is None:
        if mpv_started:
            # MPV was just started, retry getting playlist after a brief delay
            import time
            time.sleep(0.3)
            items = _get_playlist(silent=True)
            
            if items is None:
                # Still can't connect, but MPV is starting
                debug("MPV is starting up...")
                return 0
        else:
            # Do not auto-launch MPV when no action/inputs were provided; avoid surprise startups
            no_inputs = not any([
                result, url_arg, index_arg, clear_mode, play_mode,
                pause_mode, save_mode, load_mode, current_mode, list_mode
            ])

            if no_inputs:
                debug("MPV is not running. Skipping auto-launch (no inputs).", file=sys.stderr)
                return 1

            debug("MPV is not running. Starting new instance...")
            _start_mpv([], config=config)
            return 0
        
    if not items:
        debug("MPV playlist is empty.")
        return 0

    # If index is provided, perform action (Play or Clear)
    if index_arg is not None:
        try:
            # Handle 1-based index
            idx = int(index_arg) - 1
            
            if idx < 0 or idx >= len(items):
                debug(f"Index {index_arg} out of range (1-{len(items)}).")
                return 1
            
            item = items[idx]
            title = _extract_title_from_item(item)
            filename = item.get("filename", "") if isinstance(item, dict) else ""
            hydrus_header = _build_hydrus_header(config or {})
            hydrus_url = None
            try:
                hydrus_url = get_hydrus_url(config) if config is not None else None
            except Exception:
                hydrus_url = None
            
            if clear_mode:
                # Remove item
                cmd = {"command": ["playlist-remove", idx], "request_id": 101}
                resp = _send_ipc_command(cmd)
                if resp and resp.get("error") == "success":
                    debug(f"Removed: {title}")
                    # Refresh items for listing
                    items = _get_playlist() or []
                    list_mode = True
                    index_arg = None
                else:
                    debug(f"Failed to remove item: {resp.get('error') if resp else 'No response'}")
                    return 1
            else:
                # Play item
                if hydrus_header and _is_hydrus_target(filename, hydrus_url):
                    header_cmd = {"command": ["set_property", "http-header-fields", hydrus_header], "request_id": 198}
                    _send_ipc_command(header_cmd, silent=True)
                cmd = {"command": ["playlist-play-index", idx], "request_id": 102}
                resp = _send_ipc_command(cmd)
                if resp and resp.get("error") == "success":
                    # Ensure playback starts (unpause)
                    unpause_cmd = {"command": ["set_property", "pause", False], "request_id": 103}
                    _send_ipc_command(unpause_cmd)
                    
                    debug(f"Playing: {title}")
                    
                    # Monitor logs briefly for errors (e.g. ytdl failures)
                    _monitor_mpv_logs(3.0)
                    return 0
                else:
                    debug(f"Failed to play item: {resp.get('error') if resp else 'No response'}")
                    return 1
        except ValueError:
            debug(f"Invalid index: {index_arg}")
            return 1

    # List items (Default action or after clear)
    if list_mode or (index_arg is None and not url_arg):
        if not items:
            debug("MPV playlist is empty.")
            return 0
            
        # Use the loaded playlist name if available, otherwise default
        # Note: current_playlist_name is defined in the load_mode block if a playlist was loaded
        try:
            table_title = current_playlist_name or "MPV Playlist"
        except NameError:
            table_title = "MPV Playlist"
            
        table = ResultTable(table_title)
        
        for i, item in enumerate(items):
            is_current = item.get("current", False)
            title = _extract_title_from_item(item)
            store = _infer_store_from_playlist_item(item)

            # Truncate if too long
            if len(title) > 80:
                title = title[:77] + "..."
            
            row = table.add_row()
            row.add_column("Current", "*" if is_current else "")
            row.add_column("Store", store)
            row.add_column("Title", title)
            
            table.set_row_selection_args(i, [str(i + 1)])
            
        table.set_source_command(".pipe")
        
        # Register results with pipeline context so @N selection works
        ctx.set_last_result_table_overlay(table, items)
        ctx.set_current_stage_table(table)
        
        print(table)
        
    return 0

def _start_mpv(items: List[Any], config: Optional[Dict[str, Any]] = None) -> None:
    """Start MPV with a list of items."""
    import subprocess
    import time as _time_module
    
    # Kill any existing MPV processes to ensure clean start
    try:
        subprocess.run(['taskkill', '/IM', 'mpv.exe', '/F'], 
                      stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, 
                      stderr=subprocess.DEVNULL, timeout=2)
        _time_module.sleep(0.5)  # Wait for process to die
    except Exception:
        pass
    
    ipc_pipe = get_ipc_pipe_path()
    
    # Start MPV in idle mode with IPC server
    cmd = ['mpv', f'--input-ipc-server={ipc_pipe}', '--idle', '--force-window']
    cmd.append('--ytdl-format=bestvideo[height<=?1080]+bestaudio/best[height<=?1080]')

    hydrus_header = _build_hydrus_header(config or {})
    ytdl_opts = _build_ytdl_options(config, hydrus_header)

    cookies_path = get_cookies_file_path()
    if cookies_path:
        debug(f"Starting MPV with cookies file: {cookies_path.replace('\\', '/')}")
    else:
        debug("Starting MPV with browser cookies: chrome")

    if ytdl_opts:
        cmd.append(f'--ytdl-raw-options={ytdl_opts}')
    
    try:
        kwargs = {}
        if platform.system() == 'Windows':
            kwargs['creationflags'] = 0x00000008 # DETACHED_PROCESS
        
        # Log the complete MPV command being executed
        debug(f"DEBUG: Full MPV command: {' '.join(cmd)}")
        
        if hydrus_header:
            cmd.append(f'--http-header-fields={hydrus_header}')
        subprocess.Popen(cmd, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.PIPE, **kwargs)
        debug(f"Started MPV process")
        
        # Wait for IPC pipe to be ready
        import time
        max_retries = 20
        for i in range(max_retries):
            time.sleep(0.2)
            client = MPVIPCClient(socket_path=ipc_pipe)
            if client.connect():
                client.disconnect()
                break
        else:
            debug("Timed out waiting for MPV IPC connection", file=sys.stderr)
            return

        # Queue items via IPC
        if items:
            _queue_items(items, config=config)
            
    except Exception as e:
        debug(f"Error starting MPV: {e}", file=sys.stderr)


CMDLET = Cmdlet(
    name=".pipe",
    aliases=["pipe", "playlist", "queue", "ls-pipe"],
    summary="Manage and play items in the MPV playlist via IPC",
    usage=".pipe [index|url] [-current] [-clear] [-list] [-url URL]",
    args=[
        CmdletArg(
            name="index",
            type="string", # Changed to string to allow URL detection
            description="Index of item to play/clear, or URL to queue",
            required=False
        ),
        CmdletArg(
            name="url",
            type="string",
            description="URL to queue",
            required=False
        ),
        CmdletArg(
            name="clear",
            type="flag",
            description="Remove the selected item, or clear entire playlist if no index provided"
        ),
        CmdletArg(
            name="list",
            type="flag",
            description="List items (default)"
        ),
        CmdletArg(
            name="play",
            type="flag",
            description="Resume playback"
        ),
        CmdletArg(
            name="pause",
            type="flag",
            description="Pause playback"
        ),
        CmdletArg(
            name="save",
            type="flag",
            description="Save current playlist to database"
        ),
        CmdletArg(
            name="load",
            type="flag",
            description="List saved playlists"
        ),
        CmdletArg(
            name="current",
            type="flag",
            description="Emit the currently playing item to pipeline for further processing"
        ),
    ],
    exec=_run
)