Terminal interface to find, download, and stream movies, TV shows, and live TV using local media players.
feat: add 4KHDHub provider integration with resolver and playback support
Samir Hossainse3759ef57a47
diff --git a/src/cache.rs b/src/cache.rsindex c7c69fa..84126ed 100644--- a/src/cache.rs+++ b/src/cache.rs@@ -1,3 +1,4 @@+use crate::providers::models::ProviderKind;use std::fs;use std::path::PathBuf;@@ -25,8 +26,13 @@ fn read_json_cache(path: &PathBuf, expiry_secs: u64) -> Option<serde_json::Value}pub fn get_cache_dir(subdir: &str) -> PathBuf {+ get_provider_cache_dir(ProviderKind::MovieBox, subdir)+}++pub fn get_provider_cache_dir(provider: ProviderKind, subdir: &str) -> PathBuf {let mut path = dirs::cache_dir().unwrap_or_else(std::env::temp_dir);path.push("moviebox-tui");+ path.push(provider.cache_key());path.push(subdir);if !path.exists() {let _ = fs::create_dir_all(&path);@@ -35,7 +41,16 @@ pub fn get_cache_dir(subdir: &str) -> PathBuf {}pub fn get_cache_path(subject_id: &str, season: usize, episode: usize) -> PathBuf {- let mut path = get_cache_dir("streams");+ get_provider_stream_path(ProviderKind::MovieBox, subject_id, season, episode)+}++pub fn get_provider_stream_path(+ provider: ProviderKind,+ subject_id: &str,+ season: usize,+ episode: usize,+) -> PathBuf {+ let mut path = get_provider_cache_dir(provider, "streams");path.push(format!("{}_{}_{}.json", subject_id, season, episode));path}@@ -51,8 +66,24 @@ pub fn get_stream_cache()}+pub fn get_provider_stream_cache(+ provider: ProviderKind,+ subject_id: &str,+ season: usize,+ episode: usize,+) -> Option<serde_json::Value> {+ read_json_cache(+ &get_provider_stream_path(provider, subject_id, season, episode),+ CACHE_EXPIRY_SECS,+ )+}+pub fn get_details_path(subject_id: &str) -> PathBuf {- let mut path = get_cache_dir("details");+ get_provider_details_path(ProviderKind::MovieBox, subject_id)+}++pub fn get_provider_details_path(provider: ProviderKind, subject_id: &str) -> PathBuf {+ let mut path = get_provider_cache_dir(provider, "details");path.push(format!("details_{}.json", subject_id));path}@@ -61,8 +92,22 @@ pub fn get_details_cache(subject_id: &str) -> Option<serde_json::Value> {read_json_cache(&get_details_path(subject_id), CACHE_EXPIRY_SECS)}+pub fn get_provider_details_cache(+ provider: ProviderKind,+ subject_id: &str,+) -> Option<serde_json::Value> {+ read_json_cache(+ &get_provider_details_path(provider, subject_id),+ CACHE_EXPIRY_SECS,+ )+}+pub fn get_search_path(query: &str) -> PathBuf {- let mut path = get_cache_dir("search");+ get_provider_search_path(ProviderKind::MovieBox, query)+}++pub fn get_provider_search_path(provider: ProviderKind, query: &str) -> PathBuf {+ let mut path = get_provider_cache_dir(provider, "search");use md5::{Digest, Md5};let mut hasher = Md5::new();hasher.update(query.as_bytes());@@ -80,6 +125,17 @@ pub fn get_search_cache(query: &str) -> Option<serde_json::Value> {read_json_cache(&get_search_path(query), CACHE_EXPIRY_SECS)}+pub fn get_provider_search_cache(provider: ProviderKind, query: &str) -> Option<serde_json::Value> {+ let path = get_provider_search_path(provider, query);+ let value = read_json_cache(&path, CACHE_EXPIRY_SECS)?;+ if search_payload_has_results(&value) {+ Some(value)+ } else {+ let _ = fs::remove_file(path);+ None+ }+}+pub fn set_search_cache(query: &str, data: &serde_json::Value) {let path = get_search_path(query);if let Ok(content) = serde_json::to_string(data) {@@ -87,6 +143,26 @@ pub fn set_search_cache(query: &str, data: &serde_json::Value) {}}+pub fn set_provider_search_cache(provider: ProviderKind, query: &str, data: &serde_json::Value) {+ let path = get_provider_search_path(provider, query);+ if !search_payload_has_results(data) {+ let _ = fs::remove_file(path);+ return;+ }+ if let Ok(content) = serde_json::to_string(data) {+ let _ = fs::write(path, content);+ }+}++fn search_payload_has_results(data: &serde_json::Value) -> bool {+ data.get("results")+ .and_then(|results| results.as_array())+ .and_then(|results| results.first())+ .and_then(|result| result.get("subjects"))+ .and_then(|subjects| subjects.as_array())+ .is_some_and(|subjects| !subjects.is_empty())+}+pub fn set_details_cache(subject_id: &str, data: &serde_json::Value) {let path = get_details_path(subject_id);if let Ok(content) = serde_json::to_string(data) {@@ -94,6 +170,17 @@ pub fn set_details_cache(subject_id: &str, data: &serde_json::Value) {}}+pub fn set_provider_details_cache(+ provider: ProviderKind,+ subject_id: &str,+ data: &serde_json::Value,+) {+ let path = get_provider_details_path(provider, subject_id);+ if let Ok(content) = serde_json::to_string(data) {+ let _ = fs::write(path, content);+ }+}+pub fn set_stream_cache(subject_id: &str, season: usize, episode: usize, data: &serde_json::Value) {let path = get_cache_path(subject_id, season, episode);if let Ok(content) = serde_json::to_string(data) {@@ -101,6 +188,19 @@ pub fn set_stream_cache(subject_id: &str, season: usize, episode: usize, data: &}}+pub fn set_provider_stream_cache(+ provider: ProviderKind,+ subject_id: &str,+ season: usize,+ episode: usize,+ data: &serde_json::Value,+) {+ let path = get_provider_stream_path(provider, subject_id, season, episode);+ if let Ok(content) = serde_json::to_string(data) {+ let _ = fs::write(path, content);+ }+}+pub fn invalidate_stream_cache(subject_id: &str, season: usize, episode: usize) {let path = get_cache_path(subject_id, season, episode);if path.exists() {@@ -117,7 +217,7 @@ pub fn clear_all_cache() {}fn get_homepage_path(tab_id: &str, page: usize) -> PathBuf {- let mut path = get_cache_dir("homepage");+ let mut path = get_provider_cache_dir(ProviderKind::MovieBox, "homepage");path.push(format!("{}_{}.json", tab_id, page));path}@@ -132,3 +232,27 @@ pub fn set_homepage_cache(tab_id: &str, page: usize, data: &serde_json::Value) {let _ = fs::write(&path, content);}}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn provider_cache_paths_are_isolated() {+ let moviebox = get_provider_search_path(ProviderKind::MovieBox, "same");+ let fourk = get_provider_search_path(ProviderKind::FourKHdHub, "same");+ assert_ne!(moviebox, fourk);+ assert!(moviebox.to_string_lossy().contains("moviebox"));+ assert!(fourk.to_string_lossy().contains("fourkhdhub"));+ }++ #[test]+ fn empty_search_payloads_are_not_cacheable() {+ assert!(!search_payload_has_results(+ &serde_json::json!({ "results": [{ "subjects": [] }] })+ ));+ assert!(search_payload_has_results(+ &serde_json::json!({ "results": [{ "subjects": [{ "subjectId": "1" }] }] })+ ));+ }+}diff --git a/src/providers/fourkhdhub/client.rs b/src/providers/fourkhdhub/client.rsnew file mode 100644index 0000000..ce470c8--- /dev/null+++ b/src/providers/fourkhdhub/client.rs@@ -0,0 +1,310 @@+use super::{hubcloud, parser};+use crate::providers::models::{CatalogItem, MediaDetails, PlaybackSource, ProviderKind, Release};+use reqwest::Url;++const DEFAULT_BASE_URL: &str = "https://4khdhub.one/";++#[derive(thiserror::Error, Debug)]+pub enum FourKHdHubError {+ #[error("network error: {0}")]+ Network(#[from] reqwest::Error),+ #[error("invalid provider URL: {0}")]+ InvalidUrl(String),+ #[error("parse error: {0}")]+ Parse(String),+ #[error("no playable mirror resolved")]+ NoPlayableMirror,+}++#[derive(Clone)]+pub struct FourKHdHubClient {+ client: reqwest::Client,+ base_url: Url,+}++impl Default for FourKHdHubClient {+ fn default() -> Self {+ Self::new()+ }+}++impl FourKHdHubClient {+ pub fn new() -> Self {+ let base = std::env::var("MOVIEBOX_FOURKHDHUB_URL")+ .unwrap_or_else(|_| DEFAULT_BASE_URL.to_string());+ Self::with_base_url(&base).unwrap_or_else(|_| Self {+ client: build_client(),+ base_url: Url::parse(DEFAULT_BASE_URL).expect("valid default 4KHDHub URL"),+ })+ }++ pub fn with_base_url(base: &str) -> Result<Self, FourKHdHubError> {+ let base_url =+ Url::parse(base).map_err(|_| FourKHdHubError::InvalidUrl(base.to_string()))?;+ if base_url.scheme() != "https" {+ return Err(FourKHdHubError::InvalidUrl(base.to_string()));+ }+ Ok(Self {+ client: build_client(),+ base_url,+ })+ }++ pub async fn health_check(&self) -> Result<(), FourKHdHubError> {+ let response = self.client.get(self.base_url.clone()).send().await?;+ if !response.status().is_success() {+ return Err(FourKHdHubError::Parse(format!(+ "health check returned {}",+ response.status()+ )));+ }+ Ok(())+ }++ pub async fn search(&self, query: &str) -> Result<Vec<CatalogItem>, FourKHdHubError> {+ let mut url = self.base_url.clone();+ url.query_pairs_mut().append_pair("s", query);+ let html = self.fetch_text(url).await?;+ parser::parse_search(&self.base_url, &html)+ }++ pub async fn details(&self, id: &str) -> Result<MediaDetails, FourKHdHubError> {+ let url = self.provider_url(id)?;+ let html = self.fetch_text(url).await?;+ parser::parse_details(id, &html)+ }++ pub async fn releases(+ &self,+ id: &str,+ season: usize,+ episode: usize,+ ) -> Result<Vec<Release>, FourKHdHubError> {+ let url = self.provider_url(id)?;+ let html = self.fetch_text(url).await?;+ parser::parse_releases(&html, season, episode)+ }++ pub async fn resolve_release(+ &self,+ release: &Release,+ ) -> Result<PlaybackSource, FourKHdHubError> {+ if release.provider != ProviderKind::FourKHdHub {+ return Err(FourKHdHubError::Parse(+ "release belongs to another provider".into(),+ ));+ }+ for mirror in &release.mirrors {+ let candidates = if mirror.resolver_url.contains("hubcloud.") {+ hubcloud::resolve(&self.client, &mirror.resolver_url).await+ } else if mirror.resolver_url.contains("hubdrive.") {+ hubcloud::resolve_hubdrive(&self.client, &mirror.resolver_url).await+ } else {+ hubcloud::validate_playback_url(&mirror.resolver_url)+ .map(|url| vec![(url, mirror.label.clone(), mirror.headers.clone())])+ };+ if let Ok(candidates) = candidates {+ for (url, label, headers) in candidates {+ if let Ok(playable_url) = self.preflight(&url, &headers).await {+ return Ok(PlaybackSource {+ provider: ProviderKind::FourKHdHub,+ url: playable_url,+ headers,+ subtitle: None,+ source_label: label,+ });+ }+ }+ }+ }+ Err(FourKHdHubError::NoPlayableMirror)+ }++ async fn preflight(+ &self,+ url: &str,+ headers: &[(String, String)],+ ) -> Result<String, FourKHdHubError> {+ hubcloud::validate_playback_url(url)?;+ let mut request = self+ .client+ .get(url)+ .header(reqwest::header::RANGE, "bytes=0-0");+ for (name, value) in headers {+ request = request.header(name, value);+ }+ let response = request.send().await?.error_for_status()?;+ let mut final_url = response.url().clone();+ hubcloud::validate_playback_url(final_url.as_str())?;+ let content_type = response+ .headers()+ .get(reqwest::header::CONTENT_TYPE)+ .and_then(|value| value.to_str().ok())+ .unwrap_or_default()+ .to_ascii_lowercase();+ if content_type.contains("text/html")+ || content_type.contains("application/zip")+ || content_type.contains("text/plain")+ {+ let wrapped = final_url+ .query_pairs()+ .find(|(name, _)| name == "link")+ .map(|(_, value)| value.into_owned())+ .filter(|value| value.starts_with("https://"))+ .ok_or_else(|| {+ FourKHdHubError::Parse(format!("invalid media content type: {content_type}"))+ })?;+ hubcloud::validate_playback_url(&wrapped)?;+ let mut wrapped_request = self+ .client+ .get(&wrapped)+ .header(reqwest::header::RANGE, "bytes=0-0");+ for (name, value) in headers {+ wrapped_request = wrapped_request.header(name, value);+ }+ let wrapped_response = wrapped_request.send().await?.error_for_status()?;+ final_url = wrapped_response.url().clone();+ hubcloud::validate_playback_url(final_url.as_str())?;+ let wrapped_type = wrapped_response+ .headers()+ .get(reqwest::header::CONTENT_TYPE)+ .and_then(|value| value.to_str().ok())+ .unwrap_or_default()+ .to_ascii_lowercase();+ if wrapped_type.contains("text/html")+ || wrapped_type.contains("application/zip")+ || wrapped_type.contains("text/plain")+ {+ return Err(FourKHdHubError::Parse(format!(+ "invalid wrapped media content type: {wrapped_type}"+ )));+ }+ }+ Ok(final_url.to_string())+ }++ async fn fetch_text(&self, url: Url) -> Result<String, FourKHdHubError> {+ let response = self.client.get(url).send().await?.error_for_status()?;+ Ok(response.text().await?)+ }++ fn provider_url(&self, id: &str) -> Result<Url, FourKHdHubError> {+ let url = self+ .base_url+ .join(id.trim_start_matches('/'))+ .map_err(|_| FourKHdHubError::InvalidUrl(id.to_string()))?;+ if url.host_str() != self.base_url.host_str() {+ return Err(FourKHdHubError::InvalidUrl(id.to_string()));+ }+ Ok(url)+ }+}++fn build_client() -> reqwest::Client {+ reqwest::Client::builder()+ .timeout(std::time::Duration::from_secs(20))+ .connect_timeout(std::time::Duration::from_secs(5))+ .user_agent("Mozilla/5.0 MovieBox-TUI/0.1")+ .redirect(reqwest::redirect::Policy::limited(5))+ .build()+ .unwrap_or_default()+}++#[cfg(test)]+mod live_tests {+ use super::*;++ #[tokio::test]+ #[ignore = "requires live 4KHDHub network access"]+ async fn movie_and_series_catalog_gate() {+ let client = FourKHdHubClient::new();+ client.health_check().await.expect("provider health");++ for title in ["Oppenheimer", "Inception", "Interstellar"] {+ let movies = client.search(title).await.expect("movie search");+ let movie = movies+ .iter()+ .find(|item| item.title == title)+ .expect("exact movie");+ let details = client+ .details(&movie.id.value)+ .await+ .expect("movie details");+ assert_eq!(details.title, title);+ assert!(+ !client+ .releases(&movie.id.value, 0, 0)+ .await+ .expect("movie releases")+ .is_empty()+ );+ }++ for title in ["Breaking Bad", "Chernobyl", "Stranger Things", "Off Campus"] {+ let series = client.search(title).await.expect("series search");+ let show = series+ .iter()+ .find(|item| item.title == title)+ .expect("exact series");+ let show_details = client+ .details(&show.id.value)+ .await+ .expect("series details");+ assert!(show_details.seasons.iter().any(|season| {+ season.number == 1 && season.episodes.iter().any(|episode| episode.number == 1)+ }));+ let releases = client+ .releases(&show.id.value, 1, 1)+ .await+ .expect("episode releases");+ assert!(!releases.is_empty());+ assert!(+ releases+ .iter()+ .all(|release| release.season == Some(1) && release.episode == Some(1))+ );+ }+ }++ #[tokio::test]+ #[ignore = "requires live resolver and media hosts"]+ async fn hubcloud_resolution_gate() {+ let client = FourKHdHubClient::new();+ let movies = client.search("Oppenheimer").await.expect("movie search");+ let movie = movies+ .iter()+ .find(|item| item.title == "Oppenheimer")+ .expect("exact movie");+ let releases = client+ .releases(&movie.id.value, 0, 0)+ .await+ .expect("movie releases");+ let source = client+ .resolve_release(releases.first().expect("release"))+ .await+ .expect("playback source");+ assert_eq!(source.provider, ProviderKind::FourKHdHub);+ assert!(source.url.starts_with("https://"));+ }++ #[tokio::test]+ #[ignore = "requires live Off Campus resolver and PixelDrain"]+ async fn off_campus_episode_resolution_gate() {+ let client = FourKHdHubClient::new();+ let series = client.search("Off Campus").await.expect("series search");+ let show = series+ .iter()+ .find(|item| item.title == "Off Campus")+ .expect("exact series");+ let releases = client+ .releases(&show.id.value, 1, 1)+ .await+ .expect("episode releases");+ let source = client+ .resolve_release(releases.first().expect("episode release"))+ .await+ .expect("episode playback source");+ assert_eq!(source.provider, ProviderKind::FourKHdHub);+ assert!(source.url.contains("pixeldrain.dev/api/file/"));+ }+}diff --git a/src/providers/fourkhdhub/hubcloud.rs b/src/providers/fourkhdhub/hubcloud.rsnew file mode 100644index 0000000..823eca4--- /dev/null+++ b/src/providers/fourkhdhub/hubcloud.rs@@ -0,0 +1,272 @@+use super::client::FourKHdHubError;+use reqwest::Url;+use scraper::{Html, Selector};+use std::net::IpAddr;++pub async fn resolve(+ client: &reqwest::Client,+ drive_url: &str,+) -> Result<Vec<(String, String, Vec<(String, String)>)>, FourKHdHubError> {+ validate_resolver_url(drive_url)?;+ let drive_html = client+ .get(drive_url)+ .send()+ .await?+ .error_for_status()?+ .text()+ .await?;+ let sportverse_url = {+ let document = Html::parse_document(&drive_html);+ let download = Selector::parse("a#download")+ .map_err(|_| FourKHdHubError::Parse("invalid resolver selector".into()))?;+ document+ .select(&download)+ .filter_map(|node| node.value().attr("href"))+ .find(|href| href.starts_with("https://sportverse."))+ .map(str::to_string)+ .ok_or_else(|| FourKHdHubError::Parse("HubCloud resolver link missing".into()))?+ };++ let resolver_html = client+ .get(&sportverse_url)+ .send()+ .await?+ .error_for_status()?+ .text()+ .await?;+ let resolver = Html::parse_document(&resolver_html);+ let links = Selector::parse("a[href]")+ .map_err(|_| FourKHdHubError::Parse("invalid link selector".into()))?;++ let mut candidates = extract_script_pixeldrain_urls(&resolver_html)+ .into_iter()+ .map(|url| (0, url, "PixelDrain".to_string()))+ .collect::<Vec<_>>();+ candidates.extend(+ resolver+ .select(&links)+ .filter_map(|node| {+ let href = node.value().attr("href")?;+ let label = node.text().collect::<String>();+ validate_playback_url(href).ok().map(|url| {+ let url = pixeldrain_api_url(&url).unwrap_or(url);+ (score(&url, &label), url, clean_label(&label))+ })+ })+ .collect::<Vec<_>>(),+ );+ candidates.sort_by_key(|candidate| candidate.0);+ let mut resolved = candidates+ .into_iter()+ .map(|(_, url, label)| (url, label, Vec::new()))+ .collect::<Vec<_>>();+ resolved.dedup_by(|left, right| left.0 == right.0);+ if resolved.is_empty() {+ Err(FourKHdHubError::NoPlayableMirror)+ } else {+ Ok(resolved)+ }+}++pub async fn resolve_hubdrive(+ client: &reqwest::Client,+ drive_url: &str,+) -> Result<Vec<(String, String, Vec<(String, String)>)>, FourKHdHubError> {+ validate_hubdrive_url(drive_url)?;+ let html = client+ .get(drive_url)+ .send()+ .await?+ .error_for_status()?+ .text()+ .await?;+ let hubcloud_url = extract_hubcloud_drive_url(&html)+ .ok_or_else(|| FourKHdHubError::Parse("HubDrive HubCloud mirror missing".into()))?;+ resolve(client, &hubcloud_url).await+}++fn extract_hubcloud_drive_url(html: &str) -> Option<String> {+ let document = Html::parse_document(html);+ let links = Selector::parse("a[href]").ok()?;+ document.select(&links).find_map(|node| {+ let raw = node.value().attr("href")?;+ let url = Url::parse(raw).ok()?;+ let host = url.host_str()?;+ (host.starts_with("hubcloud.") && url.path().starts_with("/drive/"))+ .then(|| url.to_string())+ })+}++fn extract_script_pixeldrain_urls(html: &str) -> Vec<String> {+ const PREFIX: &str = "https://pixeldrain.dev/u/";+ let mut urls = Vec::new();+ let mut remainder = html;+ while let Some(variable_offset) = remainder.find("var pxl") {+ let variable = &remainder[variable_offset..];+ let Some(url_offset) = variable.find(PREFIX) else {+ break;+ };+ let candidate = &variable[url_offset..];+ let end = candidate+ .find(|character: char| {+ character == '"' || character == '\'' || character.is_whitespace()+ })+ .unwrap_or(candidate.len());+ if let Some(url) = pixeldrain_api_url(&candidate[..end])+ && !urls.contains(&url)+ {+ urls.push(url);+ }+ remainder = &candidate[end..];+ }+ urls+}++fn pixeldrain_api_url(raw: &str) -> Option<String> {+ let url = Url::parse(raw).ok()?;+ if url.host_str() != Some("pixeldrain.dev") {+ return None;+ }+ let id = url.path().strip_prefix("/u/")?.trim_matches('/');+ if id.is_empty()+ || !id+ .bytes()+ .all(|byte| byte.is_ascii_alphanumeric() || byte == b'-' || byte == b'_')+ {+ return None;+ }+ Some(format!("https://pixeldrain.dev/api/file/{id}?download"))+}++fn validate_resolver_url(raw: &str) -> Result<(), FourKHdHubError> {+ let url = Url::parse(raw).map_err(|_| FourKHdHubError::InvalidUrl(raw.into()))?;+ let host = url.host_str().unwrap_or_default();+ if url.scheme() != "https"+ || !host.starts_with("hubcloud.")+ || !url.path().starts_with("/drive/")+ {+ return Err(FourKHdHubError::InvalidUrl(raw.into()));+ }+ Ok(())+}++fn validate_hubdrive_url(raw: &str) -> Result<(), FourKHdHubError> {+ let url = Url::parse(raw).map_err(|_| FourKHdHubError::InvalidUrl(raw.into()))?;+ let host = url.host_str().unwrap_or_default();+ if url.scheme() != "https"+ || !host.starts_with("hubdrive.")+ || !url.path().starts_with("/file/")+ {+ return Err(FourKHdHubError::InvalidUrl(raw.into()));+ }+ Ok(())+}++pub fn validate_playback_url(raw: &str) -> Result<String, FourKHdHubError> {+ let url = Url::parse(raw).map_err(|_| FourKHdHubError::InvalidUrl(raw.into()))?;+ if url.scheme() != "https" || url.host_str().is_none() {+ return Err(FourKHdHubError::InvalidUrl(raw.into()));+ }+ let host = url.host_str().unwrap_or_default().to_ascii_lowercase();+ let path = url.path().to_ascii_lowercase();+ if host == "localhost"+ || host.ends_with(".local")+ || host+ .parse::<IpAddr>()+ .is_ok_and(|address| !is_public_ip(address))+ || path.ends_with(".zip")+ || path.contains("login.php")+ || path.contains("logout")+ {+ return Err(FourKHdHubError::InvalidUrl(raw.into()));+ }+ Ok(url.to_string())+}++fn is_public_ip(address: IpAddr) -> bool {+ match address {+ IpAddr::V4(address) => {+ !(address.is_private()+ || address.is_loopback()+ || address.is_link_local()+ || address.is_broadcast()+ || address.is_documentation()+ || address.is_unspecified())+ }+ IpAddr::V6(address) => {+ !(address.is_loopback()+ || address.is_unspecified()+ || address.is_unique_local()+ || address.is_unicast_link_local())+ }+ }+}++fn score(url: &str, label: &str) -> u8 {+ let value = format!("{} {}", url, label).to_ascii_lowercase();+ if value.contains("pixeldrain") || value.contains("pixel.hubcloud") {+ 0+ } else if value.contains("gpdl.") || value.contains("googleusercontent") {+ 1+ } else if value.contains("workers.dev") || value.contains("r2.dev") {+ 2+ } else if value.contains("latent.click") || value.contains("fsl") {+ 3+ } else {+ 4+ }+}++fn clean_label(label: &str) -> String {+ let clean = label.split_whitespace().collect::<Vec<_>>().join(" ");+ if clean.is_empty() {+ "Direct".into()+ } else {+ clean+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn rejects_local_and_non_media_destinations() {+ assert!(validate_playback_url("https://127.0.0.1/video.mp4").is_err());+ assert!(validate_playback_url("https://example.com/login.php").is_err());+ assert!(validate_playback_url("https://example.com/pack.zip").is_err());+ assert!(validate_playback_url("https://cdn.example.com/video.mp4").is_ok());+ }++ #[test]+ fn pixel_gateway_precedes_fsl() {+ assert!(+ score("https://pixel.hubcloud.cx/?id=x", "Download")+ < score("https://hub.latent.click/file", "FSL")+ );+ }++ #[test]+ fn extracts_hidden_pixeldrain_api_source() {+ let html = r#"+ <a href="https://pixeldrain.dev/u/dead">Pixel Server</a>+ <script>var pxl = "https://pixeldrain.dev/u/8UJ3KFve";</script>+ "#;+ assert_eq!(+ extract_script_pixeldrain_urls(html),+ vec!["https://pixeldrain.dev/api/file/8UJ3KFve?download"]+ );+ }++ #[test]+ fn extracts_hubcloud_fallback_from_hubdrive() {+ let html = r#"+ <a href="/login">Login</a>+ <a href="https://hubcloud.cx/drive/pss5r5pacmsn1lp">HubCloud Server</a>+ "#;+ assert_eq!(+ extract_hubcloud_drive_url(html).as_deref(),+ Some("https://hubcloud.cx/drive/pss5r5pacmsn1lp")+ );+ }+}diff --git a/src/providers/fourkhdhub/mod.rs b/src/providers/fourkhdhub/mod.rsnew file mode 100644index 0000000..6812315--- /dev/null+++ b/src/providers/fourkhdhub/mod.rs@@ -0,0 +1,6 @@+mod client;+mod hubcloud;+mod parser;++pub use client::{FourKHdHubClient, FourKHdHubError};+pub use parser::{details_to_moviebox_json, releases_to_moviebox_json, search_to_moviebox_json};diff --git a/src/providers/fourkhdhub/parser.rs b/src/providers/fourkhdhub/parser.rsnew file mode 100644index 0000000..1001d3b--- /dev/null+++ b/src/providers/fourkhdhub/parser.rs@@ -0,0 +1,540 @@+use super::client::FourKHdHubError;+use crate::providers::models::{+ CatalogItem, Episode, MediaDetails, MediaType, ProviderKind, ProviderMediaId, Release, Season,+ SourceMirror,+};+use reqwest::Url;+use scraper::{ElementRef, Html, Selector};+use std::collections::{BTreeMap, HashMap};++pub fn parse_search(base: &Url, html: &str) -> Result<Vec<CatalogItem>, FourKHdHubError> {+ let document = Html::parse_document(html);+ let card = selector("a.movie-card")?;+ let title = selector(".movie-card-title")?;+ let meta = selector(".movie-card-meta")?;+ let image = selector("img")?;+ let mut items = Vec::new();++ for node in document.select(&card) {+ let Some(href) = node.value().attr("href") else {+ continue;+ };+ let Ok(url) = base.join(href) else { continue };+ if url.host_str() != base.host_str() {+ continue;+ }+ let item_title = text_of(node.select(&title).next()).unwrap_or_default();+ if item_title.is_empty() {+ continue;+ }+ let meta_text = text_of(node.select(&meta).next()).unwrap_or_default();+ let year = first_four_digit_year(&meta_text);+ let media_type = if href.contains("-series-") {+ MediaType::Series+ } else {+ MediaType::Movie+ };+ let poster_url = node+ .select(&image)+ .next()+ .and_then(|img| img.value().attr("src"))+ .map(str::to_string);+ items.push(CatalogItem {+ id: ProviderMediaId {+ provider: ProviderKind::FourKHdHub,+ value: url.path().to_string(),+ },+ title: item_title,+ media_type,+ year,+ poster_url,+ season_count: parse_season_count(&meta_text),+ });+ }+ Ok(items)+}++pub fn parse_details(id: &str, html: &str) -> Result<MediaDetails, FourKHdHubError> {+ let document = Html::parse_document(html);+ let h1 = selector("h1")?;+ let raw_title = document+ .select(&h1)+ .find_map(|node| text_of(Some(node)))+ .filter(|text| !text.is_empty())+ .or_else(|| meta_content(&document, "meta[property=\"og:title\"]"))+ .ok_or_else(|| FourKHdHubError::Parse("title missing".into()))?;+ let title = strip_trailing_year(&raw_title);+ let media_type = if id.contains("-series-") {+ MediaType::Series+ } else {+ MediaType::Movie+ };+ let description = meta_content(&document, "meta[name=\"description\"]");+ let poster_url = meta_content(&document, "meta[property=\"og:image\"]");+ let year = find_metadata(&document, "Release:")+ .and_then(|value| first_four_digit_year(&value))+ .or_else(|| first_four_digit_year(&raw_title));+ let genres = document+ .select(&selector(".badge-outline a")?)+ .filter_map(|node| text_of(Some(node)))+ .filter(|value| {+ !matches!(+ value.as_str(),+ "Movies" | "Series" | "Hindi" | "English" | "Hollywood"+ )+ })+ .collect();+ let seasons = parse_seasons(&document)?;++ Ok(MediaDetails {+ id: ProviderMediaId {+ provider: ProviderKind::FourKHdHub,+ value: id.to_string(),+ },+ title,+ media_type,+ year,+ description,+ poster_url,+ genres,+ seasons,+ })+}++pub fn parse_releases(+ html: &str,+ season: usize,+ episode: usize,+) -> Result<Vec<Release>, FourKHdHubError> {+ let document = Html::parse_document(html);+ let item_selector = if season > 0 {+ selector("#episodes .episode-download-item")?+ } else {+ selector(".download-item")?+ };+ let filename_selector = if season > 0 {+ selector(".episode-file-title")?+ } else {+ selector(".file-title")?+ };+ let link_selector = selector("a[href]")?;+ let size_selector = selector(".badge-size, .badge")?;+ let mut grouped: HashMap<String, Release> = HashMap::new();++ for item in document.select(&item_selector) {+ let filename = text_of(item.select(&filename_selector).next()).unwrap_or_default();+ if filename.is_empty() || is_archive(&filename) {+ continue;+ }+ let parsed_episode = parse_season_episode(&filename);+ if season > 0 && parsed_episode != Some((season, episode)) {+ continue;+ }+ let mirrors = item+ .select(&link_selector)+ .filter_map(|link| {+ let href = link.value().attr("href")?;+ if !href.starts_with("https://") || href.contains("logout") {+ return None;+ }+ let label = text_of(Some(link)).unwrap_or_else(|| "Source".into());+ Some(SourceMirror {+ label,+ resolver_url: href.to_string(),+ headers: Vec::new(),+ direct_file: !href.contains("hubcloud.") && !href.contains("hubdrive."),+ })+ })+ .collect::<Vec<_>>();+ if mirrors.is_empty() {+ continue;+ }+ let size_text = item+ .select(&size_selector)+ .filter_map(|node| text_of(Some(node)))+ .find(|text| parse_size_bytes(text).is_some());+ let key = normalize_filename(&filename);+ let release = grouped.entry(key).or_insert_with(|| Release {+ provider: ProviderKind::FourKHdHub,+ quality: detect_quality(&filename),+ codec: detect_codec(&filename),+ language: detect_language(&filename),+ size_bytes: size_text.as_deref().and_then(parse_size_bytes),+ season: parsed_episode.map(|value| value.0),+ episode: parsed_episode.map(|value| value.1),+ filename: filename.clone(),+ mirrors: Vec::new(),+ });+ for mirror in mirrors {+ if !release+ .mirrors+ .iter()+ .any(|existing| existing.resolver_url == mirror.resolver_url)+ {+ release.mirrors.push(mirror);+ }+ }+ }+ let mut releases = grouped.into_values().collect::<Vec<_>>();+ releases.sort_by(|left, right| right.quality.cmp(&left.quality));+ Ok(releases)+}++fn parse_seasons(document: &Html) -> Result<Vec<Season>, FourKHdHubError> {+ let item = selector("#episodes .episode-download-item")?;+ let title = selector(".episode-file-title")?;+ let mut seasons: BTreeMap<usize, BTreeMap<usize, Episode>> = BTreeMap::new();+ for node in document.select(&item) {+ let filename = text_of(node.select(&title).next()).unwrap_or_default();+ let Some((season, episode)) = parse_season_episode(&filename) else {+ continue;+ };+ seasons+ .entry(season)+ .or_default()+ .entry(episode)+ .or_insert(Episode {+ season,+ number: episode,+ title: None,+ });+ }+ Ok(seasons+ .into_iter()+ .map(|(number, episodes)| Season {+ number,+ episodes: episodes.into_values().collect(),+ })+ .collect())+}++pub fn search_to_moviebox_json(items: &[CatalogItem]) -> serde_json::Value {+ let subjects = items+ .iter()+ .map(|item| {+ serde_json::json!({+ "subjectId": item.id.value,+ "title": item.title,+ "subjectType": if item.media_type == MediaType::Series { 2 } else { 1 },+ "releaseDate": item.year,+ "cover": { "url": item.poster_url },+ "season": item.season_count.unwrap_or_default()+ })+ })+ .collect::<Vec<_>>();+ serde_json::json!({ "results": [{ "subjects": subjects }] })+}++pub fn details_to_moviebox_json(details: &MediaDetails) -> serde_json::Value {+ let seasons = details+ .seasons+ .iter()+ .map(|season| {+ serde_json::json!({+ "se": season.number,+ "maxEp": season.episodes.len(),+ "episodeNumbers": season.episodes.iter().map(|episode| episode.number).collect::<Vec<_>>()+ })+ })+ .collect::<Vec<_>>();+ serde_json::json!({+ "id": details.id.value,+ "subjectId": details.id.value,+ "title": details.title,+ "subjectType": if details.media_type == MediaType::Series { 2 } else { 1 },+ "releaseDate": details.year,+ "description": details.description,+ "cover": { "url": details.poster_url },+ "genre": details.genres,+ "seasons": { "seasons": seasons }+ })+}++pub fn releases_to_moviebox_json(releases: &[Release]) -> serde_json::Value {+ let list = releases+ .iter()+ .enumerate()+ .map(|(index, release)| {+ let resolution = release+ .quality+ .as_deref()+ .and_then(|quality| quality.trim_end_matches('p').parse::<u64>().ok())+ .unwrap_or_default();+ serde_json::json!({+ "resourceId": format!("fourk-{}", index),+ "resourceLink": release.mirrors.first().map(|mirror| mirror.resolver_url.clone()),+ "title": release.filename,+ "fileName": release.filename,+ "size": release.size_bytes.map(|size| size.to_string()),+ "resolution": resolution,+ "codecName": release.codec,+ "uploadBy": format!("{} sources", release.mirrors.len()),+ "se": release.season.unwrap_or_default(),+ "ep": release.episode.unwrap_or_default(),+ "_fourk_release": release+ })+ })+ .collect::<Vec<_>>();+ serde_json::Value::Array(list)+}++fn selector(value: &str) -> Result<Selector, FourKHdHubError> {+ Selector::parse(value).map_err(|_| FourKHdHubError::Parse(format!("invalid selector: {value}")))+}++fn text_of(node: Option<ElementRef<'_>>) -> Option<String> {+ node.map(|node| node.text().collect::<Vec<_>>().join(" "))+ .map(|text| text.split_whitespace().collect::<Vec<_>>().join(" "))+ .filter(|text| !text.is_empty())+}++fn meta_content(document: &Html, query: &str) -> Option<String> {+ let selector = Selector::parse(query).ok()?;+ document+ .select(&selector)+ .next()+ .and_then(|node| node.value().attr("content"))+ .map(str::to_string)+}++fn find_metadata(document: &Html, label: &str) -> Option<String> {+ let item = Selector::parse(".metadata-item").ok()?;+ let label_selector = Selector::parse(".metadata-label").ok()?;+ let value_selector = Selector::parse(".metadata-value").ok()?;+ document.select(&item).find_map(|node| {+ let current = text_of(node.select(&label_selector).next())?;+ (current == label).then(|| text_of(node.select(&value_selector).next()))?+ })+}++fn first_four_digit_year(value: &str) -> Option<String> {+ value+ .as_bytes()+ .windows(4)+ .find(|window| window.iter().all(u8::is_ascii_digit) && matches!(window[0], b'1' | b'2'))+ .and_then(|window| std::str::from_utf8(window).ok())+ .map(str::to_string)+}++fn strip_trailing_year(value: &str) -> String {+ let trimmed = value.trim();+ if trimmed.len() >= 6 {+ let suffix = &trimmed[trimmed.len() - 6..];+ if suffix.starts_with('(')+ && suffix.ends_with(')')+ && suffix[1..5].bytes().all(|byte| byte.is_ascii_digit())+ {+ return trimmed[..trimmed.len() - 6].trim_end().to_string();+ }+ }+ trimmed.to_string()+}++fn parse_season_count(value: &str) -> Option<usize> {+ let marker = value.find('S')?;+ let suffix = &value[marker..];+ suffix+ .split(['-', ' ', '•'])+ .filter_map(|part| part.trim_start_matches('S').parse::<usize>().ok())+ .max()+}++fn parse_season_episode(value: &str) -> Option<(usize, usize)> {+ let upper = value.to_ascii_uppercase();+ let bytes = upper.as_bytes();+ for index in 0..bytes.len().saturating_sub(4) {+ if bytes[index] != b'S' {+ continue;+ }+ let Some(season_end) = bytes[index + 1..]+ .iter()+ .position(|byte| !byte.is_ascii_digit())+ .map(|offset| index + 1 + offset)+ else {+ continue;+ };+ if season_end == index + 1 || bytes.get(season_end) != Some(&b'E') {+ continue;+ }+ let episode_end = bytes[season_end + 1..]+ .iter()+ .position(|byte| !byte.is_ascii_digit())+ .map(|offset| season_end + 1 + offset)+ .unwrap_or(bytes.len());+ if episode_end == season_end + 1 {+ continue;+ }+ if let (Ok(season), Ok(episode)) = (+ upper[index + 1..season_end].parse(),+ upper[season_end + 1..episode_end].parse(),+ ) {+ return Some((season, episode));+ }+ }+ None+}++fn parse_size_bytes(value: &str) -> Option<u64> {+ let normalized = value.replace(' ', "").to_ascii_uppercase();+ for (suffix, multiplier) in [+ ("GB", 1024_u64.pow(3)),+ ("MB", 1024_u64.pow(2)),+ ("KB", 1024_u64),+ ] {+ if let Some(number) = normalized.strip_suffix(suffix)+ && let Ok(number) = number.parse::<f64>()+ {+ return Some((number * multiplier as f64) as u64);+ }+ }+ None+}++fn detect_quality(value: &str) -> Option<String> {+ ["2160p", "1080p", "720p", "480p"]+ .into_iter()+ .find(|quality| {+ value+ .to_ascii_lowercase()+ .contains(&quality.to_ascii_lowercase())+ })+ .map(str::to_string)+}++fn detect_codec(value: &str) -> Option<String> {+ ["HEVC", "x265", "x264", "AV1", "REMUX"]+ .into_iter()+ .find(|codec| {+ value+ .to_ascii_lowercase()+ .contains(&codec.to_ascii_lowercase())+ })+ .map(str::to_string)+}++fn detect_language(value: &str) -> Option<String> {+ let lower = value.to_ascii_lowercase();+ match (lower.contains("hindi"), lower.contains("english")) {+ (true, true) => Some("Hindi, English".into()),+ (true, false) => Some("Hindi".into()),+ (false, true) => Some("English".into()),+ _ => None,+ }+}++fn is_archive(value: &str) -> bool {+ let lower = value.to_ascii_lowercase();+ lower.ends_with(".zip") || lower.contains("complete season") || lower.contains("season pack")+}++fn normalize_filename(value: &str) -> String {+ value+ .to_ascii_lowercase()+ .chars()+ .filter(|character| character.is_ascii_alphanumeric())+ .collect()+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn parses_episode_identity() {+ assert_eq!(+ parse_season_episode("Breaking.Bad.S01E07.1080p.mkv"),+ Some((1, 7))+ );+ assert_eq!(parse_season_episode("movie.mkv"), None);+ }++ #[test]+ fn parses_sizes() {+ assert_eq!(parse_size_bytes("1.5 GB"), Some(1_610_612_736));+ assert_eq!(parse_size_bytes("480 MB"), Some(503_316_480));+ }++ #[test]+ fn strips_only_a_trailing_year_from_titles() {+ assert_eq!(strip_trailing_year("Oppenheimer (2023)"), "Oppenheimer");+ assert_eq!(strip_trailing_year("The 100"), "The 100");+ }++ #[test]+ fn archive_detection_excludes_packs() {+ assert!(is_archive("Show S01 Complete Season.zip"));+ assert!(!is_archive("Show S01E01.mkv"));+ }++ #[test]+ fn fixture_groups_mirrors_and_rejects_adjacent_episodes() {+ let html = r#"+ <div id="episodes">+ <div class="episode-download-item">+ <div class="episode-file-title">Show.S01E01.1080p.HEVC.English.mkv</div>+ <span class="badge-size">1.5 GB</span>+ <a href="https://hubcloud.ist/drive/one">HubCloud</a>+ <a href="https://hubdrive.tips/file/one">HubDrive</a>+ </div>+ <div class="episode-download-item">+ <div class="episode-file-title">Show.S01E02.1080p.HEVC.English.mkv</div>+ <a href="https://hubcloud.ist/drive/two">HubCloud</a>+ </div>+ <div class="episode-download-item">+ <div class="episode-file-title">Show.S01.Complete.Season.zip</div>+ <a href="https://hubcloud.ist/drive/pack">HubCloud</a>+ </div>+ </div>+ "#;+ let releases = parse_releases(html, 1, 1).expect("fixture parses");+ assert_eq!(releases.len(), 1);+ assert_eq!(releases[0].mirrors.len(), 2);+ assert_eq!(releases[0].episode, Some(1));+ }++ #[test]+ fn compatibility_release_payload_is_an_array() {+ let payload = releases_to_moviebox_json(&[Release {+ provider: ProviderKind::FourKHdHub,+ filename: "Movie.2160p.HEVC.mkv".into(),+ quality: Some("2160p".into()),+ codec: Some("HEVC".into()),+ language: None,+ size_bytes: Some(1024),+ season: None,+ episode: None,+ mirrors: vec![SourceMirror {+ label: "HubCloud".into(),+ resolver_url: "https://hubcloud.ist/drive/test".into(),+ headers: vec![],+ direct_file: false,+ }],+ }]);+ assert!(payload.is_array());+ assert_eq!(payload[0]["resolution"], 2160);+ assert_eq!(payload[0]["se"], 0);+ assert_eq!(payload[0]["ep"], 0);+ }++ #[test]+ fn episode_payload_preserves_stream_pool_identity() {+ let payload = releases_to_moviebox_json(&[Release {+ provider: ProviderKind::FourKHdHub,+ filename: "Off.Campus.S01E01.2160p.mkv".into(),+ quality: Some("2160p".into()),+ codec: Some("HEVC".into()),+ language: Some("English".into()),+ size_bytes: Some(1024),+ season: Some(1),+ episode: Some(1),+ mirrors: vec![SourceMirror {+ label: "HubCloud".into(),+ resolver_url: "https://hubcloud.ist/drive/off-campus".into(),+ headers: vec![],+ direct_file: false,+ }],+ }]);+ assert_eq!(payload[0]["se"], 1);+ assert_eq!(payload[0]["ep"], 1);+ }+}diff --git a/src/providers/mod.rs b/src/providers/mod.rsindex a42d096..d2d5956 100644--- a/src/providers/mod.rs+++ b/src/providers/mod.rs@@ -1,2 +1,4 @@+pub mod fourkhdhub;pub mod iptv_org;+pub mod models;pub mod moviebox;diff --git a/src/providers/models.rs b/src/providers/models.rsnew file mode 100644index 0000000..b6fd016--- /dev/null+++ b/src/providers/models.rs@@ -0,0 +1,148 @@+use serde::{Deserialize, Serialize};+use std::fmt;++#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]+#[serde(rename_all = "snake_case")]+pub enum ProviderKind {+ #[default]+ MovieBox,+ FourKHdHub,+}++impl ProviderKind {+ pub const ENABLED: [Self; 2] = [Self::MovieBox, Self::FourKHdHub];++ pub const fn cache_key(self) -> &'static str {+ match self {+ Self::MovieBox => "moviebox",+ Self::FourKHdHub => "fourkhdhub",+ }+ }++ pub const fn label(self) -> &'static str {+ match self {+ Self::MovieBox => "MovieBox",+ Self::FourKHdHub => "4KHDHub",+ }+ }+}++impl fmt::Display for ProviderKind {+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+ f.write_str(self.label())+ }+}++#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]+pub struct ProviderMediaId {+ pub provider: ProviderKind,+ pub value: String,+}++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub struct RequestContext {+ pub provider: ProviderKind,+ pub generation: u64,+}++#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]+#[serde(rename_all = "snake_case")]+pub enum MediaType {+ Movie,+ Series,+}++#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]+pub struct CatalogItem {+ pub id: ProviderMediaId,+ pub title: String,+ pub media_type: MediaType,+ pub year: Option<String>,+ pub poster_url: Option<String>,+ pub season_count: Option<usize>,+}++#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]+pub struct Episode {+ pub season: usize,+ pub number: usize,+ pub title: Option<String>,+}++#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]+pub struct Season {+ pub number: usize,+ pub episodes: Vec<Episode>,+}++#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]+pub struct MediaDetails {+ pub id: ProviderMediaId,+ pub title: String,+ pub media_type: MediaType,+ pub year: Option<String>,+ pub description: Option<String>,+ pub poster_url: Option<String>,+ pub genres: Vec<String>,+ pub seasons: Vec<Season>,+}++#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]+pub struct SourceMirror {+ pub label: String,+ pub resolver_url: String,+ pub headers: Vec<(String, String)>,+ pub direct_file: bool,+}++#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]+pub struct Release {+ pub provider: ProviderKind,+ pub filename: String,+ pub quality: Option<String>,+ pub codec: Option<String>,+ pub language: Option<String>,+ pub size_bytes: Option<u64>,+ pub season: Option<usize>,+ pub episode: Option<usize>,+ pub mirrors: Vec<SourceMirror>,+}++#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]+pub struct PlaybackSource {+ pub provider: ProviderKind,+ pub url: String,+ pub headers: Vec<(String, String)>,+ pub subtitle: Option<String>,+ pub source_label: String,+}++impl PlaybackSource {+ pub fn bare(provider: ProviderKind, url: impl Into<String>, subtitle: Option<String>) -> Self {+ Self {+ provider,+ url: url.into(),+ headers: Vec::new(),+ subtitle,+ source_label: provider.label().to_string(),+ }+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn provider_scoped_ids_do_not_collide() {+ let moviebox = ProviderMediaId {+ provider: ProviderKind::MovieBox,+ value: "42".into(),+ };+ let fourk = ProviderMediaId {+ provider: ProviderKind::FourKHdHub,+ value: "42".into(),+ };+ assert_ne!(moviebox, fourk);+ }+}diff --git a/src/tui/action.rs b/src/tui/action.rsindex aac91f1..b148f65 100644--- a/src/tui/action.rs+++ b/src/tui/action.rs@@ -2,6 +2,7 @@pub enum Action {FocusChange,ShowPlayerPicker(String, Option<String>),+ ShowPlaybackPicker(crate::providers::models::PlaybackSource),LaunchPlayer(crate::tui::state::PlayerKind, String, Option<String>),Tick,Key(crossterm::event::KeyEvent),@@ -11,6 +12,7 @@ pub enum Action {Resize(u16, u16),ToggleHelp,ToggleTvMode,+ SwitchProvider(crate::providers::models::ProviderKind),ShowTvWizard,TvChannelsLoaded(Vec<crate::providers::iptv_org::m3u::Channel>),Search {@@ -21,10 +23,11 @@ pub enum Action {query: String,},SearchSuccess {+ context: crate::providers::models::RequestContext,query: String,payload: serde_json::Value,},- SearchFailure(String),+ SearchFailure(crate::providers::models::RequestContext, String),FetchHomepage {tab_id: String,page: usize,@@ -60,8 +63,12 @@ pub enum Action {ConfirmDownloadSeason,ProcessDownloadQueue,FetchDetails(String, bool),- DetailsSuccess(String, serde_json::Value),- DetailsFailure(String),+ DetailsSuccess(+ crate::providers::models::RequestContext,+ String,+ serde_json::Value,+ ),+ DetailsFailure(crate::providers::models::RequestContext, String),InitStreamPool(String),StreamPoolInitialized(String, Vec<u32>),FetchEpisodeStreams {@@ -70,8 +77,20 @@ pub enum Action {episode: usize,force_refresh: bool,},- EpisodeStreamsReady(String, usize, usize, serde_json::Value),- EpisodeStreamsFailed(String, usize, usize, String),+ EpisodeStreamsReady(+ crate::providers::models::RequestContext,+ String,+ usize,+ usize,+ serde_json::Value,+ ),+ EpisodeStreamsFailed(+ crate::providers::models::RequestContext,+ String,+ usize,+ usize,+ String,+ ),PosterSuccess(String, std::sync::Arc<image::DynamicImage>),SearchPosterLoaded(String, Option<std::sync::Arc<image::DynamicImage>>),UpdateAvailable(String),@@ -83,4 +102,8 @@ pub enum Action {SetStatus(String),Refresh,ClearCache,+ LaunchPlayback(+ crate::tui::state::PlayerKind,+ crate::providers::models::PlaybackSource,+ ),}diff --git a/src/tui/app.rs b/src/tui/app.rsindex 963fff0..0a0d1e9 100644--- a/src/tui/app.rs+++ b/src/tui/app.rs@@ -2,7 +2,14 @@ use ratatui::Frame;use std::time::Duration;use tokio::sync::mpsc;-use crate::providers::moviebox::client::MovieBoxClient;+use crate::providers::{+ fourkhdhub::{+ FourKHdHubClient, details_to_moviebox_json, releases_to_moviebox_json,+ search_to_moviebox_json,+ },+ models::{ProviderKind, Release, RequestContext},+ moviebox::client::MovieBoxClient,+};use crate::tui::{action::Action,event::EventHandler,@@ -10,6 +17,18 @@ use crate::tui::{theme::Theme,};+fn configure_mpv_window(command: &mut std::process::Command, iina: bool) {+ let prefix = if iina { "--mpv-" } else { "--" };+ command+ .arg(format!("{prefix}autofit=960x540"))+ .arg(format!("{prefix}autofit-larger=640x360"))+ .arg(format!("{prefix}geometry=50%:50%"));+}++fn configure_vlc_window(command: &mut std::process::Command) {+ command.arg("--width=960").arg("--height=540");+}+pub fn clean_moviebox_title(raw_title: &str) -> String {let mut end = raw_title.len();@@ -39,6 +58,7 @@ pub struct App {state: AppState,theme: Theme,client: MovieBoxClient,+ fourk_client: FourKHdHubClient,action_sender: mpsc::UnboundedSender<Action>,action_receiver: mpsc::UnboundedReceiver<Action>,}@@ -69,6 +89,11 @@ impl App {{state.last_update_check = last_check;}+ if config_json.get("active_provider").and_then(|v| v.as_str())+ == Some(ProviderKind::FourKHdHub.cache_key())+ {+ state.active_provider = ProviderKind::FourKHdHub;+ }}}}@@ -77,11 +102,89 @@ impl App {state,theme: Theme::new(),client: MovieBoxClient::new(),+ fourk_client: FourKHdHubClient::new(),action_sender,action_receiver,}}+ fn request_context(&self) -> RequestContext {+ RequestContext {+ provider: self.state.active_provider,+ generation: self.state.provider_generation,+ }+ }++ fn context_is_current(&self, context: RequestContext) -> bool {+ context.provider == self.state.active_provider+ && context.generation == self.state.provider_generation+ }++ fn persist_config(&self) {+ if let Some(config_dir) = dirs::config_dir() {+ let app_dir = config_dir.join("moviebox-tui");+ let _ = std::fs::create_dir_all(&app_dir);+ let config = serde_json::json!({+ "auto_update": self.state.auto_update,+ "last_update_check": self.state.last_update_check,+ "active_provider": self.state.active_provider.cache_key()+ });+ let _ = std::fs::write(app_dir.join("config.json"), config.to_string());+ }+ }++ fn switch_provider(&mut self, provider: ProviderKind) {+ if provider == self.state.active_provider {+ return;+ }+ self.state+ .fetch_cancel+ .store(true, std::sync::atomic::Ordering::SeqCst);+ self.state.fetch_cancel = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));+ self.state.provider_generation = self.state.provider_generation.wrapping_add(1);+ self.state.active_provider = provider;+ self.state.active_screen = Screen::Home;+ self.state.is_homepage_mode = false;+ self.state.is_tv_mode = false;+ self.state.is_loading = false;+ self.state.is_fetching_streams = false;+ self.state.search_results.clear();+ self.state.search_suggestions.clear();+ self.state.search_preview = None;+ self.state.selected_details = None;+ self.state.selected_resources = None;+ self.state.active_subject_id = None;+ self.state.available_seasons.clear();+ self.state.available_episode_numbers.clear();+ self.state.stream_pool.clear();+ self.state.poster_image = None;+ self.state.poster_protocol = None;+ self.state.search_poster_protocols.clear();+ self.state.search_list_state.select(None);+ self.state.resource_list_state.select(None);+ self.state.status_message = format!(+ "{} selected. Search uses only this provider.",+ provider.label()+ );+ self.state.status_timer = 180;+ self.persist_config();+ if provider == ProviderKind::MovieBox {+ let client = self.client.clone();+ tokio::spawn(async move {+ let _ = client.init().await;+ });+ }+ }++ fn cycle_provider(&mut self) {+ let current = ProviderKind::ENABLED+ .iter()+ .position(|provider| *provider == self.state.active_provider)+ .unwrap_or(0);+ let next = ProviderKind::ENABLED[(current + 1) % ProviderKind::ENABLED.len()];+ self.switch_provider(next);+ }+fn trigger_episode_fetch(&mut self) {if let Some(id) = &self.state.active_subject_id {let stype = self@@ -120,7 +223,9 @@ impl App {self.state.resource_list_state.select(None);let mut found_cached = false;- if let Some(cached) = crate::cache::get_stream_cache(id, se, ep) {+ if let Some(cached) =+ crate::cache::get_provider_stream_cache(self.state.active_provider, id, se, ep)+ {found_cached = true;if let Some(arr) = cached.as_array() {let count = arr.len();@@ -182,6 +287,17 @@ impl App {.map(|s| s.to_string())}+ fn get_selected_release(&self) -> Option<Release> {+ self.state+ .selected_resources+ .as_ref()?+ .get("list")?+ .as_array()?+ .get(self.state.resource_list_state.selected().unwrap_or(0))?+ .get("_fourk_release")+ .and_then(|value| serde_json::from_value(value.clone()).ok())+ }+pub async fn run<B: ratatui::backend::Backend>(&mut self,terminal: &mut ratatui::Terminal<B>,@@ -213,16 +329,12 @@ impl App {let mut events = EventHandler::new(Duration::from_millis(100));- let _init_sender = self.action_sender.clone();- let client_clone = self.client.clone();- tokio::spawn(async move {- match client_clone.init().await {- Ok(_) => {- let _ = _init_sender;- }- Err(_e) => {}- }- });+ if self.state.active_provider == ProviderKind::MovieBox {+ let client = self.client.clone();+ tokio::spawn(async move {+ let _ = client.init().await;+ });+ }let now = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH)@@ -231,15 +343,7 @@ impl App {if self.state.auto_update && now.saturating_sub(self.state.last_update_check) > 3600 {self.state.last_update_check = now;- if let Some(config_dir) = dirs::config_dir() {- let config_path = config_dir.join("moviebox-tui").join("config.json");- let _ = std::fs::create_dir_all(config_dir.join("moviebox-tui"));- let config_json = serde_json::json!({- "auto_update": self.state.auto_update,- "last_update_check": now- });- let _ = std::fs::write(config_path, config_json.to_string());- }+ self.persist_config();self.action_sender.send(Action::CheckForUpdates).ok();} else {self.state.active_screen = Screen::Home;@@ -498,6 +602,7 @@ impl App {self.state.search_poster_protocols.clear();if self.state.image_picker.is_some() {}}+ Action::SwitchProvider(provider) => self.switch_provider(provider),Action::Key(key) => {use crossterm::event::{KeyCode, KeyModifiers};@@ -510,6 +615,10 @@ impl App {self.action_sender.send(Action::ToggleTvMode).ok();return None;}+ if let KeyCode::Char('p') = key.code {+ self.cycle_provider();+ return None;+ }}if let KeyCode::Char('x') | KeyCode::Char('X') = key.code@@ -1170,6 +1279,10 @@ impl App {if self.state.is_tv_mode {return None;}+ if self.state.active_provider != ProviderKind::MovieBox {+ self.state.search_suggestions.clear();+ return None;+ }let client = self.client.clone();let sender = self.action_sender.clone();@@ -1282,15 +1395,7 @@ impl App {}if lower_query == "/toggle-update" {self.state.auto_update = !self.state.auto_update;- if let Some(config_dir) = dirs::config_dir() {- let config_path = config_dir.join("moviebox-tui").join("config.json");- let _ = std::fs::create_dir_all(config_dir.join("moviebox-tui"));- let config_json = serde_json::json!({- "auto_update": self.state.auto_update,- "last_update_check": self.state.last_update_check- });- let _ = std::fs::write(config_path, config_json.to_string());- }+ self.persist_config();self.state.search_query.clear();self.state.input_mode = InputMode::Normal;self.state.toast_message = Some(format!(@@ -1416,6 +1521,12 @@ impl App {};if let Some(tid) = tab_id {+ if self.state.active_provider != ProviderKind::MovieBox {+ self.state.status_message =+ "4KHDHub has no discover feed; enter a title to search.".into();+ self.state.status_timer = 180;+ return None;+ }self.action_sender.send(Action::FetchHomepage {tab_id: tid.to_string(),@@ -1441,11 +1552,16 @@ impl App {let query_clone = query.clone();let sender = self.action_sender.clone();let client = self.client.clone();+ let fourk_client = self.fourk_client.clone();+ let context = self.request_context();tokio::spawn(async move {if !force_refresh {- if let Some(cached) = crate::cache::get_search_cache(&query_clone) {+ if let Some(cached) =+ crate::cache::get_provider_search_cache(context.provider, &query_clone)+ {sender.send(Action::SearchSuccess {+ context,query: query_clone.clone(),payload: cached,})@@ -1453,18 +1569,34 @@ impl App {return;}}- match client.search(&query_clone, 1).await {+ let result = match context.provider {+ ProviderKind::MovieBox => client+ .search(&query_clone, 1)+ .await+ .map_err(|error| format!("{error:?}")),+ ProviderKind::FourKHdHub => fourk_client+ .search(&query_clone)+ .await+ .map(|items| search_to_moviebox_json(&items))+ .map_err(|error| error.to_string()),+ };+ match result {Ok(res) => {- crate::cache::set_search_cache(&query_clone, &res);+ crate::cache::set_provider_search_cache(+ context.provider,+ &query_clone,+ &res,+ );sender.send(Action::SearchSuccess {+ context,query: query_clone,payload: res,}).ok();}Err(e) => {- sender.send(Action::SearchFailure(format!("{:?}", e))).ok();+ sender.send(Action::SearchFailure(context, e)).ok();}}});@@ -1473,6 +1605,13 @@ impl App {if self.state.is_tv_mode {return None;}+ if self.state.active_provider != ProviderKind::MovieBox {+ self.state.is_loading = false;+ self.state.status_message =+ "This provider exposes search, not a shared MovieBox homepage.".into();+ self.state.status_timer = 180;+ return None;+ }self.state.is_homepage_mode = true;self.state.current_tab_id = tab_id.clone();self.state.current_page = page;@@ -1530,15 +1669,18 @@ impl App {}});}- Action::SearchSuccess { query, payload } => {- if query != self.state.search_query.trim() {+ Action::SearchSuccess {+ context,+ query,+ payload,+ } => {+ if !self.context_is_current(context) || query != self.state.search_query.trim() {return None;}self.state.is_loading = false;if self.state.current_page <= 1 {self.state.search_results.clear();}- let mut count = 0;let subjects_opt = payload.get("results").and_then(|r| r.as_array())@@ -1641,7 +1783,6 @@ impl App {cover_url,season,});- count += 1;}}let query_lower = query.to_lowercase();@@ -1711,7 +1852,19 @@ impl App {});}- self.state.status_message = format!("Found {} results.", count);+ self.state.status_message = if self.state.search_results.is_empty() {+ format!(+ "No matches for '{}' on {}. Press Ctrl+P to try another provider.",+ query,+ context.provider.label()+ )+ } else {+ format!(+ "Found {} results on {}.",+ self.state.search_results.len(),+ context.provider.label()+ )+ };self.state.status_timer = 150;if self.state.current_page <= 1 {if let Some(res) = self.state.search_results.first() {@@ -1725,7 +1878,10 @@ impl App {}}- Action::SearchFailure(err) => {+ Action::SearchFailure(context, err) => {+ if !self.context_is_current(context) {+ return None;+ }self.state.is_loading = false;self.state.status_message = format!("Search failed: {}", err);self.state.status_timer = 150;@@ -2083,24 +2239,36 @@ impl App {self.state.current_page = next_page;let query = self.state.search_query.clone();let client = self.client.clone();+ let fourk_client = self.fourk_client.clone();let sender = self.action_sender.clone();+ let context = self.request_context();self.state.is_loading = true;self.state.status_message =format!("Loading page {}...", next_page);tokio::spawn(async move {- match client.search(&query, next_page).await {+ let result = match context.provider {+ ProviderKind::MovieBox => client+ .search(&query, next_page)+ .await+ .map_err(|error| format!("{error:?}")),+ ProviderKind::FourKHdHub => fourk_client+ .search(&query)+ .await+ .map(|items| search_to_moviebox_json(&items))+ .map_err(|error| error.to_string()),+ };+ match result {Ok(res) => {sender.send(Action::SearchSuccess {+ context,query,payload: res,}).ok();}Err(e) => {- sender- .send(Action::SearchFailure(format!("{:?}", e)))- .ok();+ sender.send(Action::SearchFailure(context, e)).ok();}}});@@ -2268,7 +2436,11 @@ impl App {self.state.player_picker_popup = false;let idx = self.state.player_picker_state.selected().unwrap_or(0);if let Some(player) = self.state.available_players.get(idx).copied() {- if let Some(link) = self.state.player_picker_link.take() {+ if let Some(source) = self.state.player_picker_playback.take() {+ self.action_sender+ .send(Action::LaunchPlayback(player, source))+ .ok();+ } else if let Some(link) = self.state.player_picker_link.take() {let sub = self.state.player_picker_subtitle.take();self.action_sender.send(Action::LaunchPlayer(player, link, sub))@@ -2351,34 +2523,56 @@ impl App {self.state.status_message = "Fetching details...".to_string();self.state.stream_pool.clear();let client = self.client.clone();+ let fourk_client = self.fourk_client.clone();let sender = self.action_sender.clone();let id_clone = id.clone();+ let context = self.request_context();tokio::spawn(async move {if !force_refresh {let id_for_cache = id_clone.clone();if let Ok(Some(cached)) = tokio::task::spawn_blocking(move || {- crate::cache::get_details_cache(&id_for_cache)+ crate::cache::get_provider_details_cache(+ context.provider,+ &id_for_cache,+ )}).await{sender- .send(Action::DetailsSuccess(id_clone.clone(), cached))+ .send(Action::DetailsSuccess(context, id_clone.clone(), cached)).ok();return;}}- match client.get_details(&id_clone).await {+ let result = match context.provider {+ ProviderKind::MovieBox => client+ .get_details(&id_clone)+ .await+ .map_err(|error| format!("{error:?}")),+ ProviderKind::FourKHdHub => fourk_client+ .details(&id_clone)+ .await+ .map(|details| details_to_moviebox_json(&details))+ .map_err(|error| error.to_string()),+ };+ match result {Ok(details) => {let id_for_cache = id_clone.clone();let details_for_cache = details.clone();let _ = tokio::task::spawn_blocking(move || {- crate::cache::set_details_cache(&id_for_cache, &details_for_cache)+ crate::cache::set_provider_details_cache(+ context.provider,+ &id_for_cache,+ &details_for_cache,+ )}).await;- sender.send(Action::DetailsSuccess(id_clone, details)).ok();+ sender+ .send(Action::DetailsSuccess(context, id_clone, details))+ .ok();}Err(e) => {- sender.send(Action::DetailsFailure(format!("{:?}", e))).ok();+ sender.send(Action::DetailsFailure(context, e)).ok();}}});@@ -2423,6 +2617,11 @@ impl App {}return None;}+ if self.state.active_provider == ProviderKind::FourKHdHub {+ self.state.preview_loading = false;+ self.state.search_preview = None;+ return None;+ }if let Some(cached) = self.state.preview_cache.get(&id).cloned() {self.state.preview_loading = false;self.state.search_preview = Some(cached.clone());@@ -2570,6 +2769,37 @@ impl App {}Action::PlayStream(open_with) => {+ if self.state.active_provider == ProviderKind::FourKHdHub {+ if let Some(release) = self.get_selected_release() {+ self.state.toast_message = Some("Resolving selected mirror...".into());+ self.state.toast_timer = 80;+ let client = self.fourk_client.clone();+ let sender = self.action_sender.clone();+ tokio::spawn(async move {+ match client.resolve_release(&release).await {+ Ok(source) if open_with => {+ sender.send(Action::ShowPlaybackPicker(source)).ok();+ }+ Ok(source) => {+ sender+ .send(Action::LaunchPlayback(+ crate::tui::state::PlayerKind::Mpv,+ source,+ ))+ .ok();+ }+ Err(error) => {+ sender+ .send(Action::SetStatus(format!(+ "Error: 4KHDHub source failed: {error}"+ )))+ .ok();+ }+ }+ });+ }+ return None;+ }if self.state.active_screen == Screen::Details&& let Some(link) = self.get_selected_link(){@@ -3333,6 +3563,12 @@ impl App {}Action::PromptDownloadEpisode => {+ if self.state.active_provider != ProviderKind::MovieBox {+ self.state.status_message =+ "Downloads require a verified direct-file mirror; none is active.".into();+ self.state.status_timer = 180;+ return None;+ }self.state.show_episode_download_confirm = true;self.state.episode_download_confirm_yes_selected = true;}@@ -3375,6 +3611,12 @@ impl App {}Action::PromptDownloadSeason => {+ if self.state.active_provider != ProviderKind::MovieBox {+ self.state.status_message =+ "Season downloads are unavailable for this provider.".into();+ self.state.status_timer = 180;+ return None;+ }self.state.show_season_download_confirm = true;self.state.season_download_confirm_yes_selected = true;}@@ -3459,8 +3701,9 @@ impl App {}}- Action::DetailsSuccess(id, payload) => {- if self.state.active_screen != Screen::Details {+ Action::DetailsSuccess(context, id, payload) => {+ if !self.context_is_current(context) || self.state.active_screen != Screen::Details+ {return None;}self.state.is_loading = false;@@ -3626,12 +3869,19 @@ impl App {self.action_sender.send(Action::InitStreamPool(id)).ok();}}- Action::DetailsFailure(err) => {+ Action::DetailsFailure(context, err) => {+ if !self.context_is_current(context) {+ return None;+ }self.state.is_loading = false;self.state.status_message = format!("Details fetch failed: {}", err);self.state.status_timer = 150;}Action::SetStatus(msg) => {+ if msg.starts_with("Error:") {+ self.state.toast_message = Some(msg.clone());+ self.state.toast_timer = 180;+ }self.state.status_message = msg;self.state.status_timer = 150;}@@ -3643,6 +3893,9 @@ impl App {self.state.stream_pool.insert(subject_id.clone(), pool);self.trigger_episode_fetch();+ if self.state.active_provider != ProviderKind::MovieBox {+ return None;+ }let client = self.client.clone();let sender = self.action_sender.clone();tokio::spawn(async move {@@ -3720,12 +3973,58 @@ impl App {self.state.is_loading = true;self.state.is_fetching_streams = true;self.state.selected_resources = None;+ let context = self.request_context();++ if context.provider == ProviderKind::FourKHdHub {+ let sender = self.action_sender.clone();+ let client = self.fourk_client.clone();+ let id = subject_id.clone();+ tokio::spawn(async move {+ match client.releases(&id, season, episode).await {+ Ok(releases) if !releases.is_empty() => {+ sender+ .send(Action::EpisodeStreamsReady(+ context,+ id,+ season,+ episode,+ releases_to_moviebox_json(&releases),+ ))+ .ok();+ }+ Ok(_) => {+ sender+ .send(Action::EpisodeStreamsFailed(+ context,+ id,+ season,+ episode,+ "No exact release found".into(),+ ))+ .ok();+ }+ Err(error) => {+ sender+ .send(Action::EpisodeStreamsFailed(+ context,+ id,+ season,+ episode,+ error.to_string(),+ ))+ .ok();+ }+ }+ });+ return None;+ }if let Some(pool) = self.state.stream_pool.get_mut(&subject_id) {if !force_refresh {if let Some(cached) = pool.episode_index.get(&(season, episode)) {self.action_sender.send(Action::EpisodeStreamsReady(+ context,subject_id.clone(),season,episode,@@ -3758,7 +4057,12 @@ impl App {if !force_refresh {let id_for_cache = id_clone.clone();if let Ok(Some(cached)) = tokio::task::spawn_blocking(move || {- crate::cache::get_stream_cache(&id_for_cache, season, episode)+ crate::cache::get_provider_stream_cache(+ context.provider,+ &id_for_cache,+ season,+ episode,+ )}).await{@@ -3767,6 +4071,7 @@ impl App {.ok();sender.send(Action::EpisodeStreamsReady(+ context,subject_id.clone(),season,episode,@@ -3899,6 +4204,7 @@ impl App {if !target_ok || all_items.is_empty() {sender.send(Action::EpisodeStreamsFailed(+ context,id_clone,season,episode,@@ -3908,6 +4214,7 @@ impl App {} else {sender.send(Action::EpisodeStreamsReady(+ context,id_clone,season,episode,@@ -3918,8 +4225,10 @@ impl App {});}}- Action::EpisodeStreamsReady(subject_id, target_se, target_ep, payload) => {- if Some(&subject_id) != self.state.active_subject_id.as_ref() {+ Action::EpisodeStreamsReady(context, subject_id, target_se, target_ep, payload) => {+ if !self.context_is_current(context)+ || Some(&subject_id) != self.state.active_subject_id.as_ref()+ {return None;}if target_se != self.state.selected_season@@ -4007,7 +4316,8 @@ impl App {let id_clone = subject_id.clone();let payload_clone = array_payload.clone();tokio::task::spawn_blocking(move || {- crate::cache::set_stream_cache(+ crate::cache::set_provider_stream_cache(+ context.provider,&id_clone,target_se,target_ep,@@ -4079,8 +4389,10 @@ impl App {self.action_sender.send(Action::DownloadStream(None)).ok();}}- Action::EpisodeStreamsFailed(subject_id, target_se, target_ep, err) => {- if Some(&subject_id) != self.state.active_subject_id.as_ref() {+ Action::EpisodeStreamsFailed(context, subject_id, target_se, target_ep, err) => {+ if !self.context_is_current(context)+ || Some(&subject_id) != self.state.active_subject_id.as_ref()+ {return None;}if target_se != self.state.selected_season@@ -4124,6 +4436,20 @@ impl App {Action::PlayersDetected(players) => {self.state.available_players = players;}+ Action::ShowPlaybackPicker(source) => {+ if self.state.available_players.is_empty() {+ self.state.status_message =+ "No media player found. Install mpv, IINA, or VLC.".into();+ self.state.status_timer = 150;+ return None;+ }+ self.state.player_picker_popup = true;+ self.state.player_picker_playback = Some(source);+ self.state.player_picker_link = None;+ self.state.player_picker_subtitle = None;+ self.state.player_picker_state.select(Some(0));+ self.state.subtitle_popup = false;+ }Action::ShowPlayerPicker(link, subtitle) => {if self.state.available_players.is_empty() {self.state.toast_message = Some(format!(@@ -4138,6 +4464,7 @@ impl App {return None;}self.state.player_picker_popup = true;+ self.state.player_picker_playback = None;self.state.player_picker_link = Some(link);self.state.player_picker_subtitle = subtitle;self.state.player_picker_state.select(Some(0));@@ -4185,6 +4512,7 @@ impl App {} else {std::process::Command::new("mpv")};+ configure_mpv_window(&mut c, false);c.arg(&link);if let Some(s) = local_sub {c.arg(format!("--sub-file={}", s));@@ -4195,11 +4523,10 @@ impl App {#[cfg(target_os = "macos")]{let mut c = std::process::Command::new("open");- c.arg("-a").arg("IINA");+ c.arg("-a").arg("IINA").arg("--args");+ configure_mpv_window(&mut c, true);if let Some(s) = &local_sub {- c.arg("--args")- .arg(&link)- .arg(format!("--mpv-sub-files={}", s));+ c.arg(&link).arg(format!("--mpv-sub-files={}", s));} else {c.arg(&link);}@@ -4208,6 +4535,7 @@ impl App {#[cfg(not(target_os = "macos"))]{let mut c = std::process::Command::new("mpv");+ configure_mpv_window(&mut c, false);c.arg(&link);if let Some(s) = local_sub {c.arg(format!("--sub-file={}", s));@@ -4239,6 +4567,7 @@ impl App {} else {std::process::Command::new("vlc")};+ configure_vlc_window(&mut c);c.arg(&link);if let Some(s) = local_sub {c.arg(format!("--sub-file={}", s));@@ -4258,6 +4587,104 @@ impl App {let _ = cmd.spawn();});}+ Action::LaunchPlayback(kind, source) => {+ self.state.player_picker_popup = false;+ if kind == crate::tui::state::PlayerKind::Vlc+ && source.headers.iter().any(|(name, _)| {+ !name.eq_ignore_ascii_case("referer")+ && !name.eq_ignore_ascii_case("user-agent")+ })+ {+ self.state.status_message =+ "This source needs headers VLC cannot provide; use mpv or IINA.".into();+ self.state.status_timer = 180;+ return None;+ }+ tokio::spawn(async move {+ let header_fields = source+ .headers+ .iter()+ .map(|(name, value)| format!("{name}: {value}"))+ .collect::<Vec<_>>()+ .join(",");+ let mut cmd = match kind {+ crate::tui::state::PlayerKind::Mpv => {+ let executable =+ if std::path::Path::new("/Applications/mpv.app/Contents/MacOS/mpv")+ .exists()+ {+ "/Applications/mpv.app/Contents/MacOS/mpv"+ } else {+ "mpv"+ };+ let mut command = std::process::Command::new(executable);+ configure_mpv_window(&mut command, false);+ command.arg(&source.url);+ if !header_fields.is_empty() {+ command.arg(format!("--http-header-fields={header_fields}"));+ }+ if let Some(subtitle) = &source.subtitle {+ command.arg(format!("--sub-file={subtitle}"));+ }+ command+ }+ crate::tui::state::PlayerKind::Iina => {+ #[cfg(target_os = "macos")]+ let mut command = {+ let mut command = std::process::Command::new("open");+ command.arg("-a").arg("IINA").arg("--args");+ configure_mpv_window(&mut command, true);+ command.arg(&source.url);+ command+ };+ #[cfg(not(target_os = "macos"))]+ let mut command = {+ let mut command = std::process::Command::new("mpv");+ configure_mpv_window(&mut command, false);+ command.arg(&source.url);+ command+ };+ if !header_fields.is_empty() {+ command.arg(format!("--mpv-http-header-fields={header_fields}"));+ }+ if let Some(subtitle) = &source.subtitle {+ command.arg(format!("--mpv-sub-files={subtitle}"));+ }+ command+ }+ crate::tui::state::PlayerKind::Vlc => {+ let executable =+ if std::path::Path::new("/Applications/VLC.app").exists() {+ "/Applications/VLC.app/Contents/MacOS/VLC"+ } else {+ "vlc"+ };+ let mut command = std::process::Command::new(executable);+ configure_vlc_window(&mut command);+ command.arg(&source.url);+ for (name, value) in &source.headers {+ if name.eq_ignore_ascii_case("referer") {+ command.arg(format!("--http-referrer={value}"));+ } else if name.eq_ignore_ascii_case("user-agent") {+ command.arg(format!("--http-user-agent={value}"));+ }+ }+ if let Some(subtitle) = &source.subtitle {+ command.arg(format!("--sub-file={subtitle}"));+ }+ command+ }+ };+ cmd.stdout(std::process::Stdio::null());+ cmd.stderr(std::process::Stdio::null());+ #[cfg(unix)]+ {+ use std::os::unix::process::CommandExt;+ cmd.process_group(0);+ }+ let _ = cmd.spawn();+ });+ }Action::CheckForUpdates => {let update_sender = self.action_sender.clone();tokio::spawn(async move {@@ -4496,7 +4923,6 @@ impl App {if self.state.show_help {super::screens::help::draw(frame, main_area, &self.state, &self.theme);}-if let Some(prog) = self.state.download_progress {if let Some(dl_area) = download_area {use ratatui::widgets::{Block, Borders, Clear, Gauge};diff --git a/src/tui/screens/help.rs b/src/tui/screens/help.rsindex 7762be1..78640bf 100644--- a/src/tui/screens/help.rs+++ b/src/tui/screens/help.rs@@ -24,6 +24,16 @@ pub fn draw(frame: &mut Frame, area: Rect, state: &AppState, theme: &Theme) {Span::styled(" [Esc] ", theme.header),Span::styled("Go Back / Clear", theme.text),]),+ Line::from(vec![+ Span::styled(" [Ctrl+P] ", theme.header),+ Span::styled(+ format!(+ "Switch Provider (active: {})",+ state.active_provider.label()+ ),+ theme.text,+ ),+ ]),Line::from(vec![]),Line::from(vec![Span::styled(" Navigation",diff --git a/src/tui/screens/home.rs b/src/tui/screens/home.rsindex f01c506..a85eabe 100644--- a/src/tui/screens/home.rs+++ b/src/tui/screens/home.rs@@ -209,6 +209,13 @@ pub fn draw(frame: &mut Frame, area: Rect, state: &mut AppState, theme: &Theme)}let legend_line = ratatui::text::Line::from(vec![+ ratatui::text::Span::styled("[", theme.text_dim),+ ratatui::text::Span::styled("Ctrl+P", theme.shortcut),+ ratatui::text::Span::styled("] ", theme.text_dim),+ ratatui::text::Span::styled(+ format!("{} ", state.active_provider.label()),+ theme.accent,+ ),ratatui::text::Span::styled("[", theme.text_dim),ratatui::text::Span::styled("Ctrl+T", theme.shortcut),ratatui::text::Span::styled("] ", theme.text_dim),diff --git a/src/tui/state.rs b/src/tui/state.rsindex 74221fe..1fcda93 100644--- a/src/tui/state.rs+++ b/src/tui/state.rs@@ -1,3 +1,4 @@+use crate::providers::models::ProviderKind;use ratatui::widgets::{ListState, TableState};#[derive(Debug, Clone, Copy, PartialEq, Eq)]@@ -48,6 +49,8 @@ pub struct SubjectStreamPool {}pub struct AppState {+ pub active_provider: ProviderKind,+ pub provider_generation: u64,pub active_screen: Screen,pub dirty: bool,pub input_mode: InputMode,@@ -111,6 +114,7 @@ pub struct AppState {pub player_picker_state: ListState,pub player_picker_link: Option<String>,pub player_picker_subtitle: Option<String>,+ pub player_picker_playback: Option<crate::providers::models::PlaybackSource>,pub available_players: Vec<PlayerKind>,pub is_loading: bool,pub status_message: String,@@ -155,6 +159,8 @@ pub struct AppState {impl Default for AppState {fn default() -> Self {Self {+ active_provider: ProviderKind::MovieBox,+ provider_generation: 0,active_screen: Screen::Startup,input_mode: InputMode::Normal,cached_animated_text: String::new(),@@ -231,6 +237,7 @@ impl Default for AppState {player_picker_state: ListState::default(),player_picker_link: None,player_picker_subtitle: None,+ player_picker_playback: None,available_players: Vec::new(),dirty: true,is_loading: false,