Terminal interface to find, download, and stream movies, TV shows, and live TV using local media players.
fix(moviebox): play real files instead of the placeholder clip (#221)
Monaee523f749992
diff --git a/src/cache.rs b/src/cache.rsindex 891f147..c4b25d5 100644--- a/src/cache.rs+++ b/src/cache.rs@@ -228,10 +228,11 @@ pub fn get_provider_stream_path(episode: usize,) -> PathBuf {let mut path = get_provider_cache_dir(provider, "streams");- let schema = if provider == ProviderKind::FourKHdHub {- "v4_"- } else {- ""+ let schema = match provider {+ ProviderKind::FourKHdHub => "v4_",+ // Discard streams cached with the DASH referer on recovered MP4 files.+ ProviderKind::MovieBox => "v2_",+ _ => "",};let hashed_id = md5_hex(subject_id);path.push(format!("{schema}{hashed_id}_{season}_{episode}.cache"));diff --git a/src/player.rs b/src/player.rsindex 89f9084..cb58337 100644--- a/src/player.rs+++ b/src/player.rs@@ -714,7 +714,6 @@ fn vlc_command(.arg(format!("--width={width}")).arg(format!("--height={height}"));}- command.arg("--play-and-exit");#[cfg(not(target_os = "macos"))]command.arg("--no-one-instance");command.arg("--network-caching=3000");@@ -1616,7 +1615,7 @@ mod tests {assert!(args.contains(&"--width=1280".into()));assert!(args.contains(&"--height=720".into()));- assert!(args.contains(&"--play-and-exit".into()));+ assert!(!args.contains(&"--play-and-exit".into()));assert!(args.contains(&"--start-time=42".into()));assert!(args.contains(&"--http-referrer=https://example.test/".into()));assert!(args.contains(&"--http-user-agent=MovieBox-Test".into()));diff --git a/src/providers/moviebox/adapt.rs b/src/providers/moviebox/adapt.rsindex 55d1478..b62ea50 100644--- a/src/providers/moviebox/adapt.rs+++ b/src/providers/moviebox/adapt.rs@@ -561,6 +561,47 @@ pub fn moviebox_resource_item_to_release(item: &serde_json::Value) -> Release {}}+pub fn moviebox_resource_position_json_to_release(+ payload: &serde_json::Value,+ original: &Release,+ user_agent: &str,+) -> Option<Release> {+ let resource_id = original.resource_id.as_deref()?;+ let data = payload.get("data").unwrap_or(payload);+ let items = data.get("list")?.as_array()?;+ for item in items {+ let candidate = moviebox_resource_item_to_release(item);+ if candidate.resource_id.as_deref() != Some(resource_id)+ || candidate.season != original.season+ || candidate.episode != original.episode+ {+ continue;+ }+ let Some(url) = candidate.direct_url() else {+ continue;+ };+ let Ok(parsed) = url::Url::parse(url) else {+ continue;+ };+ if !matches!(parsed.scheme(), "http" | "https") {+ continue;+ }+ let mut release = original.clone();+ release.mirrors = candidate.mirrors;+ // The original size belongs to the placeholder clip, not the recovered file.+ if candidate.size_bytes.is_some() {+ release.size_bytes = candidate.size_bytes;+ }+ for mirror in &mut release.mirrors {+ mirror.direct_file = true;+ // Direct MP4s reject the DASH referer with HTTP 429.+ mirror.headers = vec![("User-Agent".to_string(), user_agent.to_string())];+ }+ return Some(release);+ }+ None+}+pub fn is_deprecation_notice_url(url: &str) -> bool {let lower = url.to_ascii_lowercase();lower.contains("1c7de0bd3393702d9191801f15f88f8d")@@ -820,6 +861,121 @@ mod tests {use super::*;use serde_json::json;+ #[test]+ fn test_resource_position_reports_recovered_file_size() {+ let original = moviebox_resource_item_to_release(&json!({+ "resourceId": "42",+ "resourceLink": "https://macdn.aoneroom.com/other/2026/10/10/upgrade.mp4",+ "resolution": 720,+ "size": "824720",+ "se": 0,+ "ep": 0+ }));+ let payload = json!({"data": {"list": [{+ "resourceId": "42",+ "resourceLink": "https://cdn.example.com/resource/movie.mp4?sign=abc&t=123",+ "size": "1473204930",+ "se": 0,+ "ep": 0+ }]}});+ let recovered =+ moviebox_resource_position_json_to_release(&payload, &original, "TestAgent")+ .expect("recover original file");+ assert_eq!(recovered.size_bytes, Some(1473204930));+ }++ #[test]+ fn test_resource_position_recovers_file_and_preserves_release_metadata() {+ let original = moviebox_resource_item_to_release(&json!({+ "resourceId": 6154402015721538488_i64,+ "title": "Example Movie",+ "resourceLink": "https://macdn.aoneroom.com/other/2026/10/10/upgrade.mp4",+ "resolution": 1080,+ "codecName": "hevc",+ "size": "1010288591",+ "se": 0,+ "ep": 0+ }));+ assert!(original.mirrors.is_empty());+ let payload = json!({"data": {"list": [{+ "resourceId": "6154402015721538488",+ "resourceLink": "https://cdn.example.com/resource/movie.mp4?sign=abc&t=123",+ "se": 0,+ "ep": 0+ }]}});+ let recovered =+ moviebox_resource_position_json_to_release(&payload, &original, "TestAgent")+ .expect("recover original file");+ assert_eq!(recovered.filename, original.filename);+ assert_eq!(recovered.quality.as_deref(), Some("1080p"));+ assert_eq!(recovered.codec, original.codec);+ assert_eq!(recovered.size_bytes, Some(1010288591));+ assert_eq!(recovered.resource_id, original.resource_id);+ assert_eq!(+ recovered.direct_url(),+ Some("https://cdn.example.com/resource/movie.mp4?sign=abc&t=123")+ );+ assert!(recovered.mirrors[0].direct_file);+ assert_eq!(+ recovered.mirrors[0].headers,+ vec![("User-Agent".to_string(), "TestAgent".to_string())]+ );+ }++ #[test]+ fn test_resource_position_rejects_notices_wrong_resources_and_wrong_episodes() {+ let original = moviebox_resource_item_to_release(&json!({+ "resourceId": "episode2",+ "se": "1",+ "ep": "2"+ }));+ for item in [+ json!({"resourceId": "episode1", "se": 1, "ep": 2,+ "resourceLink": "https://cdn.example.com/another.mp4"}),+ json!({"resourceId": "episode2", "se": 1, "ep": 1,+ "resourceLink": "https://cdn.example.com/wrong-episode.mp4"}),+ json!({"resourceId": "episode2", "se": 2, "ep": 2,+ "resourceLink": "https://cdn.example.com/wrong-season.mp4"}),+ json!({"resourceId": "episode2", "se": 1, "ep": 2,+ "resourceLink": "https://macdn.aoneroom.com/other/2026/10/10/upgrade.mp4"}),+ json!({"resourceId": "episode2", "se": 1, "ep": 2,+ "resourceLink": "file:///tmp/movie.mp4"}),+ json!({"resourceId": "episode2", "se": 1, "ep": 2,+ "resourceLink": ""}),+ ] {+ assert!(+ moviebox_resource_position_json_to_release(+ &json!({"list": [item]}),+ &original,+ "TestAgent"+ )+ .is_none()+ );+ }+ for payload in [json!({}), json!({"list": []}), json!({"data": null})] {+ assert!(+ moviebox_resource_position_json_to_release(&payload, &original, "TestAgent")+ .is_none()+ );+ }++ let payload = json!({"list": [+ {"resourceId": "episode1", "se": 1, "ep": 1,+ "resourceLink": "https://cdn.example.com/episode1.mp4"},+ {"resourceId": "episode2", "se": 1, "ep": 2,+ "resourceLink": "https://cdn.example.com/episode2.mp4"}+ ]});+ let recovered =+ moviebox_resource_position_json_to_release(&payload, &original, "TestAgent")+ .expect("recover matching episode only");+ assert_eq!(recovered.season, Some(1));+ assert_eq!(recovered.episode, Some(2));+ assert_eq!(+ recovered.direct_url(),+ Some("https://cdn.example.com/episode2.mp4")+ );+ }+#[test]fn test_moviebox_search_json_to_catalog() {let payload = json!({diff --git a/src/providers/moviebox/mod.rs b/src/providers/moviebox/mod.rsindex ecc06da..e91676f 100644--- a/src/providers/moviebox/mod.rs+++ b/src/providers/moviebox/mod.rs@@ -62,20 +62,10 @@ impl crate::providers::ReleaseProvider for client::MovieBoxClient {season: usize,episode: usize,) -> Result<Vec<crate::providers::models::Release>, ProviderError> {+ let resource_path = episode_resource_path(id, season, episode);let (play_info_res, resources_res) = tokio::join!(self.get_play_info(id, season, episode),- self.get_resources(- id,- season,- episode,- if episode > 0 {- (episode - 1) / 20 + 1- } else {- 1- },- None,- 20,- )+ self.get(&resource_path));let mut releases = Vec::new();@@ -98,22 +88,62 @@ impl crate::providers::ReleaseProvider for client::MovieBoxClient {}}- if let Ok(res_json) = resources_res {- for rel in adapt::moviebox_resource_json_to_releases(&res_json) {- if let Some(url) = rel.direct_url() {- let base = url.split('?').next().unwrap_or(url).to_string();- if !base.is_empty() && seen_urls.contains(&base) {+ let items = match resources_res {+ Ok(payload) => payload+ .get("list")+ .and_then(Value::as_array)+ .cloned()+ .unwrap_or_default(),+ Err(_) if releases.is_empty() => {+ let page = episode.saturating_sub(1) / 20 + 1;+ self.fetch_resource_page(id, season, episode, 0, page)+ .await+ .map_err(ProviderError::from)?+ .0+ }+ Err(_) => Vec::new(),+ };+ for item in items {+ let mut rel = adapt::moviebox_resource_item_to_release(&item);+ if (season != 0 || episode != 0)+ && (rel.season != Some(season) || rel.episode != Some(episode))+ {+ continue;+ }+ if rel.mirrors.is_empty() {+ // Both playback and resource APIs can return an upgrade clip.+ // Ask the resource failover API for the original file instead.+ let origin = item+ .get("resourceLink")+ .or_else(|| item.get("url"))+ .and_then(Value::as_str)+ .filter(|url| adapt::is_deprecation_notice_url(url));+ let (Some(resource_id), Some(origin)) = (rel.resource_id.as_deref(), origin) else {+ continue;+ };+ let payload = match self.get_resource_position(id, resource_id, origin).await {+ Ok(payload) => payload,+ Err(error) => {+ log::warn!("moviebox direct file recovery failed: {error}");continue;}- seen_urls.insert(base);- }- if (season == 0 && episode == 0)- || (rel.season == Some(season) && rel.episode == Some(episode))- || (rel.season.is_none() && rel.episode.is_none())- {- releases.push(rel);+ };+ let Some(recovered) = adapt::moviebox_resource_position_json_to_release(+ &payload,+ &rel,+ self.user_agent(),+ ) else {+ continue;+ };+ rel = recovered;+ }+ if let Some(url) = rel.direct_url() {+ let base = url.split('?').next().unwrap_or(url).to_string();+ if !base.is_empty() && !seen_urls.insert(base) {+ continue;}}+ releases.push(rel);}if releases.is_empty() {@@ -137,6 +167,16 @@ use client::{MovieBoxClient, ScraperError};use serde_json::{Value, json};impl MovieBoxClient {+ pub async fn get_resource_position(+ &self,+ subject_id: &str,+ resource_id: &str,+ failed_url: &str,+ ) -> Result<Value, ScraperError> {+ self.get(&resource_position_path(subject_id, resource_id, failed_url))+ .await+ }+pub async fn get_play_info(&self,subject_id: &str,@@ -318,6 +358,25 @@ impl MovieBoxClient {}}+fn resource_position_path(subject_id: &str, resource_id: &str, failed_url: &str) -> String {+ let query = url::form_urlencoded::Serializer::new(String::new())+ .append_pair("subjectId", subject_id)+ .append_pair("resourceId", resource_id)+ .append_pair("failUrl", failed_url)+ .append_pair("failCode", "404")+ .append_pair("resourceNum", "0")+ .append_pair("isVip", "true")+ .finish();+ format!("/wefeed-mobile-bff/subject-api/resource-position/v2?{query}")+}++fn episode_resource_path(subject_id: &str, season: usize, episode: usize) -> String {+ // The legacy resource listing ignores se/ep and paginates the entire series.+ format!(+ "/wefeed-mobile-bff/subject-api/resource/v2?subjectId={subject_id}&page=1&perPage=20&all=0&startPosition=1&endPosition=1&pagerMode=2&resolution=0&se={season}&epFrom={episode}&epTo={episode}&isVip=true"+ )+}+pub fn resource_page_path(subject_id: &str,season: usize,@@ -348,6 +407,40 @@ pub fn resource_page_path(mod tests {use super::*;+ #[test]+ fn test_episode_resource_path_targets_exact_episode() {+ for (season, episode) in [(0, 0), (5, 1), (2, 25)] {+ let path = episode_resource_path("123", season, episode);+ let url = url::Url::parse(&format!("https://example.com{path}")).unwrap();+ let params: std::collections::HashMap<_, _> = url.query_pairs().collect();+ assert_eq!(url.path(), "/wefeed-mobile-bff/subject-api/resource/v2");+ assert_eq!(params["subjectId"], "123");+ assert_eq!(params["se"], season.to_string());+ assert_eq!(params["epFrom"], episode.to_string());+ assert_eq!(params["epTo"], episode.to_string());+ assert_eq!(params["page"], "1");+ }+ }++ #[test]+ fn test_resource_position_path_encodes_failed_url() {+ let origin = "https://cdn.example.com/notice.mp4?sign=a+b&t=123";+ let path = resource_position_path("123", "456", origin);+ let url = url::Url::parse(&format!("https://example.com{path}")).unwrap();+ let params: std::collections::HashMap<_, _> = url.query_pairs().collect();+ assert_eq!(+ url.path(),+ "/wefeed-mobile-bff/subject-api/resource-position/v2"+ );+ assert_eq!(params["subjectId"], "123");+ assert_eq!(params["resourceId"], "456");+ assert_eq!(params["failUrl"], origin);+ assert_eq!(params["failCode"], "404");+ assert_eq!(params["resourceNum"], "0");+ assert_eq!(params["isVip"], "true");+ assert_eq!(params.len(), 6);+ }+#[test]fn test_resource_page_path_movie() {let path = resource_page_path("12345", 0, 0, 0, 1);diff --git a/tests/live_stream_verification.rs b/tests/live_stream_verification.rsindex a5339b5..a5d679e 100644--- a/tests/live_stream_verification.rs+++ b/tests/live_stream_verification.rs@@ -13,22 +13,46 @@ async fn test_live_movie_stream_real_urls() {.expect("fetch movie streams");assert!(!releases.is_empty(), "releases should not be empty");- let notice_hash = "1c7de0bd3393702d9191801f15f88f8d";let mut real_streams_found = 0;for release in &releases {if let Some(link) = release.direct_url() {println!("Movie stream link: {}", link);assert!(- !link.contains(notice_hash),+ !moviebox_tui::providers::moviebox::adapt::is_deprecation_notice_url(link),"Stream URL should NOT be the legacy upgrade notice video: {}",link);assert!(- link.contains("hakunaymatata.com") && link.ends_with("/index.mpd"),- "Stream URL should be a valid MPEG-DASH manifest: {}",+ url::Url::parse(link).is_ok_and(|url| {+ url.scheme() == "https"+ && (url.path().ends_with("/index.mpd") || url.path().ends_with(".mp4"))+ }),+ "Stream URL should be a DASH manifest or recovered MP4 file: {}",link);+ // Resolving a URL is insufficient: verify the CDN serves media bytes.+ let mut request = client.http_client().get(link).header("Range", "bytes=0-31");+ for (name, value) in &release.mirrors[0].headers {+ request = request.header(name.as_str(), value.as_str());+ }+ let mut response = request.send().await.expect("request media bytes");+ assert!(+ response.status().is_success(),+ "CDN returned {}",+ response.status()+ );+ let chunk = response+ .chunk()+ .await+ .expect("read media bytes")+ .expect("nonempty media");+ if url::Url::parse(link).unwrap().path().ends_with(".mp4") {+ assert!(+ chunk.windows(4).any(|bytes| bytes == b"ftyp"),+ "expected an MP4 file header"+ );+ }real_streams_found += 1;}}@@ -70,7 +94,7 @@ async fn test_live_series_resolutions_and_streams() {assert!(!releases_ep1.is_empty(), "should find episode 1 streams");let ep1_url = releases_ep1[0].direct_url().expect("valid direct url");println!("Resolved S01E01 direct URL: {}", ep1_url);- assert!(ep1_url.contains("_1_1_"));+ assert!(!moviebox_tui::providers::moviebox::adapt::is_deprecation_notice_url(ep1_url));let releases_ep2 = client.episode_streams(&series.id.value, 1, 2)@@ -79,7 +103,7 @@ async fn test_live_series_resolutions_and_streams() {assert!(!releases_ep2.is_empty(), "should find episode 2 streams");let ep2_url = releases_ep2[0].direct_url().expect("valid direct url");println!("Resolved S01E02 direct URL: {}", ep2_url);- assert!(ep2_url.contains("_1_2_"));+ assert!(!moviebox_tui::providers::moviebox::adapt::is_deprecation_notice_url(ep2_url));assert_ne!(ep1_url, ep2_url,"different episodes must have different manifests"@@ -96,7 +120,7 @@ async fn test_live_multiple_seasons_and_episodes_return_distinct_streams() {("6207982430134357800","Breaking Bad",- vec![(1, 1), (1, 2), (2, 1), (2, 2)],+ vec![(1, 1), (1, 2), (2, 1), (2, 2), (5, 1)],),("4585605580068379856",@@ -127,12 +151,9 @@ async fn test_live_multiple_seasons_and_episodes_return_distinct_streams() {"{} S{:02}E{:02} -> filename: {}, url: {}",series_title, season, episode, releases[0].filename, url);- assert!(- releases[0]- .filename- .contains(&format!("S{:02}E{:02}", season, episode)),- "filename must match season and episode"- );+ assert_eq!(releases[0].season, Some(season));+ assert_eq!(releases[0].episode, Some(episode));+ assert!(!moviebox_tui::providers::moviebox::adapt::is_deprecation_notice_url(&url));urls.push(((season, episode), url));}