Add mirror suggestions feature with backend API and frontend UI

Co-authored-by: v0l <[email protected]>

Author: Copilot

Cargo.lock

@@ -36,13 +36,14 @@ sha2 = "0.10.8"
 sqlx = { version = "0.8.1", features = ["mysql", "runtime-tokio", "chrono", "uuid"] }
 config = { version = "0.15.7", features = ["yaml"] }
 chrono = { version = "0.4.38", features = ["serde"] }
-reqwest = { version = "0.12.8", features = ["stream", "http2"] }
+reqwest = { version = "0.12.8", features = ["stream", "http2", "json"] }
 clap = { version = "4.5.18", features = ["derive"] }
 mime2ext = "0.1.53"
 infer = "0.19.0"
 tokio-util = { version = "0.7.13", features = ["io", "io-util"] }
 http-range-header = { version = "0.4.2" }
 base58 = "0.2.0"
+url = "2.5.0"
 
 libc = { version = "0.2.153", optional = true }
 ffmpeg-rs-raw = { git = "https://git.v0l.io/Kieran/ffmpeg-rs-raw.git", rev = "aa1ce3edcad0fcd286d39b3e0c2fdc610c3988e7", optional = true }

Cargo.toml

@@ -5,18 +5,19 @@ use crate::routes::{delete_file, Nip94Event};
 use crate::settings::Settings;
 use log::error;
 use nostr::prelude::hex;
