Skip to content

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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));
}