@officebeats/matrix-iptv-cli 4.0.4 → 4.0.17

package/README.md

@@ -13,10 +13,16 @@ This project is being actively optimized by **Ernesto "Beats"** with a primary f
 ## 📸 Gallery
 
 <p align="center">
-  <img src="./assets/playlists.png" width="45%" />
-  <img src="./assets/pill.png" width="45%" />
+  <img src="./assets/selector.png" width="48%" />
+  <img src="./assets/categories.png" width="48%" />
   <br />
-  <img src="./assets/live.png" width="90%" />
+  <img src="./assets/news.png" width="48%" />
+  <img src="./assets/nba.png" width="48%" />
+  <br />
+  <img src="./assets/vod.png" width="48%" />
+  <img src="./assets/playback.png" width="48%" />
+  <br />
+  <img src="./assets/movie_details.png" width="98%" />
 </p>
 
 ---
@@ -45,9 +51,8 @@ If you have Node.js installed, this is the easiest way to stay updated:
 npm install -g @officebeats/matrix-iptv-cli
 ```
 
-### **One-Click Scripts**
-
-Alternatively, use these platform-specific one-liners:
+<details>
+<summary><strong>🚀 One-Click Install Scripts (Click to Expand)</strong></summary>
 
 #### **Windows**
 
@@ -61,6 +66,8 @@ powershell -ExecutionPolicy Bypass -Command "irm https://raw.githubusercontent.c
 curl -sSL https://raw.githubusercontent.com/officebeats/matrix-iptv/main/install.sh -o install_matrix.sh && bash install_matrix.sh && rm install_matrix.sh
 ```
 
+</details>
+
 ---
 
 ## 🎬 How to Run
@@ -125,6 +132,15 @@ We leverage advanced **MPV** flags to ensure professional-level video quality ev
 
 ---
 
+## ⚙️ Advanced Features
+
+Matrix IPTV CLI provides several core utilities to manage complex setups safely:
+
+- **VLC Fallback Integration**: While MPV provides the ultimate playback tier, you can configure the app to fall back to launching VLC Media Player instead, maximizing compatibility.
+- **Dynamic Background Sync**: Automatically handles large playlist parsing without hanging the UI, providing fluid progress updates and ETAs while it indexes tens of thousands of channels.
+
+---
+
 ## ⌨️ Common Controls
 
 | Key                     | Action                                        |
@@ -136,10 +152,10 @@ We leverage advanced **MPV** flags to ensure professional-level video quality ev
 | **`v`**                 | **Toggle Favorite**                           |
 | **`j` / `↓`**           | Move Down                                     |
 | **`k` / `↑`**           | Move Up                                       |
-| **`g`**                 | **Jump to Bottom** (Go to last item)          |
-| **`G`**                 | **Jump to Top** (Go to first item)            |
-| **`0`-`9`**             | **Jump to Item** (Direct access to items 0-9) |
-| **`m`**                 | **Playlist Mode** (Quick Toggle/Switch)       |
+| **`g`**                 | **Toggle Grid View / Group Menu**             |
+| **`G`**                 | **Manage Groups / Jump to Bottom (VOD)**      |
+| **`0`-`9`**             | **Jump to Item / Switch Account (Home)**      |
+| **`m`**                 | **Settings: Playlist Mode**                   |
 | **`x`**                 | **Settings**                                  |
 | **`n`**                 | **New Playlist** (Home Screen)                |
 | **`e`**                 | **Edit Playlist** (Home Screen)               |

package/bin/cli.js

@@ -16,30 +16,38 @@ const platformMap = {
   darwin: "macos",
 };
 