-use nostr::{Alphabet, JsonUtil, SingleLetterTag, TagKind};
+use nostr::{Alphabet, SingleLetterTag, TagKind};
 use rocket::data::ByteUnit;
 use rocket::futures::StreamExt;
 use rocket::http::{Header, Status};
 use rocket::response::Responder;
 use rocket::serde::json::Json;
 use rocket::{routes, Data, Request, Response, Route, State};
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
 use tokio::io::AsyncRead;
 use tokio_util::io::StreamReader;
 
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(crate = "rocket::serde")]
 pub struct BlobDescriptor {
     pub url: String,
@@ -55,6 +56,29 @@ struct MirrorRequest {
     pub url: String,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(crate = "rocket::serde")]
+pub struct MirrorSuggestionsRequest {
+    pub servers: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(crate = "rocket::serde")]
+pub struct FileMirrorSuggestion {
+    pub sha256: String,
+    pub url: String,
+    pub size: u64,
+    pub mime_type: Option<String>,
+    pub available_on: Vec<String>,
+    pub missing_from: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(crate = "rocket::serde")]
+pub struct MirrorSuggestionsResponse {
+    pub suggestions: Vec<FileMirrorSuggestion>,
+}
+
 #[cfg(feature = "media-compression")]
 pub fn blossom_routes() -> Vec<Route> {
     let mut routes = routes![
@@ -65,6 +89,7 @@ pub fn blossom_routes() -> Vec<Route> {
         upload_media,
         head_media,
         mirror,
+        mirror_suggestions,
     ];
 
     #[cfg(feature = "payments")]
@@ -83,6 +108,7 @@ pub fn blossom_routes() -> Vec<Route> {
         list_files,
         upload_head,
         mirror,
+        mirror_suggestions,
     ];
 
     #[cfg(feature = "payments")]
@@ -118,6 +144,9 @@ enum BlossomResponse {
 
     #[response(status = 200)]
     BlobDescriptorList(Json<Vec<BlobDescriptor>>),
+
+    #[response(status = 200)]
+    MirrorSuggestions(Json<MirrorSuggestionsResponse>),
 }
 
 impl BlossomResponse {
@@ -277,6 +306,77 @@ async fn mirror(
     .await
 }
 
+#[rocket::post("/mirror-suggestions", data = "<req>", format = "json")]
+async fn mirror_suggestions(
+    auth: BlossomAuth,
+    req: Json<MirrorSuggestionsRequest>,
+) -> BlossomResponse {
+    if !check_method(&auth.event, "mirror-suggestions") {
+        return BlossomResponse::error("Invalid request method tag");
+    }
+
+    let pubkey_hex = auth.event.pubkey.to_hex();
+    let mut file_map: HashMap<String, FileMirrorSuggestion> = HashMap::new();
+
+    // Fetch files from each server
+    for server_url in &req.servers {
+        if let Ok(_server_url_parsed) = url::Url::parse(server_url) {
+            let list_url = format!("{}/list/{}", server_url, pubkey_hex);
+            
+            match reqwest::get(&list_url).await {
+                Ok(response) => {
+                    if response.status().is_success() {
+                        match response.json::<Vec<BlobDescriptor>>().await {
+                            Ok(files) => {
+                                for file in files {
+                                    file_map
+                                        .entry(file.sha256.clone())
+                                        .and_modify(|suggestion| {
+                                            suggestion.available_on.push(server_url.clone());
+                                        })
+                                        .or_insert_with(|| FileMirrorSuggestion {
+                                            sha256: file.sha256.clone(),
+                                            url: file.url.clone(),
+                                            size: file.size,
+                                            mime_type: file.mime_type.clone(),
+                                            available_on: vec![server_url.clone()],
+                                            missing_from: Vec::new(),
+                                        });
+                                }
+                            }
+                            Err(e) => {
+                                error!("Failed to parse file list from {}: {}", server_url, e);
+                            }
+                        }
+                    }
+                }
+                Err(e) => {
+                    error!("Failed to fetch file list from {}: {}", server_url, e);
+                }
+            }
+        }
+    }
+
+    // Determine missing servers for each file
+    for suggestion in file_map.values_mut() {
+        for server_url in &req.servers {
+            if !suggestion.available_on.contains(server_url) {
+                suggestion.missing_from.push(server_url.clone());
+            }
+        }
+    }
+
+    // Filter to only files that are missing from at least one server and available on at least one
+    let filtered_suggestions: Vec<FileMirrorSuggestion> = file_map
+        .into_values()
+        .filter(|s| !s.missing_from.is_empty() && !s.available_on.is_empty())
+        .collect();
+
+    BlossomResponse::MirrorSuggestions(Json(MirrorSuggestionsResponse {
+        suggestions: filtered_suggestions,
+    }))
+}
+
 #[cfg(feature = "media-compression")]
 #[rocket::head("/media")]
 fn head_media(auth: BlossomAuth, settings: &State<Settings>) -> BlossomHead {

src/routes/blossom.rs

@@ -0,0 +1,184 @@
+import { useState, useEffect } from "react";
+import { FileMirrorSuggestion, Blossom } from "../upload/blossom";
+import { FormatBytes } from "../const";
+import Button from "./button";
+import usePublisher from "../hooks/publisher";
+
+interface MirrorSuggestionsProps {
+  servers: string[];
+  currentServer: string;
+}
+
+export default function MirrorSuggestions({ servers, currentServer }: MirrorSuggestionsProps) {
+  const [suggestions, setSuggestions] = useState<FileMirrorSuggestion[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string>();
+  const [mirroring, setMirroring] = useState<Set<string>>(new Set());
+
+  const pub = usePublisher();
+
+  useEffect(() => {
+    if (servers.length > 1 && pub) {
+      fetchSuggestions();
+    }
+  }, [servers, pub]);
+
+  async function fetchSuggestions() {
+    if (!pub) return;
+    
+    try {
+      setLoading(true);
+      setError(undefined);
+      
+      const blossom = new Blossom(currentServer, pub);
+      const result = await blossom.getMirrorSuggestions(servers);
+      setSuggestions(result.suggestions);
+    } catch (e) {
+      if (e instanceof Error) {
+        setError(e.message);
+      } else {
+        setError("Failed to fetch mirror suggestions");
+      }
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  async function mirrorFile(suggestion: FileMirrorSuggestion, targetServer: string) {
+    if (!pub) return;
+    
+    const mirrorKey = `${suggestion.sha256}-${targetServer}`;
+    setMirroring(prev => new Set(prev.add(mirrorKey)));
+    
+    try {
+      const blossom = new Blossom(targetServer, pub);
+      await blossom.mirror(suggestion.url);
+      
+      // Update suggestions by removing this server from missing_from
+      setSuggestions(prev => 
+        prev.map(s => 
+          s.sha256 === suggestion.sha256 
+            ? {
+                ...s,
+                available_on: [...s.available_on, targetServer],
+                missing_from: s.missing_from.filter(server => server !== targetServer)
+              }
+            : s
+        ).filter(s => s.missing_from.length > 0) // Remove suggestions with no missing servers
+      );
+    } catch (e) {
+      if (e instanceof Error) {
+        setError(`Failed to mirror file: ${e.message}`);
+      } else {
+        setError("Failed to mirror file");
+      }
+    } finally {
+      setMirroring(prev => {
+        const newSet = new Set(prev);
+        newSet.delete(mirrorKey);
+        return newSet;
+      });
+    }
+  }
+
+  if (servers.length <= 1) {
+    return null; // No suggestions needed for single server
+  }
+
+  if (loading) {
+    return (
+      <div className="card">
+        <h3 className="text-lg font-semibold mb-4">Mirror Suggestions</h3>
+        <p className="text-gray-400">Loading mirror suggestions...</p>
+      </div>
+    );
+  }
+
+  if (error) {
+    return (
+      <div className="card">
+        <h3 className="text-lg font-semibold mb-4">Mirror Suggestions</h3>
+        <div className="bg-red-900/20 border border-red-800 text-red-400 px-4 py-3 rounded-lg mb-4">
+          {error}
+        </div>
+        <Button onClick={fetchSuggestions} className="btn-secondary">
+          Retry
+        </Button>
+      </div>
+    );
+  }
+
+  if (suggestions.length === 0) {
+    return (
+      <div className="card">
+        <h3 className="text-lg font-semibold mb-4">Mirror Suggestions</h3>
+        <p className="text-gray-400">All your files are synchronized across all servers.</p>
+      </div>
+    );
+  }
+
+  return (
+    <div className="card">
+      <h3 className="text-lg font-semibold mb-4">Mirror Suggestions</h3>
+      <p className="text-gray-400 mb-6">
+        The following files are missing from some of your servers and can be mirrored:
+      </p>
+      
+      <div className="space-y-4">
+        {suggestions.map((suggestion) => (
+          <div key={suggestion.sha256} className="bg-gray-800 border border-gray-700 rounded-lg p-4">
+            <div className="flex items-start justify-between mb-3">
+              <div className="flex-1">
+                <p className="text-sm font-medium text-gray-300 mb-1">
+                  File: {suggestion.sha256.substring(0, 16)}...
+                </p>
+                <p className="text-xs text-gray-400">
+                  Size: {FormatBytes(suggestion.size)}
+                  {suggestion.mime_type && ` • Type: ${suggestion.mime_type}`}
+                </p>
+              </div>
+            </div>
+            
+            <div className="space-y-2">
+              <div>
+                <p className="text-xs text-green-400 mb-1">Available on:</p>
+                <div className="flex flex-wrap gap-1">
+                  {suggestion.available_on.map((server) => (
+                    <span key={server} className="text-xs bg-green-900/30 text-green-300 px-2 py-1 rounded">
+                      {new URL(server).hostname}
+                    </span>
+                  ))}
+                </div>
+              </div>
+              
+              <div>
+                <p className="text-xs text-red-400 mb-1">Missing from:</p>
+                <div className="flex flex-wrap gap-2">
+                  {suggestion.missing_from.map((server) => {
+                    const mirrorKey = `${suggestion.sha256}-${server}`;
+                    const isMirroring = mirroring.has(mirrorKey);
+                    
+                    return (
+                      <div key={server} className="flex items-center gap-2">
+                        <span className="text-xs bg-red-900/30 text-red-300 px-2 py-1 rounded">
+                          {new URL(server).hostname}
+                        </span>
+                        <Button
+                          onClick={() => mirrorFile(suggestion, server)}
+                          disabled={isMirroring}
+                          className="btn-primary text-xs py-1 px-2"
+                        >
+                          {isMirroring ? "Mirroring..." : "Mirror"}
+                        </Button>
+                      </div>
+                    );
+                  })}
+                </div>
+              </div>
+            </div>
+          </div>
+        ))}
+      </div>
+    </div>
+  );
+}