feat: add incomplete file suffix setting and per-file download progress

Add configurable suffix (e.g. .partial) appended to files while downloading,
stripped on completion — lets external tools distinguish incomplete files.
Add per-file progress bars to the torrent files table in the UI.
Auto-refresh Downloads file list when a torrent finishes.
Bump version to 1.0.9.

Author: OctopusTakopi

Cargo.lock

@@ -7,7 +7,7 @@ members = [
 
 [package]
 name = "cloud-torrent"
-version = "1.0.8"
+version = "1.0.9"
 edition = "2024"
 
 [dependencies]

Cargo.toml

@@ -144,6 +144,8 @@ pub struct Config {
     #[serde(alias = "rss_url", alias = "rssurl", alias = "RSSURL")]
     pub rss_url: String,
     pub allow_runtime_configure: bool,
+    #[serde(default)]
+    pub incomplete_suffix: String,
 }
 
 impl Default for Config {
@@ -177,6 +179,7 @@ impl Default for Config {
             scraper_url: "https://raw.githubusercontent.com/OctopusTakopi/cloud-torrent-rs/master/scraper-config.json".to_string(),
             rss_url: "".to_string(),
             allow_runtime_configure: true,
+            incomplete_suffix: String::new(),
         }
     }
 }

common/src/lib.rs

@@ -355,6 +355,20 @@ fn config_panel(props: &ConfigPanelProps) -> Html {
                     } />
                 </div>
 
+                <div class="field">
+                    <label><h5>{ "Incomplete File Suffix " } <span title="Append this suffix (e.g. .partial) to files while downloading. Removed when complete. Allows external tools to distinguish incomplete files."><i class="question circle icon"></i></span></h5></label>
+                    <input type="text" placeholder=".partial" value={c.incomplete_suffix.clone()} oninput={
+                        let config = config.clone();
+                        Callback::from(move |e: InputEvent| {
+                            let input: web_sys::HtmlInputElement = e.target_unchecked_into();
+                            if let Some(mut c) = (*config).clone() {
+                                c.incomplete_suffix = input.value();
+                                config.set(Some(c));
+                            }
+                        })
+                    } />
+                </div>
+
                 <div class="field">
                     <label><h5>{ "Scraper URL" }</h5></label>
                     <input type="text" value={c.scraper_url.clone()} oninput={
@@ -640,6 +654,21 @@ fn app() -> Html {
         })
     };
 
