Terminal interface to find, download, and stream movies, TV shows, and live TV using local media players.
feat(player): support vlc playback for dash and signed cookie streams
Samir Hossains2a7729b65673
diff --git a/Cargo.lock b/Cargo.lockindex 80955ba..d15a1ad 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -1639,6 +1639,7 @@ dependencies = ["hickory-resolver","hmac","image",+ "libc","log","lru","md-5",@@ -2499,6 +2500,7 @@ dependencies = ["base64 0.22.1","bytes","futures-core",+ "futures-util","http","http-body","http-body-util",@@ -2518,12 +2520,14 @@ dependencies = ["sync_wrapper","tokio","tokio-rustls",+ "tokio-util","tower","tower-http","tower-service","url","wasm-bindgen","wasm-bindgen-futures",+ "wasm-streams","web-sys","webpki-roots",]@@ -3228,6 +3232,19 @@ dependencies = ["tokio",]+[[package]]+name = "tokio-util"+version = "0.7.19"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "494815d09bf52b5548659851081238f0ca39ff638363907596da739561c62c52"+dependencies = [+ "bytes",+ "futures-core",+ "futures-sink",+ "pin-project-lite",+ "tokio",+]+[[package]]name = "tower"version = "0.5.3"@@ -3481,6 +3498,19 @@ dependencies = ["unicode-ident",]+[[package]]+name = "wasm-streams"+version = "0.4.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "15053d8d85c7eccdbefef60f06769760a563c7f0a9d6902a13d35c7800b0ad65"+dependencies = [+ "futures-util",+ "js-sys",+ "wasm-bindgen",+ "wasm-bindgen-futures",+ "web-sys",+]+[[package]]name = "web-sys"version = "0.3.104"diff --git a/Cargo.toml b/Cargo.tomlindex b0025c4..ba54108 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -43,7 +43,7 @@ semver = "1.0.28"serde = { version = "1.0.228", features = ["derive"] }serde_json = "1.0.150"thiserror = "2.0.18"-tokio = { version = "1.52.3", features = ["rt-multi-thread", "macros", "sync", "time", "fs", "io-util", "signal", "process"] }+tokio = { version = "1.52.3", features = ["rt-multi-thread", "macros", "sync", "time", "fs", "io-util", "signal", "process", "net"] }url = "2.5.8"unicode-segmentation = "1.12.0"unicode-width = "0.2.0"@@ -52,7 +52,7 @@ percent-encoding = "2.3.2"log = "0.4.33"flexi_logger = "0.31.10"hickory-resolver = { version = "0.25.2", default-features = false, features = ["system-config", "tokio"] }-reqwest = { version = "0.12.12", default-features = false, features = ["json", "rustls-tls-webpki-roots"] }+reqwest = { version = "0.12.12", default-features = false, features = ["json", "rustls-tls-webpki-roots", "stream"] }sha2 = "0.10.8"flate2 = "1.0.35"tar = "0.4.44"@@ -77,3 +77,6 @@ strip = true[target.'cfg(not(target_os = "android"))'.dependencies]mimalloc = "0.1.52"++[target.'cfg(unix)'.dependencies]+libc = "0.2"diff --git a/docs/players.md b/docs/players.mdindex 78f1e7d..29dea10 100644--- a/docs/players.md+++ b/docs/players.md@@ -19,7 +19,7 @@ Resolution caches detected paths across runs while allowing newly installed play| Player | Invocation | Notes || :--- | :--- | :--- || mpv | `mpv --autofit=WxH --geometry=50%:50% --idle=no --keep-open=no [--start=..] [--script=..] [--script-opts=..] [--http-header-fields=..] [--sub-file=..] <url>` | Window sized to the terminal. Injects `moviebox_tracker.lua` for position tracking and resume. Flatpak mpv is launched via `flatpak run`. |-| VLC | `vlc --width=W --height=H --play-and-exit [--start-time=..] [--http-referrer=..] [--http-user-agent=..] [--sub-file=..] <url>` | Supports start time resume via `--start-time`. |+| VLC | `vlc --width=W --height=H --play-and-exit [--start-time=..] [--http-referrer=..] [--http-user-agent=..] [--sub-file=..] <url>` | Supports start time resume via `--start-time`. For CloudFront cookie-gated streams (MovieBox DASH), the URL is replaced by a loopback sidecar proxy address (`http://127.0.0.1:<port>/https/<host>/path`) that injects all auth headers server-side before forwarding chunks to VLC. || IINA | `iina-cli --keep-running --no-stdin --mpv-autofit=.. [--mpv-start=..] --mpv-http-header-fields=.. --mpv-sub-files=.. <url>` | Uses the installed IINA `iina-cli`; falls back to `open -a IINA <url>` only if the CLI is absent. || Android / Termux | `termux-open --chooser --content-type video/* <url>` (or `termux-open-url` / `termux-am`) | Opens an app chooser on the device, delegating playback to external apps (VLC, MX Player, Just Player, MPV Android). Requires `pkg install -y termux-tools termux-am`. Forwards `User-Agent`, `Referer`, and subtitles when using `termux-am`. |@@ -32,7 +32,7 @@ Playback sources (for example 4KHD and MovieBox) may carry `Referer`/`User-AgentMovieBox DASH streams additionally carry signed `Cookie` headers for CloudFront authentication.mpv/IINA send them via `http-header-fields` (`--http-header-fields=...` or `--mpv-http-header-fields=...`),while VLC maps them to `--http-referrer` / `--http-user-agent`. Android intent playback forwards `Referer`/`User-Agent` extras when using `am`/`termux-am`, and supports unauthenticated streams (CircleFTP, DhakaFlix, IPTV) and CDN streams natively.-The `supports_headers` gate in `app/playback.rs` validates whether a player can satisfy required stream headers. MovieBox-TUI strictly respects the user's configured default player: if the chosen player cannot satisfy a stream's headers (such as VLC or Android Player attempting to play signed MovieBox DASH manifests with CloudFront cookie requirements), playback will not silently fall back to an alternative player. Instead, an explicit warning notification informs the user of the lack of header support, prompting them to switch to a supported player or install one for their operating system (`mpv` and `IINA` on macOS; `mpv` on Linux and Windows).+The `supports_headers` gate in `app/playback.rs` validates whether a player can satisfy required stream headers. For VLC, signed CloudFront `Cookie` streams (such as MovieBox DASH manifests) are supported via an automatic detached loopback sidecar proxy (`--proxy-for-vlc`). The proxy injects the signed CloudFront cookies and auth headers server-side and streams chunks directly to VLC, running as an independent process group on Unix and a detached process on Windows so playback survives terminal closure. If an unproxied player cannot satisfy a stream's headers (such as Android Intent attempting to play signed Cookie streams), playback will not silently fall back to an alternative player. Instead, an explicit warning notification informs the user of the lack of header support, prompting them to switch to a supported player or install one for their operating system (`mpv`, `IINA`, or `VLC`).## Subtitles- mpv receives the remote subtitle URL directly (`--sub-file=<url>`); mpv fetches itdiff --git a/src/lib.rs b/src/lib.rsindex d85e659..d1703c5 100644--- a/src/lib.rs+++ b/src/lib.rs@@ -8,6 +8,7 @@ pub mod models;pub mod net;pub mod player;pub mod providers;+pub mod proxy;pub mod service;pub mod tui;pub mod updater;diff --git a/src/main.rs b/src/main.rsindex ac97047..4abfa8f 100644--- a/src/main.rs+++ b/src/main.rs@@ -68,6 +68,17 @@ impl Drop for TerminalGuard {#[tokio::main]async fn main() -> std::io::Result<()> {let args: Vec<String> = std::env::args().collect();+ if let Some(pos) = args.iter().position(|a| a == "--proxy-for-vlc") {+ let target_url = args.get(pos + 1).cloned().unwrap_or_default();+ let headers_json = args+ .get(pos + 2)+ .cloned()+ .unwrap_or_else(|| "[]".to_string());+ let headers: Vec<(String, String)> =+ serde_json::from_str(&headers_json).unwrap_or_default();+ moviebox_tui::proxy::run_sidecar(target_url, headers).await;+ return Ok(());+ }if args.iter().any(|arg| arg == "--help" || arg == "-h") {println!("moviebox-tui {}", env!("CARGO_PKG_VERSION"));println!("A terminal client for finding and streaming movies, TV shows, and anime.\n");diff --git a/src/player.rs b/src/player.rsindex 6835b68..9a82090 100644--- a/src/player.rs+++ b/src/player.rs@@ -76,7 +76,8 @@ pub fn supports_headers(kind: PlayerKind, headers: &[(String, String)]) -> boolmatch kind {PlayerKind::Mpv => true,PlayerKind::Iina => true,- PlayerKind::Vlc | PlayerKind::AndroidIntent => headers.iter().all(|(name, _)| {+ PlayerKind::Vlc => true,+ PlayerKind::AndroidIntent => headers.iter().all(|(name, _)| {name.eq_ignore_ascii_case("referer") || name.eq_ignore_ascii_case("user-agent")}),}@@ -85,11 +86,11 @@ pub fn supports_headers(kind: PlayerKind, headers: &[(String, String)]) -> boolpub fn header_capable_players() -> &'static [PlayerKind] {#[cfg(target_os = "macos")]{- &[PlayerKind::Mpv, PlayerKind::Iina]+ &[PlayerKind::Mpv, PlayerKind::Iina, PlayerKind::Vlc]}#[cfg(not(target_os = "macos"))]{- &[PlayerKind::Mpv]+ &[PlayerKind::Mpv, PlayerKind::Vlc]}}@@ -157,6 +158,10 @@ fn probe_android_opener() -> Option<AndroidOpener> {let is_termux = crate::updater::artifact::is_termux_environment();if let Ok(prefix) = std::env::var("PREFIX") {+ let termux_am = format!("{prefix}/bin/termux-am");+ if Path::new(&termux_am).is_file() {+ return Some(AndroidOpener::TermuxAm(termux_am));+ }let termux_open = format!("{prefix}/bin/termux-open");if Path::new(&termux_open).is_file() {return Some(AndroidOpener::TermuxOpen(termux_open));@@ -165,12 +170,12 @@ fn probe_android_opener() -> Option<AndroidOpener> {if Path::new(&termux_open_url).is_file() {return Some(AndroidOpener::TermuxOpenUrl(termux_open_url));}- let termux_am = format!("{prefix}/bin/termux-am");- if Path::new(&termux_am).is_file() {- return Some(AndroidOpener::TermuxAm(termux_am));- }}+ let termux_am_static = "/data/data/com.termux/files/usr/bin/termux-am";+ if Path::new(termux_am_static).is_file() {+ return Some(AndroidOpener::TermuxAm(termux_am_static.to_string()));+ }let termux_open_static = "/data/data/com.termux/files/usr/bin/termux-open";if Path::new(termux_open_static).is_file() {return Some(AndroidOpener::TermuxOpen(termux_open_static.to_string()));@@ -181,27 +186,29 @@ fn probe_android_opener() -> Option<AndroidOpener> {termux_open_url_static.to_string(),));}- let termux_am_static = "/data/data/com.termux/files/usr/bin/termux-am";- if Path::new(termux_am_static).is_file() {- return Some(AndroidOpener::TermuxAm(termux_am_static.to_string()));- }+ if let Some(path) = find_in_path("termux-am") {+ return Some(AndroidOpener::TermuxAm(path));+ }if let Some(path) = find_in_path("termux-open") {return Some(AndroidOpener::TermuxOpen(path));}if let Some(path) = find_in_path("termux-open-url") {return Some(AndroidOpener::TermuxOpenUrl(path));}- if let Some(path) = find_in_path("termux-am") {- return Some(AndroidOpener::TermuxAm(path));- }-if !is_termux {- if Path::new("/system/bin/am").is_file() {- return Some(AndroidOpener::SystemAm("/system/bin/am".to_string()));- }- if let Some(path) = find_in_path("am") {- return Some(AndroidOpener::SystemAm(path));+ #[cfg(target_os = "android")]+ let is_root = unsafe { libc::getuid() == 0 };+ #[cfg(not(target_os = "android"))]+ let is_root = true;++ if is_root {+ if Path::new("/system/bin/am").is_file() {+ return Some(AndroidOpener::SystemAm("/system/bin/am".to_string()));+ }+ if let Some(path) = find_in_path("am") {+ return Some(AndroidOpener::SystemAm(path));+ }}}@@ -1405,10 +1412,10 @@ mod tests {}#[test]- fn header_support_rejects_android_and_unsupported_vlc_headers() {+ fn header_support_rejects_android_cookies_and_allows_vlc_proxy() {let headers = vec![("Cookie".into(), "session=secret".into())];assert!(!supports_headers(PlayerKind::AndroidIntent, &headers));- assert!(!supports_headers(PlayerKind::Vlc, &headers));+ assert!(supports_headers(PlayerKind::Vlc, &headers));assert!(supports_headers(PlayerKind::Vlc,&[("referer".into(), "https://example.test/".into())]diff --git a/src/proxy.rs b/src/proxy.rsnew file mode 100644index 0000000..56a22f0--- /dev/null+++ b/src/proxy.rs@@ -0,0 +1,484 @@+use std::path::PathBuf;+use std::process::{Command, Stdio};+use std::sync::atomic::{AtomicUsize, Ordering};+use std::sync::{Arc, Mutex};+use std::time::{Duration, Instant};++use futures::StreamExt;+use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};+use tokio::net::{TcpListener, TcpStream};++const MAX_LINE_BYTES: usize = 8 * 1024;+const MAX_HEADERS: usize = 64;+const MAX_MANIFEST_BYTES: usize = 10 * 1024 * 1024;+const CHUNK_IDLE_TIMEOUT_SECS: u64 = 60;+const WATCHDOG_IDLE_SECS: u64 = 600;++struct ConnectionGuard {+ conns: Arc<AtomicUsize>,+ activity: Arc<Mutex<Instant>>,+}++impl Drop for ConnectionGuard {+ fn drop(&mut self) {+ self.conns.fetch_sub(1, Ordering::Relaxed);+ if let Ok(mut lock) = self.activity.lock() {+ *lock = Instant::now();+ }+ }+}++pub fn spawn_sidecar(target_url: &str, headers: &[(String, String)]) -> Result<String, String> {+ let exe = std::env::current_exe()+ .ok()+ .or_else(|| std::env::args().next().map(PathBuf::from))+ .ok_or_else(|| "unable to locate current executable".to_string())?;++ let headers_json = serde_json::to_string(headers).unwrap_or_else(|_| "[]".to_string());++ let mut cmd = Command::new(exe);+ cmd.args(["--proxy-for-vlc", target_url, &headers_json]);+ cmd.stdin(Stdio::null());+ cmd.stdout(Stdio::piped());+ cmd.stderr(Stdio::null());++ #[cfg(unix)]+ {+ use std::os::unix::process::CommandExt;+ cmd.process_group(0);+ }++ #[cfg(windows)]+ {+ use std::os::windows::process::CommandExt;+ const DETACHED_PROCESS: u32 = 0x0000_0008;+ const CREATE_NEW_PROCESS_GROUP: u32 = 0x0000_0200;+ cmd.creation_flags(DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP);+ }++ let mut child = cmd+ .spawn()+ .map_err(|e| format!("failed to spawn proxy sidecar: {e}"))?;++ let stdout = child+ .stdout+ .take()+ .ok_or_else(|| "failed to capture sidecar stdout".to_string())?;++ let (tx, rx) = std::sync::mpsc::channel();+ std::thread::spawn(move || {+ use std::io::BufRead;+ let mut line = String::new();+ let _ = std::io::BufReader::new(stdout).read_line(&mut line);+ let _ = tx.send(line);+ });++ let line = rx.recv_timeout(Duration::from_secs(8)).map_err(|_| {+ let _ = child.kill();+ let _ = child.wait();+ "proxy sidecar timed out waiting for PORT line".to_string()+ })?;++ let port: u16 = line+ .trim()+ .strip_prefix("PORT ")+ .and_then(|s| s.parse().ok())+ .ok_or_else(|| {+ let _ = child.kill();+ let _ = child.wait();+ format!("proxy sidecar returned unexpected output: {line:?}")+ })?;++ let proxy_path = if let Some(rest) = target_url.strip_prefix("https://") {+ format!("/https/{rest}")+ } else if let Some(rest) = target_url.strip_prefix("http://") {+ format!("/http/{rest}")+ } else {+ format!("/https/{target_url}")+ };++ Ok(format!("http://127.0.0.1:{port}{proxy_path}"))+}++pub async fn run_sidecar(target_url: String, headers: Vec<(String, String)>) {+ let client = crate::net::http_client_builder()+ .connect_timeout(Duration::from_secs(15))+ .build()+ .unwrap_or_default();++ let listener = match TcpListener::bind("127.0.0.1:0").await {+ Ok(l) => l,+ Err(_) => return,+ };++ let port = match listener.local_addr() {+ Ok(addr) => addr.port(),+ Err(_) => return,+ };++ println!("PORT {port}");+ use std::io::Write;+ let _ = std::io::stdout().flush();++ let active_connections = Arc::new(AtomicUsize::new(0));+ let last_activity = Arc::new(Mutex::new(Instant::now()));++ let watchdog_conns = Arc::clone(&active_connections);+ let watchdog_activity = Arc::clone(&last_activity);+ tokio::spawn(async move {+ loop {+ tokio::time::sleep(Duration::from_secs(15)).await;+ let conns = watchdog_conns.load(Ordering::Relaxed);+ let elapsed = {+ let lock = watchdog_activity.lock().unwrap();+ lock.elapsed()+ };+ if conns == 0 && elapsed > Duration::from_secs(WATCHDOG_IDLE_SECS) {+ std::process::exit(0);+ }+ }+ });++ let target_host = extract_host_authority(&target_url);++ loop {+ let (stream, _) = match listener.accept().await {+ Ok(val) => val,+ Err(err) => {+ log::warn!("transient proxy accept error: {err}");+ tokio::time::sleep(Duration::from_millis(50)).await;+ continue;+ }+ };+ let client = client.clone();+ let headers = headers.clone();+ let target_host = target_host.clone();+ let active_conns = Arc::clone(&active_connections);+ let activity = Arc::clone(&last_activity);++ active_conns.fetch_add(1, Ordering::Relaxed);+ {+ if let Ok(mut lock) = activity.lock() {+ *lock = Instant::now();+ }+ }++ tokio::spawn(async move {+ let _guard = ConnectionGuard {+ conns: active_conns,+ activity,+ };+ let _ =+ handle_connection(stream, port, &client, &headers, target_host.as_deref()).await;+ });+ }+}++fn extract_host_authority(url: &str) -> Option<String> {+ let after_scheme = url+ .strip_prefix("https://")+ .or_else(|| url.strip_prefix("http://"))?;+ let authority = after_scheme.split('/').next()?;+ if authority.is_empty() {+ None+ } else {+ Some(authority.to_string())+ }+}++async fn handle_connection(+ stream: TcpStream,+ proxy_port: u16,+ client: &reqwest::Client,+ auth_headers: &[(String, String)],+ target_host: Option<&str>,+) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {+ let (reader, mut writer) = stream.into_split();+ let mut buf_reader = BufReader::new(reader);++ let mut request_line = String::new();+ let n = buf_reader.read_line(&mut request_line).await?;+ if n == 0 {+ return Ok(());+ }+ if request_line.len() > MAX_LINE_BYTES {+ writer+ .write_all(b"HTTP/1.1 431 Request Header Fields Too Large\r\nContent-Length: 0\r\nConnection: close\r\n\r\n")+ .await?;+ return Ok(());+ }++ let mut parts = request_line.split_whitespace();+ let method = parts.next().unwrap_or("GET");+ let path_and_query = parts.next().unwrap_or("/");++ let mut range_header = None;+ let mut header_count = 0usize;+ loop {+ let mut header_line = String::new();+ if buf_reader.read_line(&mut header_line).await? == 0 {+ break;+ }+ let trimmed = header_line.trim();+ if trimmed.is_empty() {+ break;+ }+ if header_line.len() > MAX_LINE_BYTES {+ break;+ }+ header_count += 1;+ if header_count > MAX_HEADERS {+ break;+ }+ if let Some((name, val)) = trimmed.split_once(':') {+ if name.trim().eq_ignore_ascii_case("range") {+ range_header = Some(val.trim().to_string());+ }+ }+ }++ let target_url = match extract_target_url(path_and_query) {+ Some(url) => url,+ None => {+ let response =+ "HTTP/1.1 400 Bad Request\r\nContent-Length: 0\r\nConnection: close\r\n\r\n";+ writer.write_all(response.as_bytes()).await?;+ return Ok(());+ }+ };++ let mut req = match method {+ "HEAD" => client.head(&target_url),+ _ => client.get(&target_url),+ };++ for (name, val) in auth_headers {+ req = req.header(name.as_str(), val.as_str());+ }+ if let Some(range) = range_header {+ req = req.header("Range", range);+ }++ let upstream_res = match req.send().await {+ Ok(res) => res,+ Err(e) => {+ let body = format!("Gateway Error: {e}");+ let response = format!(+ "HTTP/1.1 502 Bad Gateway\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",+ body.len()+ );+ writer.write_all(response.as_bytes()).await?;+ return Ok(());+ }+ };++ let status = upstream_res.status();+ let status_line = format!(+ "HTTP/1.1 {} {}\r\n",+ status.as_u16(),+ status.canonical_reason().unwrap_or("OK")+ );+ writer.write_all(status_line.as_bytes()).await?;++ let content_length = upstream_res+ .headers()+ .get(reqwest::header::CONTENT_LENGTH)+ .and_then(|v| v.to_str().ok())+ .and_then(|s| s.parse::<usize>().ok());++ let is_dash_manifest = target_url.ends_with(".mpd")+ || upstream_res+ .headers()+ .get(reqwest::header::CONTENT_TYPE)+ .and_then(|v| v.to_str().ok())+ .map(|ct| ct.contains("dash+xml") || ct.contains("xml"))+ .unwrap_or(false);++ let within_manifest_limit = content_length.is_none_or(|len| len <= MAX_MANIFEST_BYTES);++ if is_dash_manifest && status.is_success() && within_manifest_limit {+ let manifest_bytes = upstream_res.bytes().await?;+ if manifest_bytes.len() > MAX_MANIFEST_BYTES {+ let body = "Manifest too large";+ writer+ .write_all(+ format!(+ "Content-Type: text/plain\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",+ body.len()+ )+ .as_bytes(),+ )+ .await?;+ return Ok(());+ }+ let manifest_str = String::from_utf8_lossy(&manifest_bytes);+ let rewritten = rewrite_dash_manifest(&manifest_str, proxy_port, target_host);+ let rewritten_bytes = rewritten.as_bytes();++ let headers_out = format!(+ "Content-Type: application/dash+xml\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",+ rewritten_bytes.len()+ );+ writer.write_all(headers_out.as_bytes()).await?;+ writer.write_all(rewritten_bytes).await?;+ writer.flush().await?;+ return Ok(());+ }++ for (header_name, header_val) in upstream_res.headers() {+ let name_str = header_name.as_str();+ if name_str.eq_ignore_ascii_case("content-type")+ || name_str.eq_ignore_ascii_case("content-length")+ || name_str.eq_ignore_ascii_case("content-range")+ || name_str.eq_ignore_ascii_case("accept-ranges")+ {+ if let Ok(val_str) = header_val.to_str() {+ writer+ .write_all(format!("{name_str}: {val_str}\r\n").as_bytes())+ .await?;+ }+ }+ }+ writer.write_all(b"Connection: close\r\n\r\n").await?;++ let mut stream = upstream_res.bytes_stream();+ loop {+ let chunk_result =+ tokio::time::timeout(Duration::from_secs(CHUNK_IDLE_TIMEOUT_SECS), stream.next()).await;+ match chunk_result {+ Ok(Some(Ok(chunk))) => writer.write_all(&chunk).await?,+ Ok(Some(Err(e))) => return Err(Box::new(e)),+ Ok(None) => break,+ Err(_elapsed) => break,+ }+ }+ writer.flush().await?;++ Ok(())+}++fn extract_target_url(path_and_query: &str) -> Option<String> {+ let raw = path_and_query.strip_prefix('/')?;+ if let Some(rest) = raw.strip_prefix("https/") {+ Some(format!("https://{rest}"))+ } else if let Some(rest) = raw.strip_prefix("http/") {+ Some(format!("http://{rest}"))+ } else if raw.starts_with("proxy?") || raw.contains("&url=") || raw.starts_with("proxy?url=") {+ let query_start = raw.find('?')?;+ let query = &raw[query_start + 1..];+ for pair in query.split('&') {+ if let Some((k, v)) = pair.split_once('=') {+ if k == "url" {+ return percent_encoding::percent_decode_str(v)+ .decode_utf8()+ .ok()+ .map(|s| s.into_owned());+ }+ }+ }+ None+ } else {+ None+ }+}++fn rewrite_dash_manifest(manifest: &str, proxy_port: u16, target_host: Option<&str>) -> String {+ let Some(host) = target_host else {+ return manifest.to_string();+ };++ let https_prefix = format!("https://{host}/");+ let http_prefix = format!("http://{host}/");++ let proxy_https = format!("http://127.0.0.1:{proxy_port}/https/{host}/");+ let proxy_http = format!("http://127.0.0.1:{proxy_port}/http/{host}/");++ manifest+ .replace(&https_prefix, &proxy_https)+ .replace(&http_prefix, &proxy_http)+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn test_extract_target_url() {+ assert_eq!(+ extract_target_url("/https/sacdn.example.com/dash/index.mpd").as_deref(),+ Some("https://sacdn.example.com/dash/index.mpd")+ );+ assert_eq!(+ extract_target_url("/http/example.com/video.mp4").as_deref(),+ Some("http://example.com/video.mp4")+ );+ assert_eq!(+ extract_target_url("/https/example.com/seg.m4s?token=abc&exp=123").as_deref(),+ Some("https://example.com/seg.m4s?token=abc&exp=123")+ );+ assert_eq!(+ extract_target_url("/proxy?url=https%3A%2F%2Fexample.com%2Ffallback.mpd").as_deref(),+ Some("https://example.com/fallback.mpd")+ );+ assert_eq!(extract_target_url("/invalid/path"), None);+ }++ #[test]+ fn test_extract_host_authority_strips_path_preserves_port() {+ assert_eq!(+ extract_host_authority("https://cdn.example.com/dash/index.mpd").as_deref(),+ Some("cdn.example.com")+ );+ assert_eq!(+ extract_host_authority("http://cdn.example.com:8080/dash/index.mpd").as_deref(),+ Some("cdn.example.com:8080")+ );+ assert_eq!(extract_host_authority("not-a-url"), None);+ }++ #[test]+ fn test_rewrite_dash_manifest_scoped_to_target_host() {+ let manifest = r#"<MPD xmlns="urn:mpeg:dash:schema:mpd:2011" xsi:schemaLocation="urn:mpeg:dash:schema:mpd:2011 https://standards.iso.org/schema.xsd">+<Period>+ <AdaptationSet>+ <Representation id="1080p">+ <BaseURL>https://sacdn.example.com/dash/123/1080.mp4</BaseURL>+ <SegmentTemplate initialization="https://sacdn.example.com/dash/123/init.m4s" media="seg_$Number$.m4s" />+ </Representation>+ </AdaptationSet>+</Period>+</MPD>"#;++ let rewritten = rewrite_dash_manifest(manifest, 8888, Some("sacdn.example.com"));++ assert!(+ rewritten.contains("https://standards.iso.org/schema.xsd"),+ "XML namespace schema must not be corrupted"+ );++ assert!(+ rewritten.contains("http://127.0.0.1:8888/https/sacdn.example.com/dash/123/1080.mp4"),+ "Matching host BaseURL must be rewritten to proxy route"+ );++ assert!(+ rewritten.contains("http://127.0.0.1:8888/https/sacdn.example.com/dash/123/init.m4s"),+ "Matching host initialization URL must be rewritten to proxy route"+ );++ assert!(+ rewritten.contains("media=\"seg_$Number$.m4s\""),+ "Relative media template must remain relative"+ );+ }++ #[test]+ fn test_rewrite_dash_manifest_with_explicit_port() {+ let manifest = r#"<MPD><Period><BaseURL>https://cdn.example.com:8080/dash/seg.mp4</BaseURL></Period></MPD>"#;+ let rewritten = rewrite_dash_manifest(manifest, 9999, Some("cdn.example.com:8080"));+ assert!(+ rewritten.contains("http://127.0.0.1:9999/https/cdn.example.com:8080/dash/seg.mp4"),+ "Port must be preserved in proxy route"+ );+ }+}diff --git a/src/tui/app/playback.rs b/src/tui/app/playback.rsindex 538f919..1c5ec3b 100644--- a/src/tui/app/playback.rs+++ b/src/tui/app/playback.rs@@ -330,9 +330,30 @@ impl App {.as_ref().map(|(p, s, se, ep)| (p.as_str(), s.as_str(), *se, *ep));+ let needs_proxy = matches!(kind, crate::tui::state::PlayerKind::Vlc)+ && headers.iter().any(|(name, _)| {+ !name.eq_ignore_ascii_case("referer")+ && !name.eq_ignore_ascii_case("user-agent")+ });++ let effective_link = if needs_proxy {+ match crate::proxy::spawn_sidecar(&link, &headers) {+ Ok(local_url) => local_url,+ Err(err) => {+ log::error!("Failed to spawn VLC proxy sidecar: {err}");+ let _ = sender.send(Action::SetStatus(format!(+ "VLC stream initialization failed: {err}"+ )));+ return;+ }+ }+ } else {+ link.clone()+ };+let mut command = crate::tui::player::command(kind,- &link,+ &effective_link,local_subtitle.as_deref(),&headers,window,@@ -677,7 +698,17 @@ impl App {if let Some(source) = self.state.pending_playback_source.take() {self.dispatch_playback_or_notify(source);} else {- self.action_sender.send(Action::LaunchMpv(link, None)).ok();+ let source = crate::providers::models::PlaybackSource {+ provider: self.state.active_provider,+ url: link,+ headers: vec![(+ "User-Agent".to_string(),+ self.service.client.user_agent().to_string(),+ )],+ subtitle: None,+ source_label: "Direct".to_string(),+ };+ self.dispatch_playback_or_notify(source);}}}@@ -697,43 +728,6 @@ impl App {self.action_sender.send(Action::DownloadStream(None)).ok();}}- Action::LaunchMpv(link, subtitle_url) => {- if self.state.is_playing {- self.state.notify(- NotificationKind::Warning,- "Playback active",- "Player is already running.",- );- return None;- }- if self.state.last_playback_launch.elapsed().as_millis() < 500 {- return None;- }- self.state.last_playback_launch = std::time::Instant::now();- self.state.is_resolving_playback = false;- let player = self.state.available_players.first().cloned();- match player {- None => {- let message = if crate::updater::artifact::is_termux_environment() {- "Install player intent tools: 'pkg install -y termux-tools termux-am' and ensure an Android player (VLC, MX Player, or Just Player) is installed."- } else {- "Install mpv, IINA, or VLC to enable playback."- };- self.state- .notify(NotificationKind::Error, "Player Unavailable", message);- }- Some(kind) => {- self.state.notify(- NotificationKind::Info,- "Opening Player",- format!("Launching {}.", kind.label()),- );- self.action_sender- .send(Action::LaunchPlayer(kind, link, subtitle_url))- .ok();- }- }- }Action::LaunchPlayer(kind, link, sub) => {self.state.is_resolving_playback = false;@@ -998,7 +992,7 @@ mod tests {async fn test_playback_resolving_lock_resets_on_incompatible_player() {let mut app = crate::tui::app::App::new();app.state.is_resolving_playback = true;- app.state.available_players = vec![crate::tui::state::PlayerKind::Vlc];+ app.state.available_players = vec![crate::tui::state::PlayerKind::AndroidIntent];let source = crate::providers::models::PlaybackSource {provider: crate::providers::models::ProviderKind::MovieBox,@@ -1020,9 +1014,9 @@ mod tests {let mut app = crate::tui::app::App::new();app.state.available_players = vec![crate::tui::state::PlayerKind::Mpv,- crate::tui::state::PlayerKind::Vlc,+ crate::tui::state::PlayerKind::AndroidIntent,];- app.state.default_player = Some("vlc".to_string());+ app.state.default_player = Some("android".to_string());let source = crate::providers::models::PlaybackSource {provider: crate::providers::models::ProviderKind::MovieBox,@@ -1036,7 +1030,7 @@ mod tests {assert_eq!(resolution,super::PlaybackResolution::ExplicitPlayerIncompatible {- chosen: crate::tui::state::PlayerKind::Vlc,+ chosen: crate::tui::state::PlayerKind::AndroidIntent,compatible_alternatives: vec![crate::tui::state::PlayerKind::Mpv],});@@ -1049,10 +1043,38 @@ mod tests {assert!(!app.state.player_picker_popup);let notification = app.state.notifications.back().expect("notification posted");- assert_eq!(notification.title, "VLC Incompatible");- assert!(notification.message.contains("VLC lacks header support"));+ assert_eq!(notification.title, "Android Player Incompatible");+ assert!(+ notification+ .message+ .contains("Android Player lacks header support")+ );assert!(notification.message.contains("mpv"));}++ #[tokio::test]+ async fn test_vlc_resolves_as_available_for_cookie_source() {+ let mut app = crate::tui::app::App::new();+ app.state.available_players = vec![+ crate::tui::state::PlayerKind::Mpv,+ crate::tui::state::PlayerKind::Vlc,+ ];+ app.state.default_player = Some("vlc".to_string());++ let source = crate::providers::models::PlaybackSource {+ provider: crate::providers::models::ProviderKind::MovieBox,+ url: "https://example.com/index.mpd".to_string(),+ headers: vec![("Cookie".to_string(), "CloudFront-Policy=test".to_string())],+ subtitle: None,+ source_label: "Multi-Res".to_string(),+ };++ let resolution = app.resolve_playback_player(&source);+ assert_eq!(+ resolution,+ super::PlaybackResolution::Available(crate::tui::state::PlayerKind::Vlc)+ );+ }#[tokio::test]async fn test_playback_resolving_lock_resets_on_player_crash() {let mut app = crate::tui::app::App::new();