treewide: better cross-device sync capabilities; in-database storage

Signed-off-by: NotAShelf <raf@notashelf.dev>
Change-Id: Id99798df6f7e4470caae8a193c2654aa6a6a6964

crates/pinakes-server/src/main.rs

@@ -45,17 +45,20 @@ struct Cli {
     migrate_only: bool,
 }
 
-fn resolve_config_path(explicit: Option<&std::path::Path>) -> PathBuf {
+/// Resolve the configuration file path.
+/// Returns (path, was_explicit) where was_explicit indicates if the path was
+/// explicitly provided by the user (vs discovered).
+fn resolve_config_path(explicit: Option<&std::path::Path>) -> (PathBuf, bool) {
     if let Some(path) = explicit {
-        return path.to_path_buf();
+        return (path.to_path_buf(), true);
     }
     // Check current directory
     let local = PathBuf::from("pinakes.toml");
     if local.exists() {
-        return local;
+        return (local, false);
     }
     // XDG default
-    Config::default_config_path()
+    (Config::default_config_path(), false)
 }
 
 #[tokio::main]
@@ -89,11 +92,17 @@ async fn main() -> Result<()> {
         }
     }
 
-    let config_path = resolve_config_path(cli.config.as_deref());
+    let (config_path, was_explicit) = resolve_config_path(cli.config.as_deref());
 
     let mut config = if config_path.exists() {
         info!(path = %config_path.display(), "loading configuration from file");
         Config::from_file(&config_path)?
+    } else if was_explicit {
+        // User explicitly provided a config path that doesn't exist - this is an error
+        return Err(anyhow::anyhow!(
+            "configuration file not found: {}",
+            config_path.display()
+        ));
     } else {
         info!(
             "using default configuration (no config file found at {})",
@@ -486,6 +495,34 @@ async fn main() -> Result<()> {
         });
     }
 
+    // Initialize managed storage service if enabled
+    let managed_storage = {
+        let config_read = config_arc.read().await;
+        if config_read.managed_storage.enabled {
+            let service = pinakes_core::managed_storage::ManagedStorageService::new(
+                config_read.managed_storage.storage_dir.clone(),
+                config_read.managed_storage.max_upload_size,
+                config_read.managed_storage.verify_on_read,
+            );
+            match service.init().await {
+                Ok(()) => {
+                    info!(
+                        path = %config_read.managed_storage.storage_dir.display(),
+                        "managed storage initialized"
+                    );
+                    Some(Arc::new(service))
+                }
+                Err(e) => {
+                    tracing::error!(error = %e, "failed to initialize managed storage");
+                    None
+                }
+            }
+        } else {
+            tracing::info!("managed storage disabled in configuration");
+            None
+        }
+    };
+
     let state = AppState {
         storage: storage.clone(),
         config: config_arc.clone(),
@@ -496,6 +533,7 @@ async fn main() -> Result<()> {
         scheduler,
         plugin_manager,
         transcode_service,
+        managed_storage,
     };
 
     // Periodic session cleanup (every 15 minutes)