Skip to content

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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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,