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.mdindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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).awaitdiff --git a/src/providers/moviebox/session.rs b/src/providers/moviebox/session.rsnew file mode 100644index 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.rsindex 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.rsindex 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));}}}