-function download(url, dest) {
-  return new Promise((resolve, reject) => {
-    const file = fs.createWriteStream(dest);
-    https
-      .get(url, (response) => {
-        if (response.statusCode === 302 || response.statusCode === 301) {
-          download(response.headers.location, dest).then(resolve).catch(reject);
-          return;
-        }
-        if (response.statusCode !== 200) {
-          reject(new Error(`Failed to download: ${response.statusCode}`));
-          return;
-        }
-        response.pipe(file);
-        file.on("finish", () => {
-          file.close();
-          resolve();
-        });
-      })
-      .on("error", (err) => {
+const axios = require("axios");
+
+async function download(url, dest) {
+  const writer = fs.createWriteStream(dest);
+  
+  try {
+    const response = await axios({
+      method: 'get',
+      url: url,
+      responseType: 'stream',
+      headers: {
+        'Cache-Control': 'no-cache',
+        'User-Agent': 'matrix-iptv-cli-updater'
+      }
+    });
+
+    response.data.pipe(writer);
+
+    return new Promise((resolve, reject) => {
+      writer.on('finish', resolve);
+      writer.on('error', (err) => {
         fs.unlink(dest, () => {});
         reject(err);
       });
-  });
+    });
+  } catch (err) {
+    fs.unlink(dest, () => {});
+    if (err.response && err.response.status === 404) {
+      throw new Error(`Asset not found (404). This usually means the GitHub release exists but the binary hasn't been uploaded yet.`);
+    }
+    throw err;
+  }
 }
 
 async function performUpdate() {
@@ -75,22 +83,18 @@ async function performUpdate() {
     }
 
     // Replace old binary
-    // On Windows, sometimes the OS still has a lock for a split second or unlinking is restricted
     let attempts = 0;
-    const maxAttempts = 10;
+    const maxAttempts = 15;
     while (attempts < maxAttempts) {
       try {
         if (fs.existsSync(binaryPath)) {
           if (os.platform() === "win32") {
-            // "Rename-out" strategy for Windows: move the file to a temporary name first
-            // This is often allowed even if the file is lazily being released by the OS
             const oldPath = binaryPath + ".old." + Date.now();
             fs.renameSync(binaryPath, oldPath);
-            // Optionally try to delete the old one, but don't fail if we can't
             try {
               fs.unlinkSync(oldPath);
             } catch (e) {
-              // It's okay if we can't delete it now, it'll just stay as a .old file
+              // Mark for deletion on next reboot or just ignore
             }
           } else {
             fs.unlinkSync(binaryPath);
@@ -100,31 +104,42 @@ async function performUpdate() {
         break;
       } catch (e) {
         attempts++;
-        console.log(`[!] Retry ${attempts}/${maxAttempts}: ${e.message}`);
         if (attempts === maxAttempts) throw e;
-        // Increase delay on each attempt
-        await new Promise((r) => setTimeout(r, 500 + attempts * 200));
+        await new Promise((r) => setTimeout(r, 1000 + attempts * 500));
       }
     }
 
-    // Also clear quarantine on final binary path
     if (os.platform() === "darwin") {
       try {
         const { execSync } = require("child_process");
-        execSync(
-          `xattr -d com.apple.quarantine "${binaryPath}" 2>/dev/null || true`
-        );
+        execSync(`xattr -d com.apple.quarantine "${binaryPath}" 2>/dev/null || true`);
       } catch (e) {}
     }
 
     console.log(`[+] Update complete. Rebooting system...\n`);
+
+    if (os.platform() === "win32") {
+      const batchScript = `
+@echo off
+timeout /t 2 /nobreak > nul
+start "" "${binaryPath}" %*
+del "%~f0"
+`;
+      const batchPath = path.join(os.tmpdir(), "matrix-relaunch.bat");
+      fs.writeFileSync(batchPath, batchScript);
+      spawn("cmd.exe", ["/c", batchPath, ...process.argv.slice(2)], {
+        detached: true,
+        stdio: "ignore",
+      }).unref();
+      process.exit(0);
+    }
   } catch (err) {
     if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
     throw err;
   }
 }
 
-function launchApp() {
+function launchApp(isUpdateRelaunch = false) {
   if (!fs.existsSync(binaryPath)) {
     console.error("\n❌  Matrix IPTV binary not found.");
     console.log(
@@ -133,12 +148,27 @@ function launchApp() {
     process.exit(1);
   }
 
-  const child = spawn(binaryPath, process.argv.slice(2), {
-    stdio: "inherit",
-    windowsHide: false,
-  });
+  let child;
+  try {
+    child = spawn(binaryPath, process.argv.slice(2), {
+      stdio: "inherit",
+      windowsHide: false,
+    });
+  } catch (err) {
+    if (isUpdateRelaunch && (err.code === "EBUSY" || err.code === "EACCES")) {
+      console.log(`[*] Executable locked by OS. Retrying in 2 seconds...`);
+      setTimeout(() => launchApp(true), 2000);
+      return;
+    }
+    throw err;
+  }
 
   child.on("error", (err) => {
+    if (isUpdateRelaunch && (err.code === "EBUSY" || err.code === "EACCES")) {
+      console.log(`[*] Executable locked by OS. Retrying in 2 seconds...`);
+      setTimeout(() => launchApp(true), 2000);
+      return;
+    }
     console.error("Failed to start Matrix IPTV:", err);
     process.exit(1);
   });
@@ -147,7 +177,10 @@ function launchApp() {
     if (code === 42) {
       try {
         await performUpdate();
-        launchApp(); // Relaunch
+        // If not win32 (which handles its own relaunch), relaunch here
+        if (os.platform() !== "win32") {
+          launchApp(true);
+        }
       } catch (err) {
         console.error(`\n❌ Update failed: ${err.message}`);
         process.exit(1);

package/old_player.rs

@@ -0,0 +1,404 @@
+use std::path::PathBuf;
+use std::sync::Arc;
+use std::sync::Mutex;
+use crate::config::PlayerEngine;
+
+#[cfg(not(target_arch = "wasm32"))]
+use std::process::{Child, Command, Stdio};
+
+#[cfg(not(target_arch = "wasm32"))]
+
+
+#[cfg(not(target_arch = "wasm32"))]
+
+
+#[cfg(target_arch = "wasm32")]
+use web_sys::window;
+
+#[derive(Clone)]
+pub struct Player {
+    #[cfg(not(target_arch = "wasm32"))]
+    process: Arc<Mutex<Option<Child>>>,
+    #[cfg(not(target_arch = "wasm32"))]
+    ipc_path: Arc<Mutex<Option<PathBuf>>>,
+}
+
+impl Player {
+    pub fn new() -> Self {
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            Self {
+                process: Arc::new(Mutex::new(None)),
+                ipc_path: Arc::new(Mutex::new(None)),
+            }
+        }
+        #[cfg(target_arch = "wasm32")]
+        {
+            Self {}
+        }
+    }
+
+    /// Start the selected player engine and return the IPC pipe path for monitoring
+    #[cfg(not(target_arch = "wasm32"))]
+    pub async fn play(&self, url: &str, engine: PlayerEngine, use_default_mpv: bool, smooth_motion: bool) -> Result<(), anyhow::Error> {
+        // Pre-flight check: Verify stream is reachable before launching player
+        // This detects dead redirects/DNS issues early and notifies the user
+        self.check_stream_health(url).await?;
+
+        self.stop();
+
+        match engine {
+            PlayerEngine::Mpv => self.play_mpv(url, use_default_mpv, smooth_motion),
+            PlayerEngine::Vlc => self.play_vlc(url, smooth_motion),
+        }
+    }
+
+    async fn check_stream_health(&self, url: &str) -> Result<(), anyhow::Error> {
+        // Build a client that mimics the player's behavior (Chrome UA)
+        let client = reqwest::Client::builder()
+            .timeout(std::time::Duration::from_secs(10))
+            .user_agent("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
+            .danger_accept_invalid_certs(true)
+            .build()
+            .unwrap_or_else(|_| reqwest::Client::new());
+
+        // We use a stream request but abort immediately to check connectivity/headers.
+        // HEAD often fails on some IPTV servers, so a started GET is safer logic-wise.
+        let mut result = client.get(url).send().await;
+        
+        // Resilience: Fallback to DoH if DNS fails for the stream health check
+        if let Err(ref e) = result {
+            if crate::doh::is_dns_error(e) {
+                #[cfg(debug_assertions)]
+                println!("DEBUG: Health check DNS error detected for {}. Trying DoH fallback...", url);
+
+                if let Some(resp) = crate::doh::try_doh_fallback(&client, url).await {
+                    result = Ok(resp);
+                }
+            }
+        }
+
+        match result {
+            Ok(resp) => {
+                if resp.status().is_success() || resp.status().is_redirection() {
+                    Ok(())
+                } else {
+                    Err(anyhow::anyhow!("Stream returned error status: {} (Server might be offline/blocking)", resp.status()))
+                }
+            },
+            Err(e) => {
+                // Provide a user-friendly error description using shared DNS detection
+                if crate::doh::is_dns_error(&e) {
+                     Err(anyhow::anyhow!("Stream Server Unreachable. The host likely does not exist or is blocked (DNS Error). Details: {}", e))
+                } else if e.is_connect() || e.is_timeout() {
+                     Err(anyhow::anyhow!("Stream Connection Failed. Server may be slow or offline. Details: {}", e))
+                } else {
+                     Err(anyhow::anyhow!("Stream Check Failed: {}", e))
+                }
+            }
+        }
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    fn play_mpv(&self, url: &str, use_default_mpv: bool, smooth_motion: bool) -> Result<(), anyhow::Error> {
+
+        // Find mpv executable, checking PATH and common installation locations
+        let mpv_path = crate::setup::get_mpv_path().ok_or_else(|| {
+            let hint = if cfg!(target_os = "macos") {
+                "\n\nHint: On macOS with Homebrew:\n\
+                 - Apple Silicon: mpv is typically at /opt/homebrew/bin/mpv\n\
+                 - Intel Mac: mpv is typically at /usr/local/bin/mpv\n\n\
+                 To fix, add Homebrew to your PATH:\n\
+                   export PATH=\"/opt/homebrew/bin:$PATH\"\n\
+                 (Add this line to ~/.zshrc or ~/.bash_profile)"
+            } else {
+                ""
+            };
+            anyhow::anyhow!(
+                "mpv not found. Please install mpv and ensure it's in your PATH.{}",
+                hint
+            )
+        })?;
+
+        // Create a unique IPC path for this session
+        let pipe_name = if cfg!(target_os = "windows") {
+            format!("\\\\.\\pipe\\mpv_ipc_{}", std::process::id())
+        } else {
+            format!("/tmp/mpv_ipc_{}", std::process::id())
+        };
+
+        let mut cmd = Command::new(&mpv_path);
+        cmd.arg(url)
+           .arg("--geometry=1280x720") // Start in 720p window (user preference)
+           .arg("--force-window")      // Ensure window opens even if audio-only initially
+           .arg("--no-fs")             // DISABLING FULLSCREEN - Force Windowed Mode
+           .arg("--osc=yes");          // Enable On Screen Controller for usability
+
+        // Apply smooth motion interpolation if enabled
+        if smooth_motion {
+            cmd.arg("--video-sync=display-resample") // Smooth motion sync (required for interpolation)
+               .arg("--interpolation=yes") // Frame generation / motion smoothing
+               .arg("--tscale=linear")     // Soap opera effect - smooth motion blending (GPU friendly)
+               .arg("--tscale-clamp=0.0"); // Allow full blending for maximum smoothness
+        }
+
+        // Only apply optimizations if not using default MPV settings
+        if !use_default_mpv {
+            cmd.arg("--cache=yes")
+               .arg("--cache-pause=yes")               // Pause when cache is starved
+               .arg("--cache-pause-wait=5")            // Wait for 5 seconds of cache before resuming (builds a buffer against live edge)
+               .arg("--cache-pause-initial=yes")       // Ensure we buffer 5 seconds initially
+               .arg("--network-timeout=10")            // Increased timeout to prevent premature EOF closures
+               .arg("--hls-bitrate=max")               // Force highest quality HLS to prevent bitrate switching loops
+               .arg("--tls-verify=no")                 // Ignore certificate errors for internal/sketchy HTTPS streams
+               .arg("--hr-seek=yes")                   // Precise seeking for better buffer recovery
+               // NETWORK TURBO MODE: Aggressive Caching for Stability
+               .arg("--demuxer-max-bytes=512MiB")      // Doubled cache to 512MB
+               .arg("--demuxer-max-back-bytes=128MiB") // Increase back buffer for seeking/rewind
+               .arg("--demuxer-readahead-secs=60")     // Buffer 1 full minute ahead (Adaptive Buffering)
+               .arg("--stream-buffer-size=8MiB")       // Low-level socket buffer
+               .arg("--load-unsafe-playlists=yes")     // Stay alive through malformed HLS fragments
+               .arg("--framedrop=vo")                  // Drop frames gracefully if GPU lags
+               .arg("--vd-lavc-fast")                  // Enable fast decoding optimizations
+               .arg("--vd-lavc-skiploopfilter=all")    // Major CPU saver for low-end machines
+               .arg("--vd-lavc-threads=0")             // Maximize thread usage for decoding
+               // LOW-END FRIENDLY UPSCALING (catmull_rom: good quality, low GPU cost)
+               .arg("--scale=catmull_rom")         // Clean upscaling, ~25% faster than spline36
+               .arg("--cscale=catmull_rom")        // Matching chroma scaler
+               .arg("--dscale=catmull_rom")        // Consistent downscaling
+               .arg("--scale-antiring=0.7")        // Reduce haloing
+               .arg("--cscale-antiring=0.7")
+               .arg("--hwdec=auto-copy")           // More compatible hardware decoding
+               // RECONNECT TURBO: Auto-reconnect on network drops (avoiding aggressive EOF looping)
+               .arg("--stream-lavf-o=reconnect_on_http_error=4xx,5xx,reconnect_on_network_error=1,reconnect_streamed=1,reconnect_delay_max=5,fflags=+genpts+igndts");
+
+            if cfg!(target_os = "windows") {
+                cmd.arg("--d3d11-flip=yes")            // Modern Windows presentation (faster)
+                   .arg("--gpu-api=d3d11");             // Force D3D11 (faster than OpenGL on Windows)
+            } else if cfg!(target_os = "macos") {
+                cmd.arg("--gpu-api=opengl");            // Generally safe default for macOS mpv
+            }
+        }
+
+        // Common settings for both modes
+        cmd.arg("--msg-level=all=no")
+           .arg("--term-status-msg=no")
+           .arg("--input-terminal=no") // Ignore terminal for input
+           .arg("--terminal=no")       // Completely disable terminal interactions
+           // USER AGENT MASQUERADE: Modern Chrome to avoid throttling
+           .arg("--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
+           // Keep window open if playback fails to see error (optional, maybe off for prod)
+           .arg("--keep-open=no")
+           // Logging for troubleshooting
+           .arg("--log-file=mpv_playback.log")
+           // IPC for status monitoring
+           .arg(format!("--input-ipc-server={}", pipe_name));
+
+        // Disconnect from terminal input/output to prevent hotkey conflicts
+        cmd.stdin(Stdio::null())
+           .stdout(Stdio::null())
+           .stderr(Stdio::null());
+
+        let child = cmd.spawn();
+
+        match child {
+            Ok(child) => {
+                {
+                    let mut guard = self.process.lock().map_err(|e| {
+                        anyhow::anyhow!("Failed to lock process mutex: {}", e)
+                    })?;
+                    *guard = Some(child);
+                }
+                {
+                    let mut ipc_guard = self.ipc_path.lock().map_err(|e| {
+                        anyhow::anyhow!("Failed to lock IPC path mutex: {}", e)
+                    })?;
+                    *ipc_guard = Some(PathBuf::from(&pipe_name));
+                }
+                Ok(())
+            }
+            Err(e) => {
+                let hint = if cfg!(target_os = "macos") {
+                    format!(
+                        "\n\nSearched for mpv at: {}\n\
+                        Hint: On Apple Silicon, Homebrew installs to /opt/homebrew/bin.\n\
+                        Add this to your ~/.zshrc: export PATH=\"/opt/homebrew/bin:$PATH\"",
+                        mpv_path
+                    )
+                } else {
+                    String::new()
+                };
+                Err(anyhow::anyhow!(
+                    "Failed to start mpv: {}.{}",
+                    e, hint
+                ))
+            }
+        }
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    fn play_vlc(&self, url: &str, smooth_motion: bool) -> Result<(), anyhow::Error> {
+        // Find vlc executable
+        let vlc_path = crate::setup::get_vlc_path().ok_or_else(|| {
+            anyhow::anyhow!("VLC not found. Please install VLC.")
+        })?;
+
+        let mut cmd = Command::new(&vlc_path);
+        
+        // Add Referrer validation (Common anti-scraping measure)
+        // Manual parsing to avoid adding 'url' crate dependency
+        if let Some(scheme_end) = url.find("://") {
+            let rest = &url[scheme_end + 3..];
+            if let Some(path_start) = rest.find('/') {
+                let host = &rest[..path_start];
+                let base = format!("{}://{}/", &url[..scheme_end], host);
+                cmd.arg(format!("--http-referrer={}", base));
+            }
+        }
+
+        cmd.arg(url)
+           .arg("--no-video-title-show") 
+           .arg("--http-user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
+           .arg("--http-reconnect")
+           .arg("--http-continuous")
+           .arg("--clock-jitter=500")           // Allow more jitter in stream clock
+           .arg("--network-caching=15000")      // 15 second buffer for TS streams
+           .arg("--gnutls-verify-trust-ee=no"); // For VLC HTTPS stability
+
+        // Apply smooth motion (deinterlacing) if enabled
+        if smooth_motion {
+            cmd.arg("--video-filter=deinterlace")
+               .arg("--deinterlace-mode=bob");
+        }
+        // DISCONNECT from terminal
+        cmd.stdin(Stdio::null())
+           .stdout(Stdio::null())
+           .stderr(Stdio::null());
+
+        #[cfg(windows)]
+        {
+            use std::os::windows::process::CommandExt;
+            const DETACHED_PROCESS: u32 = 0x00000008;
+            cmd.creation_flags(DETACHED_PROCESS);
+        }
+
+        let child = cmd.spawn()?;
+        
+        {
+            let mut guard = self.process.lock().map_err(|e| {
+                anyhow::anyhow!("Failed to lock process mutex: {}", e)
+            })?;
+            *guard = Some(child);
+        }
+        
+        Ok(())
+    }
+
+    /// Read the last few lines of the player logs to find errors
+    pub fn get_last_error_from_log(&self) -> Option<String> {
+        let logs = ["mpv_playback.log", "vlc_playback.log"];
+        
+        for log_file in logs {
+            if let Ok(content) = std::fs::read_to_string(log_file) {
+                let lines: Vec<&str> = content.lines().rev().take(15).collect();
+                for line in lines {
+                    let lower = line.to_lowercase();
+                    if lower.contains("error") || lower.contains("failed") || lower.contains("fatal") {
+                        // Clean up common VLC/MPV prefixes for cleaner UI display
+                        let cleaned = line.split("]: ").last().unwrap_or(line);
+                        return Some(cleaned.to_string());
+                    }
+                }
+            }
+        }
+        None
+    }
+
+    /// Check if MPV is still running (process alive)
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn is_running(&self) -> bool {
+        if let Ok(mut guard) = self.process.lock() {
+            if let Some(ref mut child) = *guard {
+                // try_wait returns Ok(Some(status)) if exited, Ok(None) if still running
+                match child.try_wait() {
+                    Ok(Some(_)) => false, // Process has exited
+                    Ok(None) => true,     // Still running
+                    Err(_) => false,      // Error, assume not running
+                }
+            } else {
+                false
+            }
+        } else {
+            false // Mutex poisoned, assume not running
+        }
+    }
+
+    /// Wait for MPV to actually start playing by polling process status
+    /// Returns Ok(true) if playback confirmed, Ok(false) if process died, Err on timeout
+    #[cfg(not(target_arch = "wasm32"))]
+    pub async fn wait_for_playback(&self, timeout_ms: u64) -> Result<bool, anyhow::Error> {
+        use tokio::time::{sleep, Duration, Instant};
+
+        let start = Instant::now();
+        let timeout = Duration::from_millis(timeout_ms);
+
+        // Give MPV a moment to initialize
+        sleep(Duration::from_millis(500)).await;
+
+        // Poll until process is confirmed running and has had time to buffer
+        while start.elapsed() < timeout {
+            if !self.is_running() {
+                // Process died, playback failed
+                return Ok(false);
+            }
+
+            // Check if process has been alive for at least 2 seconds
+            // This indicates MPV successfully connected and is playing
+            if start.elapsed() > Duration::from_millis(2000) {
+                return Ok(true);
+            }
+
+            sleep(Duration::from_millis(200)).await;
+        }
+
+        // If we reached here and process is still running, consider it a success
+        Ok(self.is_running())
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    pub fn play(&self, url: &str, _engine: PlayerEngine, _use_default_mpv: bool, _smooth_motion: bool) -> Result<(), anyhow::Error> {
+        self.stop();
+        if let Some(win) = window() {
+            let _ = win.alert_with_message(&format!("Play stream: {}", url));
+        }
+        Ok(())
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn stop(&self) {
+        if let Ok(mut guard) = self.process.lock() {
+            if let Some(mut child) = guard.take() {
+                let _ = child.kill();
+                let _ = child.wait();
+            }
+        }
+
+        if let Ok(mut ipc_guard) = self.ipc_path.lock() {
+            *ipc_guard = None;
+        }
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    pub fn stop(&self) {
+        if let Some(_win) = window() {
+            web_sys::console::log_1(&"Stopping stream".into());
+        }
+    }
+}
+
+impl Drop for Player {
+    fn drop(&mut self) {
+        #[cfg(not(target_arch = "wasm32"))]
+        self.stop();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@officebeats/matrix-iptv-cli",
-  "version": "4.0.4",
+  "version": "4.0.17",
   "description": "The premium Terminal IPTV Decoder",
   "main": "index.js",
   "bin": {