Skip to content

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

feat: implement caching layer and refresh logic and improved terminal environment compatibility.

Samir Hossainsa641d1a925df
diff --git a/src/cache.rs b/src/cache.rs
new file mode 100644
index 0000000..526aee7
--- /dev/null
+++ b/src/cache.rs
@@ -0,0 +1,177 @@
+use std::path::PathBuf;
+use std::fs;
+use std::time::SystemTime;
+
+const CACHE_EXPIRY_SECS: u64 = 24 * 60 * 60; // 24 hours
+
+pub fn get_cache_dir(subdir: &str) -> PathBuf {
+ let mut path = dirs::cache_dir().unwrap_or_else(|| std::env::temp_dir());
+ path.push("moviebox-tui");
+ path.push(subdir);
+ if !path.exists() {
+ let _ = fs::create_dir_all(&path);
+ }
+ path
+}
+
+pub fn get_cache_path(subject_id: &str, season: usize, episode: usize) -> PathBuf {
+ let mut path = get_cache_dir("streams");
+ path.push(format!("{}_{}_{}.json", subject_id, season, episode));
+ path
+}
+
+pub fn get_stream_cache(subject_id: &str, season: usize, episode: usize) -> Option<serde_json::Value> {
+ let path = get_cache_path(subject_id, season, episode);
+ if path.exists() {
+ if let Ok(metadata) = fs::metadata(&path) {
+ if let Ok(modified) = metadata.modified() {
+ if let Ok(duration) = SystemTime::now().duration_since(modified) {
+ if duration.as_secs() > CACHE_EXPIRY_SECS {
+ let _ = fs::remove_file(&path);
+ return None;
+ }
+ }
+ }
+ }
+
+ if let Ok(content) = fs::read_to_string(&path) {
+ if let Ok(val) = serde_json::from_str(&content) {
+ return Some(val);
+ }
+ }
+ }
+ None
+}
+
+pub fn get_details_path(subject_id: &str) -> PathBuf {
+ let mut path = get_cache_dir("details");
+ path.push(format!("details_{}.json", subject_id));
+ path
+}
+
+pub fn get_details_cache(subject_id: &str) -> Option<serde_json::Value> {
+ let path = get_details_path(subject_id);
+ if path.exists() {
+ if let Ok(metadata) = fs::metadata(&path) {
+ if let Ok(modified) = metadata.modified() {
+ if let Ok(duration) = SystemTime::now().duration_since(modified) {
+ if duration.as_secs() > CACHE_EXPIRY_SECS {
+ let _ = fs::remove_file(&path);
+ return None;
+ }
+ }
+ }
+ }
+
+ if let Ok(content) = fs::read_to_string(&path) {
+ if let Ok(val) = serde_json::from_str(&content) {
+ return Some(val);
+ }
+ }
+ }
+ None
+}
+
+pub fn get_search_path(query: &str) -> PathBuf {
+ let mut path = get_cache_dir("search");
+ use md5::{Digest, Md5};
+ let mut hasher = Md5::new();
+ hasher.update(query.as_bytes());
+ let safe_query: String = hasher.finalize().iter().map(|b| format!("{:02x}", b)).collect();
+ path.push(format!("search_{}.json", safe_query));
+ path
+}
+
+pub fn get_search_cache(query: &str) -> Option<serde_json::Value> {
+ let path = get_search_path(query);
+ if path.exists() {
+ if let Ok(metadata) = fs::metadata(&path) {
+ if let Ok(modified) = metadata.modified() {
+ if let Ok(duration) = SystemTime::now().duration_since(modified) {
+ if duration.as_secs() > CACHE_EXPIRY_SECS {
+ let _ = fs::remove_file(&path);
+ return None;
+ }
+ }
+ }
+ }
+
+ if let Ok(content) = fs::read_to_string(&path) {
+ if let Ok(val) = serde_json::from_str(&content) {
+ return Some(val);
+ }
+ }
+ }
+ None
+}
+
+pub fn set_search_cache(query: &str, data: &serde_json::Value) {
+ let path = get_search_path(query);
+ if let Ok(content) = serde_json::to_string(data) {
+ let _ = fs::write(&path, content);
+ }
+}
+
+pub fn set_details_cache(subject_id: &str, data: &serde_json::Value) {
+ let path = get_details_path(subject_id);
+ if let Ok(content) = serde_json::to_string(data) {
+ let _ = fs::write(&path, content);
+ }
+}
+
+pub fn set_stream_cache(subject_id: &str, season: usize, episode: usize, data: &serde_json::Value) {
+ let path = get_cache_path(subject_id, season, episode);
+ if let Ok(content) = serde_json::to_string(data) {
+ let _ = fs::write(&path, content);
+ }
+}
+
+pub fn invalidate_stream_cache(subject_id: &str, season: usize, episode: usize) {
+ let path = get_cache_path(subject_id, season, episode);
+ if path.exists() {
+ let _ = fs::remove_file(&path);
+ }
+}
+
+pub fn clear_all_cache() {
+ let mut path = dirs::cache_dir().unwrap_or_else(|| std::env::temp_dir());
+ path.push("moviebox-tui");
+ if path.exists() {
+ let _ = fs::remove_dir_all(&path);
+ }
+}
+
+fn get_homepage_path(tab_id: &str, page: usize) -> PathBuf {
+ let mut path = get_cache_dir("homepage");
+ path.push(format!("{}_{}.json", tab_id, page));
+ path
+}
+
+pub fn get_homepage_cache(tab_id: &str, page: usize) -> Option<serde_json::Value> {
+ let path = get_homepage_path(tab_id, page);
+ if path.exists() {
+ if let Ok(metadata) = fs::metadata(&path) {
+ if let Ok(modified) = metadata.modified() {
+ if let Ok(elapsed) = modified.elapsed() {
+ if elapsed.as_secs() > 3600 {
+ let _ = fs::remove_file(&path);
+ return None;
+ }
+ }
+ }
+ }
+ if let Ok(content) = fs::read_to_string(&path) {
+ if let Ok(val) = serde_json::from_str(&content) {
+ return Some(val);
+ }
+ }
+ }
+ None
+}
+
+pub fn set_homepage_cache(tab_id: &str, page: usize, data: &serde_json::Value) {
+ let path = get_homepage_path(tab_id, page);
+ if let Ok(content) = serde_json::to_string(data) {
+ let _ = fs::write(&path, content);
+ }
+}
diff --git a/src/lib.rs b/src/lib.rs
index f3093af..05326b8 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,2 +1,3 @@
pub mod providers;
pub mod tui;
+pub mod cache;
diff --git a/src/providers/moviebox/client.rs b/src/providers/moviebox/client.rs
index 7efe2d7..d8919c8 100644
--- a/src/providers/moviebox/client.rs
+++ b/src/providers/moviebox/client.rs
@@ -1,9 +1,8 @@
use crate::providers::moviebox::crypto::build_signed_headers;
use reqwest::Response;
use serde_json::Value;
-use std::sync::Arc;
-use tokio::sync::RwLock;
-
+use std::sync::{Arc, RwLock};
+use std::sync::atomic::{AtomicUsize, Ordering};
const HOST_POOL: &[&str] = &[
"https://api6.aoneroom.com",
"https://api5.aoneroom.com",
@@ -34,7 +33,7 @@ pub enum ScraperError {
pub struct MovieBoxClient {
client: reqwest::Client,
runtime_token: Arc<RwLock<Option<String>>>,
- active_base_idx: Arc<RwLock<usize>>,
+ active_base_idx: Arc<AtomicUsize>,
user_agent: String,
client_info: String,
spoofed_ip: String,
@@ -55,7 +54,7 @@ impl MovieBoxClient {
.pool_idle_timeout(std::time::Duration::from_secs(90))
.pool_max_idle_per_host(4)
.build()
- .expect("Failed to build reqwest client; TLS backend may be missing");
+ .unwrap_or_else(|_| reqwest::Client::new());
let (user_agent, client_info) =
crate::providers::moviebox::crypto::generate_client_info_and_ua();
@@ -64,7 +63,7 @@ impl MovieBoxClient {
Self {
client,
runtime_token: Arc::new(RwLock::new(None)),
- active_base_idx: Arc::new(RwLock::new(0)),
+ active_base_idx: Arc::new(AtomicUsize::new(0)),
user_agent,
client_info,
spoofed_ip,
@@ -79,8 +78,8 @@ impl MovieBoxClient {
let path = "/wefeed-mobile-bff/tab-operating?page=1&tabId=0&version=";
let _ = self.get(path).await?;
- let token = self.runtime_token.read().await;
- if token.is_none() {
+ let has_token = self.runtime_token.read().unwrap().is_some();
+ if !has_token {
return Err(ScraperError::MissingToken);
}
Ok(())
@@ -100,7 +99,7 @@ impl MovieBoxClient {
return;
};
if !token.is_empty() {
- let mut write_token = self.runtime_token.write().await;
+ let mut write_token = self.runtime_token.write().unwrap();
*write_token = Some(token.to_string());
}
}
@@ -120,14 +119,17 @@ impl MovieBoxClient {
path_and_query: &str,
body: Option<&str>,
) -> Result<Value, ScraperError> {
- let start_idx = *self.active_base_idx.read().await;
+ let start_idx = self.active_base_idx.load(Ordering::Relaxed);
for i in 0..HOST_POOL.len() {
+ if i > 0 {
+ tokio::time::sleep(std::time::Duration::from_millis(50)).await;
+ }
let idx = (start_idx + i) % HOST_POOL.len();
let base = HOST_POOL[idx];
let url = format!("{}{}", base, path_and_query);
- let token = self.runtime_token.read().await.clone();
+ let token = self.runtime_token.read().unwrap().clone();
let headers = build_signed_headers(
method,
&url,
@@ -157,8 +159,7 @@ impl MovieBoxClient {
continue;
}
- let mut active_idx = self.active_base_idx.write().await;
- *active_idx = idx;
+ self.active_base_idx.store(idx, Ordering::Relaxed);
match self.parse_response(resp).await {
Ok(val) => return Ok(val),
diff --git a/src/tui/action.rs b/src/tui/action.rs
index a16207f..9c45d04 100644
--- a/src/tui/action.rs
+++ b/src/tui/action.rs
@@ -12,6 +12,7 @@ pub enum Action {
ToggleHelp,
Search {
query: String,
+ force_refresh: bool,
},
SelectSuggestion {
query: String,
@@ -49,7 +50,7 @@ pub enum Action {
DownloadStream,
UpdateDownload(Option<f64>, Option<String>),
CancelDownload,
- FetchDetails(String),
+ FetchDetails(String, bool),
DetailsSuccess(String, serde_json::Value),
DetailsFailure(String),
InitStreamPool(String),
@@ -58,6 +59,7 @@ pub enum Action {
subject_id: String,
season: usize,
episode: usize,
+ force_refresh: bool,
},
EpisodeStreamsReady(usize, usize, serde_json::Value),
EpisodeStreamsFailed(usize, usize, String),
@@ -69,4 +71,7 @@ pub enum Action {
UpdateProgress(f64),
UpdateSuccess,
UpdateFailure(String),
+ SetStatus(String),
+ Refresh,
+ ClearCache,
}
diff --git a/src/tui/app.rs b/src/tui/app.rs
index 1312815..1cd3530 100644
--- a/src/tui/app.rs
+++ b/src/tui/app.rs
@@ -11,28 +11,28 @@ use crate::tui::{
};
pub fn clean_moviebox_title(raw_title: &str) -> String {
- let mut clean = raw_title.to_string();
- if let Some(start) = clean.find(" [") {
- clean = clean[..start].to_string();
+ let mut end = raw_title.len();
+
+ if let Some(start) = raw_title[..end].find(" [") {
+ end = start;
}
- if let Some(start) = clean.find(" (") {
- let lower = clean.to_lowercase();
- let inside = &lower[start..];
+ if let Some(start) = raw_title[..end].find(" (") {
+ let inside = &raw_title[start..end].to_lowercase();
if inside.contains("dub") || inside.contains("hindi") {
- clean = clean[..start].to_string();
+ end = start;
}
}
- if let Some(s_idx) = clean.rfind(" S") {
- let suffix = &clean[s_idx + 2..];
+ if let Some(s_idx) = raw_title[..end].rfind(" S") {
+ let suffix = &raw_title[s_idx + 2..end];
let is_season = suffix
.chars()
.all(|c| c.is_ascii_digit() || c == '-' || c == 'S');
if is_season && suffix.chars().next().is_some_and(|c| c.is_ascii_digit()) {
- clean = clean[..s_idx].trim_end().to_string();
+ end = s_idx;
}
}
- clean
+ raw_title[..end].trim_end().to_string()
}
pub struct App {
@@ -84,25 +84,61 @@ impl App {
fn trigger_episode_fetch(&mut self) {
if let Some(id) = &self.state.active_subject_id {
- let se_idx = self.state.season_list_state.selected().unwrap_or(0);
- let ep_idx = self.state.episode_list_state.selected().unwrap_or(0);
-
- if let Some(season) = self.state.available_seasons.get(se_idx) {
- let se = season.get("se").and_then(|s| s.as_i64()).unwrap_or(1) as usize;
- let ep = if let Some(ep_numbers) = self.state.available_episode_numbers.get(se_idx) {
+ let stype = self.state.selected_details
+ .as_ref()
+ .and_then(|d| d.get("subjectType").or_else(|| d.get("stype")))
+ .and_then(|s| s.as_i64())
+ .unwrap_or(1);
+
+ let (se, ep) = if stype == 2 {
+ let se_idx = self.state.season_list_state.selected().unwrap_or(0);
+ let ep_idx = self.state.episode_list_state.selected().unwrap_or(0);
+
+ let season_num = self.state.available_seasons.get(se_idx)
+ .and_then(|s| s.get("se"))
+ .and_then(|s| s.as_i64())
+ .unwrap_or(1) as usize;
+
+ let ep_num = if let Some(ep_numbers) = self.state.available_episode_numbers.get(se_idx) {
ep_numbers.get(ep_idx).copied().unwrap_or(ep_idx + 1)
} else {
ep_idx + 1
};
- self.state.selected_season = se;
- self.state.selected_episode = ep;
- self.state.resource_list_state.select(None);
- self.state.selected_resources = None;
+ (season_num, ep_num)
+ } else {
+ (0, 0)
+ };
+
+ self.state.selected_season = se;
+ self.state.selected_episode = ep;
+ self.state.resource_list_state.select(None);
+
+ let mut found_cached = false;
+ if let Some(cached) = crate::cache::get_stream_cache(id, se, ep) {
+ found_cached = true;
+ if let Some(arr) = cached.as_array() {
+ let count = arr.len();
+ let mut result = serde_json::Map::new();
+ result.insert("list".to_string(), cached.clone());
+ self.state.selected_resources = Some(serde_json::Value::Object(result));
+ self.state.is_loading = false;
+ self.state.is_fetching_streams = false;
+ self.state.resource_list_state.select(if count > 0 { Some(0) } else { None });
+ self.state.status_message = format!("Resolved {} direct stream sources (cached).", count);
+ self.state.status_timer = 150;
+ }
+ }
+
+ if !found_cached {
self.state.is_loading = true;
+ self.state.is_fetching_streams = true;
+ self.state.status_message = "Resolving streams...".to_string();
+ self.state.status_timer = 150;
self.state.pending_episode_fetch = Some((id.clone(), se, ep));
self.state.last_episode_nav = std::time::Instant::now();
- self.state.is_fetching_streams = true;
+ } else {
+ self.state.pending_episode_fetch = None;
}
}
}
@@ -154,10 +190,7 @@ impl App {
self.state.image_picker = Some(picker);
}
- tokio::time::sleep(std::time::Duration::from_millis(30)).await;
- while crossterm::event::poll(std::time::Duration::ZERO).unwrap_or(false) {
- let _ = crossterm::event::read();
- }
+
}
Err(_) => {
self.state.image_supported = false;
@@ -259,27 +292,35 @@ impl App {
}
async fn handle_action(&mut self, action: Action) -> Option<()> {
- self.state.dirty = true;
+ if !matches!(action, Action::Tick) {
+ self.state.dirty = true;
+ }
match action {
Action::Tick => {
+ let mut needs_redraw = self.state.is_loading || self.state.tick_count < 15;
self.state.tick_count = self.state.tick_count.wrapping_add(1);
if self.state.toast_timer > 0 {
+ needs_redraw = true;
self.state.toast_timer -= 1;
if self.state.toast_timer == 0 {
self.state.toast_message = None;
}
}
if self.state.status_timer > 0 {
+ needs_redraw = true;
self.state.status_timer -= 1;
if self.state.status_timer == 0 {
self.state.status_message.clear();
}
}
+ if needs_redraw {
+ self.state.dirty = true;
+ }
let current_query = self.state.search_query.trim().to_string();
if current_query != self.state.last_suggest_query
&& self.state.last_search_edit.elapsed()
- >= std::time::Duration::from_millis(250)
+ >= std::time::Duration::from_millis(100)
{
self.state.last_suggest_query = current_query.clone();
if !current_query.is_empty() {
@@ -324,6 +365,7 @@ impl App {
subject_id,
season: se,
episode: ep,
+ force_refresh: false,
})
.ok();
}
@@ -337,20 +379,14 @@ impl App {
self.state.poster_protocol = None;
self.state.search_poster_protocols.clear();
if self.state.image_picker.is_some() {
- tokio::time::sleep(std::time::Duration::from_millis(30)).await;
- while crossterm::event::poll(std::time::Duration::ZERO).unwrap_or(false) {
- let _ = crossterm::event::read();
- }
+
}
}
Action::Resize(_w, _h) => {
self.state.poster_protocol = None;
self.state.search_poster_protocols.clear();
if self.state.image_picker.is_some() {
- tokio::time::sleep(std::time::Duration::from_millis(30)).await;
- while crossterm::event::poll(std::time::Duration::ZERO).unwrap_or(false) {
- let _ = crossterm::event::read();
- }
+
}
}
Action::Key(key) => {
@@ -389,13 +425,12 @@ impl App {
self.state.input_mode = InputMode::Normal;
self.state.search_suggestions.clear();
self.state.suggest_index = None;
- self.state.search_results.clear();
self.state.search_list_state.select(None);
self.state.last_search_edit = std::time::Instant::now();
let action = if selected_suggestion {
Action::SelectSuggestion { query }
} else {
- Action::Search { query }
+ Action::Search { query, force_refresh: false }
};
self.action_sender.send(action).ok();
}
@@ -460,6 +495,9 @@ impl App {
KeyCode::Char('q') => {
self.action_sender.send(Action::Quit).ok();
}
+ KeyCode::Char('r') => {
+ self.action_sender.send(Action::Refresh).ok();
+ }
KeyCode::Char(c)
if (key.modifiers.is_empty()
|| key.modifiers == KeyModifiers::SHIFT) =>
@@ -492,28 +530,8 @@ impl App {
self.action_sender.send(Action::DownloadStream).ok();
}
}
- KeyCode::Char('R') => {
- if let Some(id) = self.state.active_subject_id.clone() {
- let se = if self.state.available_seasons.is_empty() {
- 0
- } else {
- self.state.selected_season
- };
- let ep = if self.state.available_seasons.is_empty() {
- 0
- } else {
- self.state.selected_episode
- };
- self.state.selected_season = se;
- self.state.selected_episode = ep;
- self.action_sender
- .send(Action::FetchEpisodeStreams {
- subject_id: id,
- season: se,
- episode: ep,
- })
- .ok();
- }
+ KeyCode::Char('r') => {
+ self.action_sender.send(Action::Refresh).ok();
}
KeyCode::Char('?') => {
self.action_sender.send(Action::ToggleHelp).ok();
@@ -611,6 +629,7 @@ impl App {
self.state
.fetch_cancel
.store(true, std::sync::atomic::Ordering::Relaxed);
+ self.state.stream_pool.clear();
self.state.pending_episode_fetch = None;
self.state.selected_resources = None;
self.state.active_screen = Screen::Home;
@@ -622,6 +641,47 @@ impl App {
}
}
}
+ Action::Refresh => {
+ match self.state.active_screen {
+ Screen::Home => {
+ let query = self.state.search_query.trim().to_string();
+ if !query.is_empty() {
+ self.action_sender.send(Action::Search { query, force_refresh: true }).ok();
+ }
+ }
+ Screen::Details => {
+ if let Some(id) = self.state.active_subject_id.clone() {
+ let se = if self.state.available_seasons.is_empty() {
+ 0
+ } else {
+ self.state.selected_season
+ };
+ let ep = if self.state.available_seasons.is_empty() {
+ 0
+ } else {
+ self.state.selected_episode
+ };
+ crate::cache::invalidate_stream_cache(&id, se, ep);
+ self.state.selected_season = se;
+ self.state.selected_episode = ep;
+ self.action_sender
+ .send(Action::FetchEpisodeStreams {
+ subject_id: id,
+ season: se,
+ episode: ep,
+ force_refresh: true,
+ })
+ .ok();
+ }
+ }
+ _ => {}
+ }
+ }
+ Action::ClearCache => {
+ crate::cache::clear_all_cache();
+ self.state.status_message = "Cache cleared completely.".to_string();
+ self.state.status_timer = 150;
+ }
Action::SelectLanguage(idx) => {
if let Some(details) = &self.state.selected_details
&& let Some(dubs) = details.get("dubs").and_then(|d| d.as_array())
@@ -629,16 +689,41 @@ impl App {
&& let Some(id) = dub.get("subjectId").and_then(|i| i.as_str())
{
let next_id = id.to_string();
- self.state.selected_details = None;
self.state.selected_resources = None;
self.state.resource_list_state.select(None);
self.state.language_chosen = true;
self.state.status_message = "Switching language...".to_string();
self.state.status_timer = 150;
- self.action_sender.send(Action::FetchDetails(next_id)).ok();
+ self.action_sender.send(Action::FetchDetails(next_id, false)).ok();
}
}
Action::Suggest(query) => {
+ if query.starts_with('/') {
+ let commands = vec![
+ "/discover",
+ "/movies",
+ "/tvshows",
+ "/search",
+ "/clear-cache",
+ "/quit",
+ ];
+ let mut suggestions = vec![];
+ for cmd in commands {
+ if cmd.starts_with(&query) {
+ suggestions.push(serde_json::json!({ "title": cmd }));
+ }
+ }
+ if !suggestions.is_empty() {
+ let fake_payload = serde_json::json!({
+ "results": [{
+ "subjects": suggestions
+ }]
+ });
+ self.action_sender.send(Action::SuggestSuccess(query, fake_payload)).ok();
+ }
+ return None;
+ }
+
let client = self.client.clone();
let sender = self.action_sender.clone();
let query_clone = query.clone();
@@ -700,9 +785,9 @@ impl App {
}
}
Action::SelectSuggestion { query } => {
- self.action_sender.send(Action::Search { query }).ok();
+ self.action_sender.send(Action::Search { query, force_refresh: false }).ok();
}
- Action::Search { query } => {
+ Action::Search { query, force_refresh } => {
let lower_query = query.trim().to_lowercase();
if lower_query == "/github" {
let _ = open::that("https://github.com/mesamirh/MovieBox-Tui");
@@ -752,6 +837,12 @@ impl App {
return None;
}
+ if lower_query == "/clear-cache" {
+ self.action_sender.send(Action::ClearCache).ok();
+ self.state.search_query.clear();
+ return None;
+ }
+
let tab_id = match lower_query.as_str() {
"/home" | "/discover" => Some("0"),
"/movies" => Some("2"),
@@ -776,19 +867,31 @@ impl App {
self.state.selected_details = None;
self.state.selected_resources = None;
self.state.is_loading = true;
- self.state.search_results.clear();
self.state.search_list_state.select(Some(0));
self.state.search_suggestions.clear();
self.state.suggest_index = None;
+ self.state.search_preview = None;
self.state.status_message = format!("Searching for '{}'...", query);
self.state.status_timer = 150;
- let client = self.client.clone();
- let sender = self.action_sender.clone();
let query_clone = query.clone();
+ let sender = self.action_sender.clone();
+ let client = self.client.clone();
tokio::spawn(async move {
+ if !force_refresh {
+ if let Some(cached) = crate::cache::get_search_cache(&query_clone) {
+ sender
+ .send(Action::SearchSuccess {
+ query: query_clone.clone(),
+ payload: cached,
+ })
+ .ok();
+ return;
+ }
+ }
match client.search(&query_clone, 1).await {
Ok(res) => {
+ crate::cache::set_search_cache(&query_clone, &res);
sender
.send(Action::SearchSuccess {
query: query_clone,
@@ -821,9 +924,24 @@ impl App {
let client = self.client.clone();
let sender = self.action_sender.clone();
+ let force_refresh = false;
+
+ if !force_refresh {
+ if let Some(cached) = crate::cache::get_homepage_cache(&tab_id, page) {
+ sender
+ .send(Action::HomepageSuccess {
+ tab_id: tab_id.clone(),
+ page,
+ payload: cached,
+ })
+ .ok();
+ }
+ }
+
tokio::spawn(async move {
match client.get_homepage(&tab_id, page).await {
Ok(res) => {
+ crate::cache::set_homepage_cache(&tab_id, page, &res);
sender
.send(Action::HomepageSuccess {
tab_id,
@@ -1283,6 +1401,9 @@ impl App {
let current = self.state.language_list_state.selected().unwrap_or(0);
if current > 0 {
self.state.language_list_state.select(Some(current - 1));
+ self.action_sender
+ .send(Action::SelectLanguage(current - 1))
+ .ok();
}
}
},
@@ -1444,6 +1565,9 @@ impl App {
&& current + 1 < dubs.len()
{
self.state.language_list_state.select(Some(current + 1));
+ self.action_sender
+ .send(Action::SelectLanguage(current + 1))
+ .ok();
}
}
},
@@ -1606,19 +1730,29 @@ impl App {
self.state.status_timer = 150;
let sender = self.action_sender.clone();
- sender.send(Action::FetchDetails(item.id)).ok();
+ sender.send(Action::FetchDetails(item.id.clone(), false)).ok();
}
}
}
- Action::FetchDetails(id) => {
+ Action::FetchDetails(id, force_refresh) => {
self.state.poster_protocol = None;
self.state.is_loading = true;
+ self.state.fetch_cancel.store(false, std::sync::atomic::Ordering::Relaxed);
+ self.state.status_message = "Fetching details...".to_string();
+ self.state.stream_pool.clear();
let client = self.client.clone();
let sender = self.action_sender.clone();
let id_clone = id.clone();
tokio::spawn(async move {
+ if !force_refresh {
+ if let Some(cached) = crate::cache::get_details_cache(&id_clone) {
+ sender.send(Action::DetailsSuccess(id_clone.clone(), cached)).ok();
+ return;
+ }
+ }
match client.get_details(&id_clone).await {
Ok(details) => {
+ crate::cache::set_details_cache(&id_clone, &details);
sender.send(Action::DetailsSuccess(id_clone, details)).ok();
}
Err(e) => {
@@ -2394,8 +2528,29 @@ impl App {
}
Action::DetailsSuccess(id, payload) => {
+ let mut final_payload = payload.clone();
+ if self.state.language_chosen {
+ if let Some(existing) = &self.state.selected_details {
+ if let Some(final_obj) = final_payload.as_object_mut() {
+ if let Some(existing_obj) = existing.as_object() {
+ let preserve_keys = [
+ "title", "synopsis", "cover", "year", "releaseDate",
+ "duration", "countryName", "genre", "imdbRatingValue",
+ "intro", "description", "dubs"
+ ];
+ for key in preserve_keys {
+ if let Some(v) = existing_obj.get(key) {
+ final_obj.insert(key.to_string(), v.clone());
+ }
+ }
+ }
+ }
+ }
+ }
+
self.state.active_subject_id = Some(id.clone());
- self.state.selected_details = Some(payload.clone());
+ self.state.selected_details = Some(final_payload.clone());
+ let payload = final_payload;
if self.state.poster_image.is_none() {
if let Some(cached_img) = self.state.image_cache.get(&id) {
@@ -2475,21 +2630,13 @@ impl App {
if let Some(dubs) = payload.get("dubs").and_then(|d| d.as_array()) {
let mut current_idx = 0;
- let current_id = payload
- .get("id")
- .and_then(|i| {
- i.as_i64()
- .map(|n| n.to_string())
- .or_else(|| i.as_str().map(|s| s.to_string()))
- })
- .unwrap_or_default();
for (i, dub) in dubs.iter().enumerate() {
let dub_id = dub.get("subjectId").and_then(|i| {
i.as_i64()
.map(|n| n.to_string())
.or_else(|| i.as_str().map(|s| s.to_string()))
});
- if dub_id == Some(current_id.clone()) {
+ if dub_id == Some(id.clone()) {
current_idx = i;
}
}
@@ -2498,8 +2645,10 @@ impl App {
self.state.language_list_state.select(Some(0));
}
- self.state.selected_season = 1;
- self.state.selected_episode = 1;
+ if !self.state.language_chosen {
+ self.state.selected_season = 1;
+ self.state.selected_episode = 1;
+ }
let has_multiple_dubs = payload
.get("dubs")
@@ -2513,16 +2662,15 @@ impl App {
self.state.status_timer = 150;
} else {
if stype == 2 && !self.state.available_seasons.is_empty() {
- self.state.details_pane = crate::tui::state::DetailsPane::Episodes;
+ self.state.details_pane = crate::tui::state::DetailsPane::Seasons;
} else {
self.state.details_pane = crate::tui::state::DetailsPane::Streams;
}
-
- self.state
- .fetch_cancel
+
+ self.state.is_loading = true;
+ self.state.fetch_cancel
.store(false, std::sync::atomic::Ordering::Relaxed);
- let sender = self.action_sender.clone();
- sender.send(Action::InitStreamPool(id)).ok();
+ self.action_sender.send(Action::InitStreamPool(id)).ok();
}
}
Action::DetailsFailure(err) => {
@@ -2530,18 +2678,24 @@ impl App {
self.state.status_message = format!("Details fetch failed: {}", err);
self.state.status_timer = 150;
}
+ Action::SetStatus(msg) => {
+ self.state.status_message = msg;
+ self.state.status_timer = 150;
+ }
Action::InitStreamPool(subject_id) => {
+ let mut pool = crate::tui::state::SubjectStreamPool::default();
+ pool.available_resolutions = vec![];
+ self.state.stream_pool.insert(subject_id.clone(), pool);
+ self.trigger_episode_fetch();
+
let client = self.client.clone();
let sender = self.action_sender.clone();
- let id_clone = subject_id.clone();
tokio::spawn(async move {
- let resolutions = client
- .fetch_collection_resolutions(&id_clone)
- .await
- .unwrap_or_else(|_| vec![1080, 720, 480, 360]);
- sender
- .send(Action::StreamPoolInitialized(id_clone, resolutions))
- .ok();
+ if let Ok(resolutions) = client.fetch_collection_resolutions(&subject_id).await {
+ if !resolutions.is_empty() {
+ sender.send(Action::StreamPoolInitialized(subject_id, resolutions)).ok();
+ }
+ }
});
}
Action::StreamPoolInitialized(subject_id, resolutions) => {
@@ -2556,13 +2710,18 @@ impl App {
.or_else(|| details.get("stype").and_then(|s| s.as_i64()))
.unwrap_or(1);
if stype == 2 {
- (1usize, 1usize)
+ let se = if self.state.selected_season > 0 { self.state.selected_season } else { 1 };
+ let ep = if self.state.selected_episode > 0 { self.state.selected_episode } else { 1 };
+ (se, ep)
} else {
(0usize, 0usize)
}
} else {
- (1usize, 1usize)
+ let se = if self.state.selected_season > 0 { self.state.selected_season } else { 1 };
+ let ep = if self.state.selected_episode > 0 { self.state.selected_episode } else { 1 };
+ (se, ep)
};
+ let _ = (se, ep);
self.state.selected_season = se;
self.state.selected_episode = ep;
@@ -2572,6 +2731,7 @@ impl App {
subject_id,
season: se,
episode: ep,
+ force_refresh: true,
})
.ok();
}
@@ -2579,22 +2739,35 @@ impl App {
subject_id,
season,
episode,
+ force_refresh,
} => {
self.state.is_loading = true;
- self.state.selected_resources = None;
+ self.state.is_fetching_streams = true;
if let Some(pool) = self.state.stream_pool.get_mut(&subject_id) {
- if let Some(cached) = pool.episode_index.get(&(season, episode)) {
- self.action_sender
- .send(Action::EpisodeStreamsReady(
- season,
- episode,
- serde_json::Value::Array(cached.clone()),
- ))
- .ok();
- return None;
+ if !force_refresh {
+ if let Some(cached) = pool.episode_index.get(&(season, episode)) {
+ self.action_sender
+ .send(Action::EpisodeStreamsReady(
+ season,
+ episode,
+ serde_json::Value::Array(cached.clone()),
+ ))
+ .ok();
+ return None;
+ }
}
+ let mut absolute_episode = 0;
+ for s_val in &self.state.available_seasons {
+ let se = s_val.get("se").and_then(|v| v.as_i64()).unwrap_or(0) as usize;
+ if se < season {
+ absolute_episode += s_val.get("maxEp").and_then(|m| m.as_i64()).unwrap_or(1) as usize;
+ }
+ }
+ absolute_episode += episode.saturating_sub(1);
+ let estimated_page = (absolute_episode / 20) + 1;
+
let client = self.client.clone();
let sender = self.action_sender.clone();
let cancel_token = self.state.fetch_cancel.clone();
@@ -2603,6 +2776,16 @@ impl App {
let is_movie = season == 0 && episode == 0;
tokio::spawn(async move {
+ if !force_refresh {
+ if let Some(cached) = crate::cache::get_stream_cache(&id_clone, season, episode) {
+ sender.send(Action::SetStatus("Loaded from cache.".to_string())).ok();
+ sender.send(Action::EpisodeStreamsReady(season, episode, cached)).ok();
+ return;
+ }
+ }
+
+ sender.send(Action::SetStatus("Fetching streams...".to_string())).ok();
+
let mut all_items: Vec<serde_json::Value> = Vec::new();
let mut found_target = false;
@@ -2627,7 +2810,7 @@ impl App {
}
}
} else {
- let mut page = 1usize;
+ let mut page = estimated_page;
'outer: loop {
if cancel_token.load(std::sync::atomic::Ordering::Relaxed) { break 'outer; }
let mut page_handles = Vec::new();
@@ -2701,10 +2884,6 @@ impl App {
}
Action::EpisodeStreamsReady(target_se, target_ep, payload) => {
if target_se != self.state.selected_season || target_ep != self.state.selected_episode {
- self.state.is_fetching_streams = false;
- if self.state.pending_episode_fetch.is_none() {
- self.state.is_loading = false;
- }
return None;
}
@@ -2780,18 +2959,28 @@ impl App {
});
let count = filtered.len();
+ let array_payload = serde_json::Value::Array(filtered.clone());
+ if count > 0 {
+ if let Some(subject_id) = &self.state.active_subject_id {
+ crate::cache::set_stream_cache(subject_id, target_se, target_ep, &array_payload);
+ }
+ }
+
let mut result = serde_json::Map::new();
- result.insert("list".to_string(), serde_json::Value::Array(filtered));
+ result.insert("list".to_string(), array_payload);
self.state.selected_resources = Some(serde_json::Value::Object(result));
self.state.is_loading = false;
self.state.is_fetching_streams = false;
self.state
.resource_list_state
.select(if count > 0 { Some(0) } else { None });
- self.state.status_message = format!("Resolved {} direct stream sources.", count);
+ self.state.status_message = format!("{} streams available.", count);
self.state.status_timer = 150;
}
- Action::EpisodeStreamsFailed(_season, _episode, err) => {
+ Action::EpisodeStreamsFailed(target_se, target_ep, err) => {
+ if target_se != self.state.selected_season || target_ep != self.state.selected_episode {
+ return None;
+ }
self.state.is_loading = false;
self.state.is_fetching_streams = false;
self.state.selected_resources = None;
@@ -2890,13 +3079,21 @@ impl App {
#[cfg(target_os = "macos")]
{
let mut c = std::process::Command::new("open");
- c.arg("-a").arg("IINA").arg(&link);
+ c.arg("-a").arg("IINA");
+ if let Some(s) = &local_sub {
+ c.arg("--args").arg(&link).arg(format!("--mpv-sub-file={}", s));
+ } else {
+ c.arg(&link);
+ }
c
}
#[cfg(not(target_os = "macos"))]
{
let mut c = std::process::Command::new("mpv");
c.arg(&link);
+ if let Some(s) = local_sub {
+ c.arg(format!("--sub-file={}", s));
+ }
c
}
}
@@ -2926,7 +3123,7 @@ impl App {
};
c.arg(&link);
if let Some(s) = local_sub {
- c.arg("--sub-file").arg(s);
+ c.arg(format!("--sub-file={}", s));
}
c
}
@@ -2992,7 +3189,7 @@ impl App {
self.state.toast_message =
Some("Failed to check for updates.".to_string());
}
- self.state.toast_timer = 150;
+ self.state.toast_timer = 40;
}
} else {
self.state.update_available = Some(version);
@@ -3018,7 +3215,7 @@ impl App {
let download_url = format!("https://github.com/mesamirh/MovieBox-Tui/releases/download/v{}/{}", version, asset_name);
- let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_secs();
+ let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let tmp_dir = std::env::temp_dir().join(format!("moviebox-update-{}", ts));
let _ = std::fs::create_dir_all(&tmp_dir);
diff --git a/src/tui/event.rs b/src/tui/event.rs
index 25a8223..83a04b8 100644
--- a/src/tui/event.rs
+++ b/src/tui/event.rs
@@ -16,7 +16,10 @@ impl EventHandler {
tokio::spawn(async move {
loop {
- let polled = crossterm::event::poll(Duration::from_millis(16)).unwrap_or(false);
+ let polled = match crossterm::event::poll(Duration::from_millis(16)) {
+ Ok(p) => p,
+ Err(_) => break,
+ };
if polled {
match crossterm::event::read() {
Ok(CrosstermEvent::Key(key)) => {
diff --git a/src/tui/screens/details.rs b/src/tui/screens/details.rs
index e1d1176..e5480ea 100644
--- a/src/tui/screens/details.rs
+++ b/src/tui/screens/details.rs
@@ -165,7 +165,9 @@ pub fn draw(frame: &mut Frame, area: Rect, state: &mut AppState, theme: &Theme)
}
}
if let Some((_, proto)) = &state.poster_protocol {
- frame.render_widget(ratatui_image::Image::new(proto), poster_area);
+ if !state.show_help {
+ frame.render_widget(ratatui_image::Image::new(proto), poster_area);
+ }
}
} else if state.image_supported {
let current_spinner = if state.basic_terminal {
@@ -457,11 +459,25 @@ pub fn draw(frame: &mut Frame, area: Rect, state: &mut AppState, theme: &Theme)
.get("codecName")
.and_then(|c| c.as_str())
.unwrap_or("None");
- let _upload_by = file
+ let upload_by = file
.get("uploadBy")
.and_then(|u| u.as_str())
- .unwrap_or("None");
+ .unwrap_or("Unknown");
let size_str = file.get("size").and_then(|s| s.as_str()).unwrap_or("0");
+
+ let duration = file.get("duration").and_then(|d| d.as_u64()).unwrap_or(0);
+ let duration_str = if duration > 0 {
+ let hours = duration / 3600;
+ let mins = (duration % 3600) / 60;
+ let secs = duration % 60;
+ if hours > 0 {
+ format!("{:02}:{:02}:{:02}", hours, mins, secs)
+ } else {
+ format!("{:02}:{:02}", mins, secs)
+ }
+ } else {
+ "--:--".to_string()
+ };
let size_formatted = if let Ok(bytes) = size_str.parse::<f64>() {
let mb = bytes / 1024.0 / 1024.0;
@@ -490,7 +506,7 @@ pub fn draw(frame: &mut Frame, area: Rect, state: &mut AppState, theme: &Theme)
let stream_line = ratatui::text::Line::from(vec![
ratatui::text::Span::styled(pointer, theme.accent),
ratatui::text::Span::styled(
- format!("{:<7} {:<6} ", size_formatted, codec),
+ format!("{:<7} | {:<5} | {} | By: {}", size_formatted, codec.to_uppercase(), duration_str, upload_by),
stream_style,
),
]);
@@ -567,7 +583,9 @@ pub fn draw(frame: &mut Frame, area: Rect, state: &mut AppState, theme: &Theme)
.and_then(|d| d.as_array())
.is_some_and(|a| a.len() > 1);
- let msg = if state.is_loading {
+ let is_busy = state.is_loading || state.is_fetching_streams;
+
+ let msg = if is_busy {
let spinner = if state.basic_terminal {
let frames = ['-', '\\', '|', '/'];
frames[(state.tick_count as usize) % frames.len()]
@@ -578,28 +596,32 @@ pub fn draw(frame: &mut Frame, area: Rect, state: &mut AppState, theme: &Theme)
format!("{} Loading streams...", spinner)
} else if has_multiple_dubs && !state.language_chosen {
"Please select a language dubbing from the Audio panel to view streams.".to_string()
- } else if state.status_message.to_lowercase().contains("failed")
+ } else if state.status_message.to_lowercase().contains("no streams")
|| state.status_message.to_lowercase().contains("error")
{
state.status_message.clone()
} else {
- "Failed to load streams.".to_string()
+ String::new()
};
- let style = if state.is_loading || (has_multiple_dubs && !state.language_chosen) {
+ let style = if is_busy || (has_multiple_dubs && !state.language_chosen) {
theme.text_dim
} else {
theme.error
};
- let inner = streams_block.inner(streams_area);
- let pad = "\n".repeat((inner.height.saturating_sub(1) / 2) as usize);
- let p = Paragraph::new(format!("{}{}", pad, msg))
- .style(style)
- .alignment(Alignment::Center)
- .wrap(Wrap { trim: true })
- .block(streams_block.clone());
- frame.render_widget(p, streams_area);
+ if !msg.is_empty() {
+ let inner = streams_block.inner(streams_area);
+ let pad = "\n".repeat((inner.height.saturating_sub(1) / 2) as usize);
+ let p = Paragraph::new(format!("{}{}", pad, msg))
+ .style(style)
+ .alignment(Alignment::Center)
+ .wrap(Wrap { trim: true })
+ .block(streams_block.clone());
+ frame.render_widget(p, streams_area);
+ } else {
+ frame.render_widget(streams_block.clone(), streams_area);
+ }
}
}
if !state.selected_resources.is_some() {
@@ -691,7 +713,7 @@ pub fn draw(frame: &mut Frame, area: Rect, state: &mut AppState, theme: &Theme)
}
let footer_text =
- "Enter Play o Open With... D Download C Copy Link Esc Back";
+ "Enter Play o Open With... D Download r Refresh Esc Back";
let footer_p = Paragraph::new(footer_text)
.alignment(Alignment::Center)
.style(theme.muted);
diff --git a/src/tui/screens/help.rs b/src/tui/screens/help.rs
index c80ccf5..7819745 100644
--- a/src/tui/screens/help.rs
+++ b/src/tui/screens/help.rs
@@ -74,6 +74,10 @@ pub fn draw(frame: &mut Frame, area: Rect, state: &AppState, theme: &Theme) {
Span::styled(" /toggle-update ", theme.header),
Span::styled("Toggle auto updates", theme.text),
]),
+ Line::from(vec![
+ Span::styled(" /clear-cache ", theme.header),
+ Span::styled("Clear app cache", theme.text),
+ ]),
Line::from(vec![]),
Line::from(vec![Span::styled(
" Stream Controls",
@@ -88,8 +92,8 @@ pub fn draw(frame: &mut Frame, area: Rect, state: &AppState, theme: &Theme) {
Span::styled("Open Player Picker", theme.text),
]),
Line::from(vec![
- Span::styled(" [R] ", theme.header),
- Span::styled("Refresh Streams", theme.text),
+ Span::styled(" [r] ", theme.header),
+ Span::styled("Refresh Streams/Search", theme.text),
]),
Line::from(vec![
Span::styled(" [d] ", theme.header),
diff --git a/src/tui/screens/home.rs b/src/tui/screens/home.rs
index a2e0ce8..dc929f7 100644
--- a/src/tui/screens/home.rs
+++ b/src/tui/screens/home.rs
@@ -263,16 +263,7 @@ pub fn draw(frame: &mut Frame, area: Rect, state: &mut AppState, theme: &Theme)
frame.render_widget(version, version_chunks[1]);
if state.tick_count >= 3 {
- let search_chunks = Layout::default()
- .direction(Direction::Horizontal)
- .constraints([
- Constraint::Percentage(25),
- Constraint::Percentage(50),
- Constraint::Percentage(25),
- ])
- .split(vertical_chunks[5]);
-
- search_bar_area = search_chunks[1];
+ search_bar_area = vertical_chunks[5];
let search_bar = Paragraph::new(search_content.clone())
.alignment(Alignment::Center)
@@ -314,34 +305,51 @@ pub fn draw(frame: &mut Frame, area: Rect, state: &mut AppState, theme: &Theme)
.split(area);
search_bar_area = chunks[0];
-
let border_style = if state.input_mode == InputMode::Editing {
theme.border_focus
} else {
theme.border
};
+ let loading_title = if state.is_loading && !state.search_results.is_empty() {
+ let spinner = if state.basic_terminal {
+ let frames = ['-', '\\', '|', '/'];
+ frames[(state.tick_count as usize) % frames.len()]
+ } else {
+ let frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+ frames[(state.tick_count as usize) % frames.len()]
+ };
+ Some(ratatui::text::Line::from(ratatui::text::Span::styled(
+ format!(" {} ", spinner),
+ theme.accent,
+ )))
+ } else {
+ None
+ };
+
+ let mut search_block = Block::default()
+ .borders(Borders::ALL)
+ .border_style(border_style)
+ .border_type(if state.basic_terminal {
+ ratatui::widgets::BorderType::Plain
+ } else {
+ ratatui::widgets::BorderType::Rounded
+ })
+ .padding(ratatui::widgets::Padding::left(1));
+ if let Some(title) = loading_title {
+ search_block = search_block.title_top(title).title_alignment(Alignment::Right);
+ }
let search_bar = Paragraph::new(search_content.clone())
.style(match state.input_mode {
InputMode::Editing => theme.title,
InputMode::Normal => theme.text,
})
- .block(
- Block::default()
- .borders(Borders::ALL)
- .border_style(border_style)
- .border_type(if state.basic_terminal {
- ratatui::widgets::BorderType::Plain
- } else {
- ratatui::widgets::BorderType::Rounded
- })
- .padding(ratatui::widgets::Padding::left(1)),
- );
+ .block(search_block);
frame.render_widget(search_bar, search_bar_area);
let list_block = Block::default();
- if state.is_loading {
+ if state.is_loading && state.search_results.is_empty() {
let spinner = if state.basic_terminal {
let frames = ['-', '\\', '|', '/'];
frames[(state.tick_count as usize) % frames.len()]
@@ -637,7 +645,7 @@ pub fn draw(frame: &mut Frame, area: Rect, state: &mut AppState, theme: &Theme)
{
let search_area = search_bar_area;
- let dropdown_height = std::cmp::min(state.search_suggestions.len() as u16 + 2, 10);
+ let dropdown_height = std::cmp::min(state.search_suggestions.len() as u16, 10);
let is_home_screen = state.search_results.is_empty()
&& !state.is_loading
@@ -646,7 +654,7 @@ pub fn draw(frame: &mut Frame, area: Rect, state: &mut AppState, theme: &Theme)
let dropdown_y = if !is_home_screen && search_area.y > area.height / 2 {
search_area.y.saturating_sub(dropdown_height)
} else {
- search_area.y + search_area.height
+ search_area.y + 1
};
let max_len = state
@@ -655,8 +663,17 @@ pub fn draw(frame: &mut Frame, area: Rect, state: &mut AppState, theme: &Theme)
.map(|s| s.len())
.max()
.unwrap_or(0) as u16;
+
let dropdown_width = std::cmp::min(std::cmp::max(max_len + 8, 30), search_area.width);
- let dropdown_x = search_area.x + (search_area.width.saturating_sub(dropdown_width)) / 2;
+
+ let text_len = search_content.chars().count() as u16;
+ let text_start_x = search_area.x + search_area.width.saturating_sub(text_len) / 2;
+
+ let dropdown_x = if is_home_screen {
+ text_start_x + 2
+ } else {
+ search_area.x + 3
+ };
let dropdown_area = Rect {
x: dropdown_x,
@@ -691,13 +708,7 @@ pub fn draw(frame: &mut Frame, area: Rect, state: &mut AppState, theme: &Theme)
.collect();
let list = ratatui::widgets::List::new(items).block(
ratatui::widgets::Block::default()
- .borders(ratatui::widgets::Borders::ALL)
- .border_style(theme.border_focus)
- .border_type(if state.basic_terminal {
- ratatui::widgets::BorderType::Plain
- } else {
- ratatui::widgets::BorderType::Rounded
- }),
+ .borders(ratatui::widgets::Borders::NONE),
);
frame.render_widget(list, dropdown_area);
}
diff --git a/src/tui/state.rs b/src/tui/state.rs
index 7ddbdd4..682ccb6 100644
--- a/src/tui/state.rs
+++ b/src/tui/state.rs
@@ -157,7 +157,9 @@ impl Default for AppState {
let is_windows = cfg!(target_os = "windows");
let is_dumb = term == "dumb" || term == "linux";
let is_apple_terminal = term_program == "Apple_Terminal";
- is_windows || is_dumb || is_apple_terminal
+ let is_tmux = std::env::var("TMUX").is_ok();
+ let is_ssh = std::env::var("SSH_TTY").is_ok() || std::env::var("SSH_CLIENT").is_ok();
+ is_windows || is_dumb || is_apple_terminal || is_tmux || is_ssh
},
selected_details: None,
active_subject_id: None,
@@ -186,16 +188,12 @@ impl Default for AppState {
image_supported: {
let term = std::env::var("TERM").unwrap_or_default();
let term_program = std::env::var("TERM_PROGRAM").unwrap_or_default();
- if term_program == "Apple_Terminal" || term == "dumb" {
+ if term_program == "Apple_Terminal" || term == "dumb" || term == "linux" {
+ false
+ } else if std::env::var("TMUX").is_ok() || std::env::var("SSH_TTY").is_ok() {
false
} else {
- std::env::var("KITTY_WINDOW_ID").is_ok()
- || term_program.to_lowercase() == "ghostty"
- || term_program.to_lowercase() == "wezterm"
- || std::env::var("WEZTERM_UNIX_SOCKET").is_ok()
- || std::env::var("WEZTERM_EXECUTABLE").is_ok()
- || std::env::var("ITERM_SESSION_ID").is_ok()
- || term == "xterm-kitty"
+ true // Let ratatui_image::picker::Picker query the terminal itself
}
},
poster_rows: 3,
@@ -235,7 +233,11 @@ impl Default for AppState {
pending_open_with: false,
username: std::env::var("USER")
.or_else(|_| std::env::var("USERNAME"))
- .unwrap_or_else(|_| "Friend".to_string()),
+ .unwrap_or_else(|_| "Friend".to_string())
+ .split('\\')
+ .last()
+ .unwrap_or("Friend")
+ .to_string(),
}
}
}