Skip to content

Terminal interface to find, download, and stream movies, TV shows, and live TV using local media players.

feat(moviebox): update provider for current playback API

Samir Hossainsc5c591047dfc
diff --git a/CHANGELOG.md b/CHANGELOG.md
index fa52cba..a6e75bf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,6 +3,12 @@
## [Unreleased]
### Added
+- **MovieBox Current Playback API & Long-Lived Session Lifecycle (`src/providers/moviebox/`, `src/player.rs`, `src/tui/app/requests.rs`)**:
+ - Upgraded guest authentication to `POST /wefeed-mobile-bff/user-api/visitor-login` with a dedicated `MovieBoxSession` model that parses JWT claims (`userId`, `exp`).
+ - Added atomic disk session persistence (`~/.cache/moviebox-tui/moviebox_session.bin`), single-flight async initialization mutex, and automatic 401/403 recovery with single retry.
+ - Implemented `resolve_dash_manifest_from_policy` and `moviebox_play_info_json_to_releases` to decode CloudFront base64 statements into canonical MPEG-DASH manifests (`https://sacdn.hakunaymatata.com/dash/.../index.mpd`).
+ - Added multi-resolution stream releases (`1080p`, `720p`, `480p` HEVC) from stream descriptor representations.
+ - Updated `mpv` and `IINA` player invocations to forward authentication headers via `--http-header-fields` and `--ytdl-raw-options=add-header=...` for authenticated CloudFront DASH demuxing.
- **Smooth Loading Transitions & Zero-Flicker View State Optimization (`src/tui/screens/home.rs`, `src/tui/screens/details.rs`, `src/tui/app/keyboard.rs`)**:
- Eliminated millisecond flashes of "No matches found" / "No results found" when submitting searches by synchronizing `is_loading` state on Enter and prioritizing `SearchViewState::Loading` in `search_view_state`.
- Prevented transient "No stream sources found" flash on the Details screen by displaying the stream loading spinner while either `is_fetching_streams` or `is_loading` is active.
diff --git a/src/player.rs b/src/player.rs
index 72b9551..3bcf971 100644
--- a/src/player.rs
+++ b/src/player.rs
@@ -318,6 +318,13 @@ fn mpv_command(
.collect::<Vec<_>>()
.join(",");
command.arg(format!("{prefix}http-header-fields={fields}"));
+
+ let ytdl_headers = headers
+ .iter()
+ .map(|(name, value)| format!("add-header={name}:{value}"))
+ .collect::<Vec<_>>()
+ .join(",");
+ command.arg(format!("{prefix}ytdl-raw-options={ytdl_headers}"));
}
if let Some(subtitle) = subtitle {
let opt = if iina {
diff --git a/src/providers/moviebox/adapt.rs b/src/providers/moviebox/adapt.rs
index 5c9635d..133dec1 100644
--- a/src/providers/moviebox/adapt.rs
+++ b/src/providers/moviebox/adapt.rs
@@ -2,6 +2,7 @@ use crate::providers::models::{
AudioTrackOption, CatalogItem, Episode, MediaDetails, MediaType, ProviderError, ProviderKind,
ProviderMediaId, Release, Season, SourceMirror, SubtitleOption,
};
+use base64::Engine;
pub fn captions_json_to_options(payload: &serde_json::Value) -> Vec<SubtitleOption> {
let Some(captions) = payload.get("extCaptions").and_then(|c| c.as_array()) else {
return Vec::new();
@@ -513,6 +514,150 @@ pub fn moviebox_resource_item_to_release(item: &serde_json::Value) -> Release {
}
}
+pub fn resolve_dash_manifest_from_policy(sign_cookie: &str) -> Option<String> {
+ for part in sign_cookie.split(';') {
+ let trimmed = part.trim();
+ if let Some(policy_b64) = trimmed.strip_prefix("CloudFront-Policy=") {
+ let mut padded = policy_b64.to_string();
+ let padding = (4 - padded.len() % 4) % 4;
+ padded.push_str(&"=".repeat(padding));
+ if let Ok(decoded_bytes) = base64::engine::general_purpose::STANDARD.decode(&padded) {
+ if let Ok(json) = serde_json::from_slice::<serde_json::Value>(&decoded_bytes) {
+ if let Some(resource) = json
+ .get("Statement")
+ .and_then(|s| s.as_array())
+ .and_then(|arr| arr.first())
+ .and_then(|st| st.get("Resource"))
+ .and_then(|r| r.as_str())
+ {
+ let base_resource = resource.trim_end_matches('*').trim_end_matches('/');
+ if !base_resource.is_empty() && base_resource.starts_with("http") {
+ return Some(format!("{base_resource}/index.mpd"));
+ }
+ }
+ }
+ }
+ }
+ }
+ None
+}
+
+pub fn moviebox_play_info_json_to_releases(
+ payload: &serde_json::Value,
+ season: usize,
+ episode: usize,
+ user_agent: &str,
+) -> Vec<Release> {
+ let data = payload.get("data").unwrap_or(payload);
+ let title_prefix = data
+ .get("title")
+ .and_then(|t| t.as_str())
+ .unwrap_or("MovieBox Stream");
+
+ let Some(streams) = data.get("streams").and_then(|s| s.as_array()) else {
+ return Vec::new();
+ };
+
+ let mut releases = Vec::new();
+
+ for stream in streams {
+ let format_type = stream
+ .get("format")
+ .and_then(|f| f.as_str())
+ .unwrap_or("MP4");
+ let codec = stream
+ .get("codecName")
+ .or_else(|| stream.get("codec"))
+ .and_then(|c| c.as_str())
+ .map(|s| s.to_string());
+ let size_bytes = stream.get("size").and_then(|s| {
+ if let Some(n) = s.as_u64() {
+ Some(n)
+ } else if let Some(n) = s.as_i64() {
+ Some(n as u64)
+ } else if let Some(str_val) = s.as_str() {
+ str_val.parse::<u64>().ok()
+ } else {
+ None
+ }
+ });
+
+ let resolutions_str = stream
+ .get("resolutions")
+ .or_else(|| data.get("displayResolutions"))
+ .and_then(|r| r.as_str())
+ .unwrap_or("1080,720,480");
+
+ let sign_cookie = stream
+ .get("signCookie")
+ .and_then(|c| c.as_str())
+ .unwrap_or("");
+
+ let stream_url = stream.get("url").and_then(|u| u.as_str()).unwrap_or("");
+
+ let manifest_url = resolve_dash_manifest_from_policy(sign_cookie).or_else(|| {
+ if stream_url.starts_with("http") {
+ Some(stream_url.to_string())
+ } else {
+ None
+ }
+ });
+
+ let Some(playable_url) = manifest_url else {
+ continue;
+ };
+
+ let mut headers = vec![
+ ("Referer".to_string(), "https://sportslive.wine".to_string()),
+ ("User-Agent".to_string(), user_agent.to_string()),
+ ];
+ if !sign_cookie.is_empty() {
+ headers.push(("Cookie".to_string(), sign_cookie.to_string()));
+ }
+
+ let mut parsed_resolutions: Vec<u32> = resolutions_str
+ .split(',')
+ .filter_map(|s| s.trim().parse::<u32>().ok())
+ .collect();
+ parsed_resolutions.sort_by(|a, b| b.cmp(a));
+ parsed_resolutions.dedup();
+ if parsed_resolutions.is_empty() {
+ parsed_resolutions.push(1080);
+ }
+
+ for &res in &parsed_resolutions {
+ let quality = Some(format!("{res}p"));
+ let codec_disp = codec.as_deref().unwrap_or(format_type);
+ let filename = if season > 0 && episode > 0 {
+ format!("{title_prefix} S{season:02}E{episode:02} {res}p {codec_disp}")
+ } else {
+ format!("{title_prefix} {res}p {codec_disp}")
+ };
+
+ let mirror = SourceMirror {
+ label: format!("{res}p {codec_disp}"),
+ resolver_url: playable_url.clone(),
+ headers: headers.clone(),
+ direct_file: true,
+ };
+
+ releases.push(Release {
+ provider: ProviderKind::MovieBox,
+ filename,
+ quality,
+ codec: codec.clone(),
+ language: None,
+ size_bytes,
+ season: if season > 0 { Some(season) } else { None },
+ episode: if episode > 0 { Some(episode) } else { None },
+ mirrors: vec![mirror],
+ });
+ }
+ }
+
+ releases
+}
+
pub fn moviebox_resource_json_to_releases(payload: &serde_json::Value) -> Vec<Release> {
let items = if let Some(list) = payload.get("list").and_then(|l| l.as_array()) {
list.as_slice()
@@ -664,4 +809,91 @@ mod tests {
);
assert_eq!(releases[0].source_label(), "NF");
}
+
+ #[test]
+ fn test_resolve_dash_manifest_from_policy() {
+ let policy_json = r#"{"Statement":[{"Resource":"https://sacdn.hakunaymatata.com/dash/4179386086617137184_0_0_1080_h265_518/*","Condition":{"DateLessThan":{"AWS:EpochTime":1788879894}}}]}"#;
+ let b64 = base64::engine::general_purpose::STANDARD.encode(policy_json.as_bytes());
+ let cookie = format!(
+ "CloudFront-Policy={b64};CloudFront-Signature=abc;CloudFront-Key-Pair-Id=KMHN1LQ1HEUPL;"
+ );
+
+ let resolved = resolve_dash_manifest_from_policy(&cookie);
+ assert_eq!(
+ resolved.as_deref(),
+ Some(
+ "https://sacdn.hakunaymatata.com/dash/4179386086617137184_0_0_1080_h265_518/index.mpd"
+ )
+ );
+ }
+
+ #[test]
+ fn test_moviebox_play_info_json_to_releases_with_signed_cookie() {
+ let policy_json = r#"{"Statement":[{"Resource":"https://sacdn.example.com/dash/12345_0_0_1080_h265_518/*"}]}"#;
+ let b64 = base64::engine::general_purpose::STANDARD.encode(policy_json.as_bytes());
+ let cookie = format!(
+ "CloudFront-Policy={b64};CloudFront-Signature=xyz;CloudFront-Key-Pair-Id=K123;"
+ );
+
+ let payload = json!({
+ "code": 0,
+ "message": "ok",
+ "data": {
+ "title": "Sample Movie",
+ "displayResolutions": "480,720,1080",
+ "streams": [
+ {
+ "id": "9999",
+ "format": "MP4",
+ "codecName": "hevc",
+ "duration": 7200,
+ "size": "1500000000",
+ "resolutions": "1080,720,480",
+ "url": "https://macdn.example.com/notice.mp4",
+ "signCookie": cookie
+ }
+ ]
+ }
+ });
+
+ let releases = moviebox_play_info_json_to_releases(&payload, 0, 0, "TestAgent/1.0");
+ assert_eq!(releases.len(), 3);
+ assert_eq!(releases[0].quality.as_deref(), Some("1080p"));
+ assert_eq!(releases[0].codec.as_deref(), Some("hevc"));
+ assert_eq!(releases[1].quality.as_deref(), Some("720p"));
+ assert_eq!(releases[2].quality.as_deref(), Some("480p"));
+ assert_eq!(
+ releases[0].direct_url(),
+ Some("https://sacdn.example.com/dash/12345_0_0_1080_h265_518/index.mpd")
+ );
+ let mirror = &releases[0].mirrors[0];
+ assert!(
+ mirror
+ .headers
+ .iter()
+ .any(|(k, v)| k == "Referer" && v == "https://sportslive.wine")
+ );
+ assert!(
+ mirror
+ .headers
+ .iter()
+ .any(|(k, v)| k == "Cookie" && v.contains("CloudFront-Policy="))
+ );
+ }
+
+ #[test]
+ fn test_moviebox_play_info_empty_or_invalid_streams() {
+ let empty_payload = json!({
+ "code": 0,
+ "data": {
+ "title": "Empty",
+ "streams": []
+ }
+ });
+ let releases = moviebox_play_info_json_to_releases(&empty_payload, 0, 0, "TestAgent/1.0");
+ assert!(releases.is_empty());
+
+ let invalid_cookie = "CloudFront-Policy=invalid_base64;";
+ assert_eq!(resolve_dash_manifest_from_policy(invalid_cookie), None);
+ }
}
diff --git a/src/providers/moviebox/client.rs b/src/providers/moviebox/client.rs
index 6c33d0f..9fcf220 100644
--- a/src/providers/moviebox/client.rs
+++ b/src/providers/moviebox/client.rs
@@ -1,8 +1,12 @@
use crate::providers::moviebox::crypto::build_signed_headers;
+use crate::providers::moviebox::session::{
+ MovieBoxSession, clear_persisted_session, load_persisted_session, save_session,
+};
use reqwest::Response;
use serde_json::Value;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, RwLock};
+
const HOST_POOL: &[&str] = &[
"https://api6.aoneroom.com",
"https://api5.aoneroom.com",
@@ -32,7 +36,8 @@ pub enum ScraperError {
#[derive(Clone)]
pub struct MovieBoxClient {
client: reqwest::Client,
- runtime_token: Arc<RwLock<Option<String>>>,
+ session: Arc<RwLock<Option<MovieBoxSession>>>,
+ init_lock: Arc<tokio::sync::Mutex<()>>,
active_base_idx: Arc<AtomicUsize>,
user_agent: String,
client_info: String,
@@ -62,7 +67,8 @@ impl MovieBoxClient {
Self {
client,
- runtime_token: Arc::new(RwLock::new(None)),
+ session: Arc::new(RwLock::new(None)),
+ init_lock: Arc::new(tokio::sync::Mutex::new(())),
active_base_idx: Arc::new(AtomicUsize::new(0)),
user_agent,
client_info,
@@ -79,18 +85,85 @@ impl MovieBoxClient {
}
pub async fn init(&self) -> Result<(), ScraperError> {
- let path = "/wefeed-mobile-bff/tab-operating?page=1&tabId=0&version=";
- let _ = self.request_hosts("GET", path, None).await?;
+ self.ensure_session().await.map(|_| ())
+ }
+
+ pub async fn ensure_session(&self) -> Result<String, ScraperError> {
+ // Fast path: valid in-memory session
+ if let Some(session) = self
+ .session
+ .read()
+ .unwrap_or_else(|e| e.into_inner())
+ .as_ref()
+ {
+ if session.is_valid() {
+ return Ok(session.token.clone());
+ }
+ }
+
+ // Cache path: valid persisted session
+ if let Some(persisted) = load_persisted_session() {
+ if persisted.is_valid() {
+ let mut write_guard = self.session.write().unwrap_or_else(|e| e.into_inner());
+ *write_guard = Some(persisted.clone());
+ return Ok(persisted.token);
+ }
+ }
+
+ // Single-flight lock: serialize concurrent guest logins
+ let _guard = self.init_lock.lock().await;
- let has_token = self
- .runtime_token
+ // Double check after acquiring lock
+ if let Some(session) = self
+ .session
.read()
.unwrap_or_else(|e| e.into_inner())
- .is_some();
- if !has_token {
- return Err(ScraperError::MissingToken);
+ .as_ref()
+ {
+ if session.is_valid() {
+ return Ok(session.token.clone());
+ }
}
- Ok(())
+
+ let session = self.fetch_fresh_session().await?;
+ let token = session.token.clone();
+
+ let mut write_guard = self.session.write().unwrap_or_else(|e| e.into_inner());
+ *write_guard = Some(session.clone());
+ save_session(&session);
+
+ Ok(token)
+ }
+
+ async fn fetch_fresh_session(&self) -> Result<MovieBoxSession, ScraperError> {
+ let path = "/wefeed-mobile-bff/user-api/visitor-login";
+ let body_str = "{}";
+ let val = self
+ .request_hosts("POST", path, Some(body_str), None)
+ .await?;
+
+ let token = val
+ .get("token")
+ .and_then(|t| t.as_str())
+ .filter(|t| !t.trim().is_empty())
+ .ok_or(ScraperError::MissingToken)?;
+
+ let explicit_uid = val.get("uid").or_else(|| val.get("userId")).and_then(|v| {
+ v.as_str()
+ .map(|s| s.to_string())
+ .or_else(|| v.as_i64().map(|n| n.to_string()))
+ });
+
+ Ok(MovieBoxSession::from_token_and_payload(
+ token.to_string(),
+ explicit_uid,
+ ))
+ }
+
+ pub fn invalidate_session(&self) {
+ let mut write_guard = self.session.write().unwrap_or_else(|e| e.into_inner());
+ *write_guard = None;
+ clear_persisted_session();
}
async fn absorb_x_user(&self, headers: &reqwest::header::HeaderMap) {
@@ -107,11 +180,18 @@ impl MovieBoxClient {
return;
};
if !token.is_empty() {
- let mut write_token = self
- .runtime_token
- .write()
- .unwrap_or_else(|e| e.into_inner());
- *write_token = Some(token.to_string());
+ let uid = json
+ .get("uid")
+ .or_else(|| json.get("userId"))
+ .and_then(|v| {
+ v.as_str()
+ .map(|s| s.to_string())
+ .or_else(|| v.as_i64().map(|n| n.to_string()))
+ });
+ let session = MovieBoxSession::from_token_and_payload(token.to_string(), uid);
+ let mut write_guard = self.session.write().unwrap_or_else(|e| e.into_inner());
+ *write_guard = Some(session.clone());
+ save_session(&session);
}
}
@@ -130,18 +210,23 @@ impl MovieBoxClient {
path_and_query: &str,
body: Option<&str>,
) -> Result<Value, ScraperError> {
- match self.request_hosts(method, path_and_query, body).await {
+ let token = self.ensure_session().await?;
+
+ match self
+ .request_hosts(method, path_and_query, body, Some(&token))
+ .await
+ {
+ Err(ScraperError::ApiStatus(401 | 403)) => {
+ self.invalidate_session();
+ let fresh_token = self.ensure_session().await?;
+ self.request_hosts(method, path_and_query, body, Some(&fresh_token))
+ .await
+ }
Err(ScraperError::HostsExhausted) => {
- let has_token = self
- .runtime_token
- .read()
- .unwrap_or_else(|e| e.into_inner())
- .is_some();
- if has_token {
- return Err(ScraperError::HostsExhausted);
- }
- let _ = self.init().await;
- self.request_hosts(method, path_and_query, body).await
+ self.invalidate_session();
+ let fresh_token = self.ensure_session().await?;
+ self.request_hosts(method, path_and_query, body, Some(&fresh_token))
+ .await
}
result => result,
}
@@ -152,6 +237,7 @@ impl MovieBoxClient {
method: &str,
path_and_query: &str,
body: Option<&str>,
+ auth_token: Option<&str>,
) -> Result<Value, ScraperError> {
let start_idx = self.active_base_idx.load(Ordering::Relaxed);
let mut backoff_ms: u64 = 50;
@@ -165,16 +251,11 @@ impl MovieBoxClient {
let base = HOST_POOL[idx];
let url = format!("{}{}", base, path_and_query);
- let token = self
- .runtime_token
- .read()
- .unwrap_or_else(|e| e.into_inner())
- .clone();
let headers = build_signed_headers(
method,
&url,
body,
- token.as_deref(),
+ auth_token,
&self.user_agent,
&self.client_info,
&self.spoofed_ip,
@@ -266,3 +347,63 @@ impl MovieBoxClient {
}
}
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[tokio::test]
+ async fn test_client_in_memory_session_reuse() {
+ let client = MovieBoxClient::new();
+ let session = MovieBoxSession::new(
+ "token_123".to_string(),
+ Some("u1".to_string()),
+ Some(u64::MAX),
+ );
+ {
+ let mut write_guard = client.session.write().unwrap();
+ *write_guard = Some(session.clone());
+ }
+
+ let token1 = client.ensure_session().await.expect("ensure session 1");
+ assert_eq!(token1, "token_123");
+
+ let token2 = client.ensure_session().await.expect("ensure session 2");
+ assert_eq!(token2, "token_123");
+ }
+
+ #[tokio::test]
+ async fn test_client_invalidation_clears_session() {
+ let client = MovieBoxClient::new();
+ let session = MovieBoxSession::new("token_abc".to_string(), None, Some(u64::MAX));
+ {
+ let mut write_guard = client.session.write().unwrap();
+ *write_guard = Some(session);
+ }
+
+ assert!(client.session.read().unwrap().is_some());
+ client.invalidate_session();
+ assert!(client.session.read().unwrap().is_none());
+ }
+
+ #[tokio::test]
+ async fn test_client_concurrent_session_reuse() {
+ let client = MovieBoxClient::new();
+ let session = MovieBoxSession::new("concurrent_token".to_string(), None, Some(u64::MAX));
+ {
+ let mut write_guard = client.session.write().unwrap();
+ *write_guard = Some(session);
+ }
+
+ let mut handles = Vec::new();
+ for _ in 0..10 {
+ let c = client.clone();
+ handles.push(tokio::spawn(async move { c.ensure_session().await }));
+ }
+
+ for h in handles {
+ let res = h.await.expect("task join").expect("token result");
+ assert_eq!(res, "concurrent_token");
+ }
+ }
+}
diff --git a/src/providers/moviebox/mod.rs b/src/providers/moviebox/mod.rs
index 5b33ada..785edd5 100644
--- a/src/providers/moviebox/mod.rs
+++ b/src/providers/moviebox/mod.rs
@@ -1,6 +1,7 @@
pub mod adapt;
pub mod client;
pub mod crypto;
+pub mod session;
pub mod title;
pub use title::clean_moviebox_title;
@@ -53,17 +54,69 @@ impl Provider for client::MovieBoxClient {
}
}
+impl crate::providers::ReleaseProvider for client::MovieBoxClient {
+ async fn episode_streams(
+ &self,
+ id: &str,
+ season: usize,
+ episode: usize,
+ ) -> Result<Vec<crate::providers::models::Release>, ProviderError> {
+ let json = self
+ .get_play_info(id, season, episode)
+ .await
+ .map_err(ProviderError::from)?;
+ let releases =
+ adapt::moviebox_play_info_json_to_releases(&json, season, episode, self.user_agent());
+ if !releases.is_empty() {
+ return Ok(releases);
+ }
+
+ let (items, _) = self
+ .fetch_resource_page(id, 0, 1)
+ .await
+ .map_err(ProviderError::from)?;
+ let mut legacy_releases = Vec::new();
+ for item in items {
+ let rel = adapt::moviebox_resource_item_to_release(&item);
+ if (season == 0 && episode == 0)
+ || (rel.season == Some(season) && rel.episode == Some(episode))
+ {
+ legacy_releases.push(rel);
+ }
+ }
+ Ok(legacy_releases)
+ }
+}
+
use client::{MovieBoxClient, ScraperError};
use serde_json::{Value, json};
impl MovieBoxClient {
+ pub async fn get_play_info(
+ &self,
+ subject_id: &str,
+ season: usize,
+ episode: usize,
+ ) -> Result<Value, ScraperError> {
+ let path = if season == 0 && episode == 0 {
+ format!(
+ "/wefeed-mobile-bff/subject-api/play-info/v2?subjectId={}",
+ subject_id
+ )
+ } else {
+ format!(
+ "/wefeed-mobile-bff/subject-api/play-info/v2?subjectId={}&se={}&ep={}",
+ subject_id, season, episode
+ )
+ };
+ self.get(&path).await
+ }
pub async fn search(&self, query: &str, page: usize) -> Result<Value, ScraperError> {
let payload = json!({
"keyword": query,
"page": page,
- "perPage": 20,
- "subjectType": "All",
- "tabId": "All"
+ "perPage": 15,
+ "subjectType": 0
});
self.post("/wefeed-mobile-bff/subject-api/search/v2", &payload)
.await
diff --git a/src/providers/moviebox/session.rs b/src/providers/moviebox/session.rs
new file mode 100644
index 0000000..e7af328
--- /dev/null
+++ b/src/providers/moviebox/session.rs
@@ -0,0 +1,160 @@
+use base64::Engine;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use std::path::PathBuf;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct MovieBoxSession {
+ pub token: String,
+ pub user_id: Option<String>,
+ pub expires_at: Option<u64>,
+ pub created_at: u64,
+}
+
+impl MovieBoxSession {
+ pub fn new(token: String, user_id: Option<String>, expires_at: Option<u64>) -> Self {
+ let created_at = std::time::SystemTime::now()
+ .duration_since(std::time::UNIX_EPOCH)
+ .unwrap_or_default()
+ .as_secs();
+ Self {
+ token,
+ user_id,
+ expires_at,
+ created_at,
+ }
+ }
+
+ pub fn from_token_and_payload(token: String, explicit_uid: Option<String>) -> Self {
+ let (jwt_uid, jwt_exp) = parse_jwt_claims(&token);
+ let user_id = explicit_uid.or(jwt_uid);
+ Self::new(token, user_id, jwt_exp)
+ }
+
+ pub fn is_valid(&self) -> bool {
+ if self.token.trim().is_empty() {
+ return false;
+ }
+ let now = std::time::SystemTime::now()
+ .duration_since(std::time::UNIX_EPOCH)
+ .unwrap_or_default()
+ .as_secs();
+
+ if let Some(exp) = self.expires_at {
+ now.saturating_add(60) < exp
+ } else {
+ now < self.created_at.saturating_add(7 * 24 * 3600)
+ }
+ }
+}
+
+pub fn parse_jwt_claims(token: &str) -> (Option<String>, Option<u64>) {
+ let parts: Vec<&str> = token.split('.').collect();
+ if parts.len() < 2 {
+ return (None, None);
+ }
+ let payload_b64 = parts[1];
+ let pad_len = (4 - (payload_b64.len() % 4)) % 4;
+ let padded = format!("{}{}", payload_b64, "=".repeat(pad_len));
+
+ let decoded = base64::engine::general_purpose::URL_SAFE_NO_PAD
+ .decode(payload_b64)
+ .or_else(|_| base64::engine::general_purpose::URL_SAFE.decode(&padded))
+ .or_else(|_| base64::engine::general_purpose::STANDARD.decode(&padded))
+ .ok();
+
+ let Some(bytes) = decoded else {
+ return (None, None);
+ };
+
+ let Ok(val) = serde_json::from_slice::<Value>(&bytes) else {
+ return (None, None);
+ };
+
+ let uid = val
+ .get("userId")
+ .or_else(|| val.get("uid"))
+ .or_else(|| val.get("sub"))
+ .and_then(|v| {
+ v.as_str()
+ .map(|s| s.to_string())
+ .or_else(|| v.as_i64().map(|n| n.to_string()))
+ .or_else(|| v.as_u64().map(|n| n.to_string()))
+ });
+
+ let exp = val.get("exp").and_then(|v| {
+ if let Some(n) = v.as_u64() {
+ Some(n)
+ } else if let Some(n) = v.as_i64() {
+ Some(n as u64)
+ } else if let Some(s) = v.as_str() {
+ s.parse::<u64>().ok()
+ } else {
+ None
+ }
+ });
+
+ (uid, exp)
+}
+
+pub fn session_cache_path() -> PathBuf {
+ crate::config::cache_dir().join("moviebox_session.bin")
+}
+
+pub fn load_persisted_session() -> Option<MovieBoxSession> {
+ let path = session_cache_path();
+ crate::cache::get_typed_cache::<MovieBoxSession>(&path, 30 * 24 * 3600)
+}
+
+pub fn save_session(session: &MovieBoxSession) {
+ let path = session_cache_path();
+ crate::cache::set_typed_cache(&path, 30 * 24 * 3600, session);
+}
+
+pub fn clear_persisted_session() {
+ let path = session_cache_path();
+ let _ = std::fs::remove_file(path);
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_jwt_claims_parsing_valid() {
+ let payload = r#"{"userId":"123456789","exp":1893456000,"role":"visitor"}"#;
+ let b64 = base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(payload.as_bytes());
+ let token = format!("eyJhbGciOiJIUzI1NiJ9.{b64}.signature");
+
+ let (uid, exp) = parse_jwt_claims(&token);
+ assert_eq!(uid.as_deref(), Some("123456789"));
+ assert_eq!(exp, Some(1893456000));
+ }
+
+ #[test]
+ fn test_session_validity_and_expiration() {
+ let valid_session = MovieBoxSession::new("valid_token".to_string(), None, Some(u64::MAX));
+ assert!(valid_session.is_valid());
+
+ let expired_session = MovieBoxSession::new("expired_token".to_string(), None, Some(100));
+ assert!(!expired_session.is_valid());
+
+ let empty_session = MovieBoxSession::new("".to_string(), None, Some(u64::MAX));
+ assert!(!empty_session.is_valid());
+ }
+
+ #[test]
+ fn test_session_roundtrip_cache() {
+ let temp_dir = tempfile::tempdir().expect("tempdir");
+ let path = temp_dir.path().join("session_test.bin");
+ let session = MovieBoxSession::new(
+ "test_jwt_token".to_string(),
+ Some("uid_999".to_string()),
+ Some(1900000000),
+ );
+
+ crate::cache::set_typed_cache(&path, 3600, &session);
+ let loaded = crate::cache::get_typed_cache::<MovieBoxSession>(&path, 3600);
+ assert_eq!(loaded, Some(session));
+ }
+}
diff --git a/src/tui/app/requests.rs b/src/tui/app/requests.rs
index c432286..5e956a5 100644
--- a/src/tui/app/requests.rs
+++ b/src/tui/app/requests.rs
@@ -1497,6 +1497,21 @@ impl App {
.send(Action::SetStatus("Fetching streams...".to_string()))
.ok();
+ if let Ok(streams) = crate::providers::ReleaseProvider::episode_streams(
+ &client, &id_clone, season, episode,
+ )
+ .await
+ {
+ if !streams.is_empty() {
+ sender
+ .send(Action::EpisodeStreamsReady(
+ context, request_id, id_clone, season, episode, streams,
+ ))
+ .ok();
+ return;
+ }
+ }
+
let mut all_items: Vec<Release> = Vec::new();
let mut found_target = false;
let mut any_fetch_failed = false;
diff --git a/tests/live_stream_verification.rs b/tests/live_stream_verification.rs
index 67a351f..e53cecf 100644
--- a/tests/live_stream_verification.rs
+++ b/tests/live_stream_verification.rs
@@ -1,3 +1,4 @@
+use moviebox_tui::providers::ReleaseProvider;
use moviebox_tui::providers::moviebox::client::MovieBoxClient;
#[tokio::test]
@@ -6,18 +7,18 @@ async fn test_live_movie_stream_real_urls() {
let client = MovieBoxClient::new();
client.init().await.expect("client init successful");
- // Avatar subject_id: 1654274595068805784
- let (items, _) = client
- .fetch_resource_page("1654274595068805784", 0, 1)
+ // Ek Deewane Ki Deewaniyat subject_id: 4179386086617137184
+ let releases = client
+ .episode_streams("4179386086617137184", 0, 0)
.await
- .expect("fetch resource page");
- assert!(!items.is_empty(), "items should not be empty");
+ .expect("fetch movie streams");
+ assert!(!releases.is_empty(), "releases should not be empty");
let notice_hash = "1c7de0bd3393702d9191801f15f88f8d";
let mut real_streams_found = 0;
- for item in &items {
- if let Some(link) = item.get("resourceLink").and_then(|l| l.as_str()) {
+ for release in &releases {
+ if let Some(link) = release.direct_url() {
println!("Movie stream link: {}", link);
assert!(
!link.contains(notice_hash),
@@ -25,8 +26,8 @@ async fn test_live_movie_stream_real_urls() {
link
);
assert!(
- link.contains("bcdn.hakunaymatata.com") || link.contains("sign="),
- "Stream URL should be a signed CDN link: {}",
+ link.contains("sacdn.hakunaymatata.com") && link.ends_with("/index.mpd"),
+ "Stream URL should be a valid MPEG-DASH manifest: {}",
link
);
real_streams_found += 1;
@@ -45,50 +46,243 @@ async fn test_live_series_resolutions_and_streams() {
let client = MovieBoxClient::new();
client.init().await.expect("client init successful");
- // Loki subject_id: 8449792878959887920
- let resolutions = client
- .fetch_collection_resolutions("8449792878959887920")
+ // Search for a series dynamically
+ let search_res = client
+ .search("Breaking Bad", 1)
.await
- .expect("fetch collection resolutions");
+ .expect("search series");
+ let catalog =
+ moviebox_tui::providers::moviebox::adapt::moviebox_search_json_to_catalog(&search_res);
+ assert!(!catalog.is_empty(), "search should return catalog items");
- println!("Series resolutions: {:?}", resolutions);
- assert!(!resolutions.is_empty(), "resolutions should not be empty");
- assert!(
- resolutions.contains(&1080) || resolutions.contains(&720) || resolutions.contains(&480),
- "resolutions should contain standard qualities: {:?}",
- resolutions
+ let series = catalog
+ .iter()
+ .find(|item| item.media_type == moviebox_tui::providers::models::MediaType::Series)
+ .unwrap_or(&catalog[0]);
+
+ println!(
+ "Testing live series: {} ({})",
+ series.title, series.id.value
);
- // Fetch season 1 episode 1
- let res = client
- .get_resources("8449792878959887920", 1, 1, 1, None, 20)
+ let releases_ep1 = client
+ .episode_streams(&series.id.value, 1, 1)
.await
- .expect("fetch episode resources");
+ .expect("fetch episode 1 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_"));
- let items = res
- .get("list")
- .and_then(|l| l.as_array())
- .cloned()
- .unwrap_or_default();
- let notice_hash = "1c7de0bd3393702d9191801f15f88f8d";
- let mut episode_streams_found = 0;
+ let releases_ep2 = client
+ .episode_streams(&series.id.value, 1, 2)
+ .await
+ .expect("fetch episode 2 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_ne!(
+ ep1_url, ep2_url,
+ "different episodes must have different manifests"
+ );
+}
- for item in &items {
- if let Some(link) = item.get("resourceLink").and_then(|l| l.as_str()) {
- println!("Episode stream link: {}", link);
- assert!(
- !link.contains(notice_hash),
- "Episode stream URL should NOT be the legacy upgrade notice video: {}",
- link
- );
- episode_streams_found += 1;
- }
+#[tokio::test]
+#[ignore = "live network test; run with cargo test --test live_stream_verification -- --ignored"]
+async fn test_inspect_live_mpd_manifest() {
+ let client = MovieBoxClient::new();
+ client.init().await.expect("client init successful");
+
+ let releases = client
+ .episode_streams("4179386086617137184", 0, 0)
+ .await
+ .expect("fetch movie streams");
+ assert!(!releases.is_empty(), "releases should not be empty");
+
+ let mirror = &releases[0].mirrors[0];
+ println!("Fetching MPD Manifest from: {}", mirror.resolver_url);
+
+ let mut req = client.http_client().get(&mirror.resolver_url);
+ for (name, val) in &mirror.headers {
+ req = req.header(name, val);
}
+ let resp = req.send().await.expect("send mpd request");
+ let xml = resp.text().await.expect("read mpd xml");
+ println!(
+ "=== RAW MPD MANIFEST ===\n{}\n========================",
+ xml
+ );
+
+ // Test quality switching with mpv
+ for (target_label, height_constraint, expected_res) in [
+ (
+ "1080p",
+ "bestvideo[height<=1080]+bestaudio/best",
+ "1920x1080",
+ ),
+ ("720p", "bestvideo[height<=720]+bestaudio/best", "1280x720"),
+ ("480p", "bestvideo[height<=480]+bestaudio/best", "854x480"),
+ ] {
+ let mut cmd = moviebox_tui::player::command(
+ moviebox_tui::player::PlayerKind::Mpv,
+ &mirror.resolver_url,
+ None,
+ &mirror.headers,
+ None,
+ None,
+ None,
+ );
+ cmd.arg("--vo=null")
+ .arg("--ao=null")
+ .arg("--frames=15")
+ .arg(format!("--ytdl-format={height_constraint}"));
+
+ let output = cmd.output().expect("run mpv with quality format");
+ let out = String::from_utf8_lossy(&output.stdout);
+ let err = String::from_utf8_lossy(&output.stderr);
+ let combined = format!("{out}\n{err}");
+ println!("Quality [{target_label}] output:\n{}", combined);
+ assert!(
+ combined.contains(expected_res),
+ "mpv should select resolution {} for quality {}",
+ expected_res,
+ target_label
+ );
+ }
+}
+
+#[tokio::test]
+#[ignore = "live network test; run with cargo test --test live_stream_verification -- --ignored"]
+async fn test_live_moviebox_mpv_end_to_end_playback() {
+ let client = MovieBoxClient::new();
+ client.init().await.expect("client init successful");
+
+ let releases = client
+ .episode_streams("4179386086617137184", 0, 0)
+ .await
+ .expect("fetch movie streams");
+ assert!(!releases.is_empty(), "releases should not be empty");
+
+ let release = &releases[0];
+ let mirror = &release.mirrors[0];
+ println!(
+ "Testing mpv playback on live manifest: {}",
+ mirror.resolver_url
+ );
+
+ let mut cmd = moviebox_tui::player::command(
+ moviebox_tui::player::PlayerKind::Mpv,
+ &mirror.resolver_url,
+ None,
+ &mirror.headers,
+ None,
+ None,
+ None,
+ );
+
+ cmd.arg("--vo=null").arg("--ao=null").arg("--frames=20");
+
+ let output = cmd.output().expect("execute mpv command");
+ let stdout = String::from_utf8_lossy(&output.stdout);
+ let stderr = String::from_utf8_lossy(&output.stderr);
+ let combined = format!("{stdout}\n{stderr}");
+
+ println!("MPV execution output:\n{}", combined);
assert!(
- episode_streams_found > 0,
- "Should find at least one real episode stream"
+ combined.contains("Video") || combined.contains("hevc"),
+ "mpv should detect video stream"
);
+ assert!(
+ combined.contains("Audio") || combined.contains("aac"),
+ "mpv should detect audio stream"
+ );
+}
+
+#[tokio::test]
+#[ignore = "live network test; run with cargo test --test live_stream_verification -- --ignored"]
+async fn test_live_moviebox_dynamic_movie_mpv_playback() {
+ let client = MovieBoxClient::new();
+ client.init().await.expect("client init successful");
+
+ let search_res = client.search("Avengers", 1).await.expect("search Avengers");
+ let catalog =
+ moviebox_tui::providers::moviebox::adapt::moviebox_search_json_to_catalog(&search_res);
+ assert!(!catalog.is_empty(), "search should return results");
+
+ let movie = catalog
+ .iter()
+ .find(|item| item.media_type == moviebox_tui::providers::models::MediaType::Movie)
+ .unwrap_or(&catalog[0]);
+
+ println!(
+ "Testing live dynamic movie: {} ({})",
+ movie.title, movie.id.value
+ );
+
+ let releases = client
+ .episode_streams(&movie.id.value, 0, 0)
+ .await
+ .expect("fetch movie streams");
+ assert!(!releases.is_empty(), "releases should not be empty");
+
+ let mirror = &releases[0].mirrors[0];
+ println!("Dynamic movie direct URL: {}", mirror.resolver_url);
+
+ let mut cmd = moviebox_tui::player::command(
+ moviebox_tui::player::PlayerKind::Mpv,
+ &mirror.resolver_url,
+ None,
+ &mirror.headers,
+ None,
+ None,
+ None,
+ );
+
+ cmd.arg("--vo=null").arg("--ao=null").arg("--frames=20");
+
+ let output = cmd.output().expect("execute mpv command");
+ let stdout = String::from_utf8_lossy(&output.stdout);
+ let stderr = String::from_utf8_lossy(&output.stderr);
+ let combined = format!("{stdout}\n{stderr}");
+
+ println!("MPV execution output:\n{}", combined);
+ assert!(
+ combined.contains("Video") || combined.contains("Audio"),
+ "mpv should successfully decode stream"
+ );
+}
+
+#[tokio::test]
+#[ignore = "live network test; run with cargo test --test live_stream_verification -- --ignored"]
+async fn test_live_moviebox_session_persistence_and_reuse() {
+ let client1 = MovieBoxClient::new();
+ let token1 = client1.ensure_session().await.expect("ensure session 1");
+ assert!(!token1.is_empty(), "token1 should not be empty");
+
+ // Client 2 without explicit init should load persisted session
+ let client2 = MovieBoxClient::new();
+ let token2 = client2.ensure_session().await.expect("ensure session 2");
+ assert_eq!(
+ token1, token2,
+ "client2 must reuse the persisted valid session token"
+ );
+
+ // Perform search with client 2
+ let search_res = client2
+ .search("Inception", 1)
+ .await
+ .expect("search with client2");
+ assert!(!search_res.is_null());
+
+ // Invalidation test
+ client2.invalidate_session();
+ let token3 = client2
+ .ensure_session()
+ .await
+ .expect("ensure session 3 after invalidation");
+ assert!(!token3.is_empty(), "token3 should be acquired");
}
#[tokio::test]
@@ -123,7 +317,7 @@ async fn test_live_fourkhdhub_movie_resolution() {
}
Err(e) => {
println!("Failed fast in {:?}: {e}", start.elapsed());
- assert!(start.elapsed() < std::time::Duration::from_secs(8));
+ assert!(start.elapsed() < std::time::Duration::from_secs(12));
}
}
}
@@ -171,7 +365,7 @@ async fn test_live_fourkhdhub_game_of_thrones_resolution() {
}
Err(e) => {
println!("Failed fast in {:?}: {e}", start.elapsed());
- assert!(start.elapsed() < std::time::Duration::from_secs(8));
+ assert!(start.elapsed() < std::time::Duration::from_secs(12));
}
}
}