+    {
+        let finished_count = (*state)
+            .as_ref()
+            .map(|gs| gs.torrents.iter().filter(|t| t.is_seeding).count())
+            .unwrap_or(0);
+        let downloads_expanded = downloads_expanded.clone();
+        let refresh_files = refresh_files.clone();
+        use_effect_with(finished_count, move |_| {
+            if *downloads_expanded {
+                refresh_files.emit(());
+            }
+            || ()
+        });
+    }
+
     let fetch_rss = {
         let rss_loading = rss_loading.clone();
         let rss_state = rss_state.clone();
@@ -1485,14 +1514,26 @@ fn app() -> Html {
                                                     </div>
                                                     <table class="ui unstackable compact striped downloads table">
                                                         <thead>
-                                                            <tr><th>{ "File" }</th><th>{ "Size" }</th></tr>
+                                                            <tr><th>{ "File" }</th><th>{ "Size" }</th><th>{ "Progress" }</th></tr>
                                                         </thead>
                                                         <tbody>
-                                                            { for t.files.iter().map(|f| html! {
+                                                            { for t.files.iter().map(|f| {
+                                                                let pct = f.get("Percent").and_then(|v| v.as_f64()).unwrap_or(0.0);
+                                                                let downloaded = f.get("Downloaded").and_then(|v| v.as_u64()).unwrap_or(0);
+                                                                let size = f.get("Size").and_then(|v| v.as_u64()).unwrap_or(0);
+                                                                let is_done = pct >= 100.0;
+                                                                html! {
                                                                 <tr>
                                                                     <td>{ f.get("Path").and_then(|v| v.as_str()).unwrap_or("?") }</td>
-                                                                    <td>{ format_bytes(f.get("Size").and_then(|v| v.as_u64()).unwrap_or(0)) }</td>
+                                                                    <td class="right aligned collapsing">{ format_bytes(size) }</td>
+                                                                    <td class="collapsing" style="min-width: 140px;">
+                                                                        <div class={classes!("ui", "tiny", if is_done { "green" } else { "blue" }, "progress")} style="margin: 0; position: relative;" title={format!("{} / {}", format_bytes(downloaded), format_bytes(size))}>
+                                                                            <div class="bar" style={format!("width: {}%; min-width: 0;", if pct < 1.0 && pct > 0.0 { 1.0 } else { pct })}></div>
+                                                                            <div style="position: absolute; top: 0; left: 0; right: 0; text-align: center; font-size: 0.7em; line-height: 1.5em; color: rgba(0,0,0,0.7); pointer-events: none;">{ format!("{:.1}%", pct) }</div>
+                                                                        </div>
+                                                                    </td>
                                                                 </tr>
+                                                                }
                                                             }) }
                                                         </tbody>
                                                     </table>

frontend/src/main.rs

@@ -105,6 +105,16 @@ impl Engine {
             storage,
         };
 
+        // Strip incomplete suffix from files before restore so librqbit can find them
+        {
+            let state = engine.state.read().await;
+            let suffix = &state.config.incomplete_suffix;
+            if !suffix.is_empty() {
+                let dl_path = Path::new(&state.config.download_directory);
+                strip_incomplete_suffix_recursive(dl_path, suffix);
+            }
+        }
+
         // Background manager loop
         let engine_clone = engine.clone();
         tokio::spawn(async move {
@@ -119,6 +129,9 @@ impl Engine {
 
     async fn manager_loop(&self) {
         let mut interval = tokio::time::interval(std::time::Duration::from_secs(2));
+        // Tracks whether each torrent has had the incomplete suffix added (false) or
+        // stripped on completion (true). Absent = not yet handled.
+        let mut suffix_state: HashMap<String, bool> = HashMap::new();
         loop {
             interval.tick().await;
             let config = self.get_config().await;
@@ -176,6 +189,44 @@ impl Engine {
                     }
                 }
 
+                if !config.incomplete_suffix.is_empty() {
+                    let already_done = suffix_state.get(&info_hash).copied();
+                    let needs_action = match (stats.finished, already_done) {
+                        (true, Some(true)) => false,   // already stripped
+                        (false, Some(false)) => false,  // already suffixed
+                        _ => true,
+                    };
+                    if needs_action {
+                        let metadata_guard = h.metadata.load();
+                        if let Some(meta) = metadata_guard.as_ref() {
+                            let download_dir = Path::new(&config.download_directory);
+                            let output_dir = if meta.file_infos.len() >= 2 {
+                                let name = h.name().unwrap_or_else(|| info_hash.clone());
+                                download_dir.join(name)
+                            } else {
+                                download_dir.to_path_buf()
+                            };
+                            for f in &meta.file_infos {
+                                let rel = f.relative_filename.to_string_lossy();
+                                if stats.finished {
+                                    strip_incomplete_suffix(
+                                        &output_dir,
+                                        &rel,
+                                        &config.incomplete_suffix,
+                                    );
+                                } else {
+                                    add_incomplete_suffix(
+                                        &output_dir,
+                                        &rel,
+                                        &config.incomplete_suffix,
+                                    );
+                                }
+                            }
+                            suffix_state.insert(info_hash.clone(), stats.finished);
+                        }
+                    }
+                }
+
                 if !matches!(stats.state, TorrentStatsState::Paused) {
                     if let Some(remaining_bytes) = remaining_bytes {
                         if remaining_bytes > available_download_budget {
@@ -781,10 +832,19 @@ impl Engine {
                 let mut files = vec![];
                 let metadata_guard = h.metadata.load();
                 if let Some(meta) = metadata_guard.as_ref() {
-                    for f in &meta.file_infos {
+                    let file_progress = &stats.file_progress;
+                    for (i, f) in meta.file_infos.iter().enumerate() {
+                        let have_bytes = file_progress.get(i).copied().unwrap_or(0);
+                        let pct = if f.len > 0 {
+                            (have_bytes as f64 / f.len as f64) * 100.0
+                        } else {
+                            100.0
+                        };
                         files.push(serde_json::json!({
                             "Path": f.relative_filename.to_string_lossy(),
                             "Size": f.len,
+                            "Downloaded": have_bytes,
+                            "Percent": (pct * 10.0).round() / 10.0,
                         }));
                     }
                 }

src/engine/mod.rs

@@ -147,3 +147,66 @@ fn format_bytes_for_error(bytes: u64) -> String {
     }
     format!("{value:.2} {}", units[unit])
 }
+
+pub fn strip_incomplete_suffix_recursive(dir: &Path, suffix: &str) {
+    let Ok(entries) = std::fs::read_dir(dir) else {
+        return;
+    };
+    for entry in entries.flatten() {
+        let path = entry.path();
+        if path.is_dir() {
+            strip_incomplete_suffix_recursive(&path, suffix);
+        } else if let Some(name) = path.file_name().and_then(|n| n.to_str())
+            && let Some(base) = name.strip_suffix(suffix)
+        {
+            let dest = path.with_file_name(base);
+            if !dest.exists() {
+                if let Err(e) = std::fs::rename(&path, &dest) {
+                    tracing::error!(
+                        "Failed to strip incomplete suffix from {}: {}",
+                        path.display(),
+                        e
+                    );
+                } else {
+                    tracing::info!(
+                        "Stripped incomplete suffix: {} -> {}",
+                        path.display(),
+                        dest.display()
+                    );
+                }
+            }
+        }
+    }
+}
+
+pub fn add_incomplete_suffix(download_dir: &Path, relative_path: &str, suffix: &str) {
+    let src = download_dir.join(relative_path);
+    if src.exists() {
+        let dest_name = format!("{}{}", relative_path, suffix);
+        let dest = download_dir.join(&dest_name);
+        if !dest.exists()
+            && let Err(e) = std::fs::rename(&src, &dest)
+        {
+            tracing::error!(
+                "Failed to add incomplete suffix to {}: {}",
+                src.display(),
+                e
+            );
+        }
+    }
+}
+
+pub fn strip_incomplete_suffix(download_dir: &Path, relative_path: &str, suffix: &str) {
+    let suffixed_name = format!("{}{}", relative_path, suffix);
+    let src = download_dir.join(&suffixed_name);
+    if src.exists() {
+        let dest = download_dir.join(relative_path);
+        if let Err(e) = std::fs::rename(&src, &dest) {
+            tracing::error!(
+                "Failed to strip incomplete suffix from {}: {}",
+                src.display(),
+                e
+            );
+        }
+    }
+}