Merge main into spacedrive-data

Author: jamiepine

apps/tauri/src-tauri/src/main.rs

@@ -2004,6 +2004,14 @@ fn main() {
 
 			tracing::info!("Spacedrive Tauri app starting...");
 
+			// Apply Windows-specific window customizations (dark titlebar)
+			#[cfg(target_os = "windows")]
+			{
+				if let Some(window) = app.get_webview_window("main") {
+					crate::windows::apply_dark_titlebar_pub(&window);
+				}
+			}
+
 			// Apply macOS-specific window customizations
 			#[cfg(target_os = "macos")]
 			{

apps/tauri/src-tauri/src/windows.rs

@@ -390,6 +390,9 @@ impl SpacedriveWindow {
 					.build()
 					.map_err(|e| format!("Failed to create context menu: {}", e))?;
 
+				#[cfg(target_os = "windows")]
+				apply_dark_titlebar(&window);
+
 				Ok(window)
 			}
 		}
@@ -435,6 +438,10 @@ fn create_window(
 		.build()
 		.map_err(|e| format!("Failed to create window: {}", e))?;
 
+	// Windows: force dark titlebar + override accent color
+	#[cfg(target_os = "windows")]
+	apply_dark_titlebar(&window);
+
 	window.show().ok();
 	window.set_focus().ok();
 
@@ -616,3 +623,76 @@ pub async fn position_context_menu(
 
 	Ok(())
 }
+
+/// Apply dark titlebar on Windows using DWM API.
+///
+/// Sets both `DWMWA_USE_IMMERSIVE_DARK_MODE` (dark window chrome) and
+/// `DWMWA_CAPTION_COLOR` (explicit titlebar color) to override the user's
+/// Windows accent color setting which would otherwise tint the titlebar.
+#[cfg(target_os = "windows")]
+pub fn apply_dark_titlebar_pub(window: &WebviewWindow) {
+	apply_dark_titlebar(window);
+}
+
+#[cfg(target_os = "windows")]
+fn apply_dark_titlebar(window: &WebviewWindow) {
+	#[allow(non_snake_case)]
+	mod dwm {
+		// DWM attribute constants
+		pub const DWMWA_USE_IMMERSIVE_DARK_MODE: u32 = 20;
+		pub const DWMWA_CAPTION_COLOR: u32 = 35;
+		pub const DWMWA_BORDER_COLOR: u32 = 34;
+
+		extern "system" {
+			pub fn DwmSetWindowAttribute(
+				hwnd: isize,
+				attr: u32,
+				value: *const std::ffi::c_void,
+				size: u32,
+			) -> i32;
+		}
+	}
+
+	let Ok(hwnd) = window.hwnd() else {
+		tracing::warn!("Failed to get HWND for dark titlebar");
+		return;
+	};
+	let hwnd = hwnd.0 as isize;
+
+	unsafe {
+		let set_attr =
+			|attr: u32, value: *const std::ffi::c_void, size: u32, name: &'static str| {
+				let hr = dwm::DwmSetWindowAttribute(hwnd, attr, value, size);
+				if hr < 0 {
+					tracing::warn!(attribute = name, hr, "Failed to apply DWM window attribute");
+				}
+			};
+
+		// Enable immersive dark mode (dark close/minimize/maximize icons)
+		let dark_mode: i32 = 1;
+		set_attr(
+			dwm::DWMWA_USE_IMMERSIVE_DARK_MODE,
+			&dark_mode as *const _ as *const std::ffi::c_void,
+			std::mem::size_of::<i32>() as u32,
+			"DWMWA_USE_IMMERSIVE_DARK_MODE",
+		);
+
+		// Force caption color to dark gray — overrides user's accent color
+		// COLORREF format is 0x00BBGGRR
+		let caption_color: u32 = 0x00_1E_1E_1E; // #1E1E1E in BGR
+		set_attr(
+			dwm::DWMWA_CAPTION_COLOR,
+			&caption_color as *const _ as *const std::ffi::c_void,
+			std::mem::size_of::<u32>() as u32,
+			"DWMWA_CAPTION_COLOR",
+		);
+
+		// Match border color to caption
+		set_attr(
+			dwm::DWMWA_BORDER_COLOR,
+			&caption_color as *const _ as *const std::ffi::c_void,
+			std::mem::size_of::<u32>() as u32,
+			"DWMWA_BORDER_COLOR",
+		);
+	}
+}

core/src/common/utils.rs

@@ -3,3 +3,41 @@
 // Note: Device ID management has been moved to device::manager for better
 // module organization. Import from there instead:
 // use crate::device::manager::{get_current_device_id, set_current_device_id};
+
+/// Strip Windows extended path prefixes produced by `std::fs::canonicalize()`.
+///
+/// On Windows, `canonicalize()` returns paths like `\\?\C:\...` (local) or
+/// `\\?\UNC\server\share\...` (network). These prefixes break `starts_with()`
+/// matching throughout the codebase and must be normalized.
+///
+/// - `\\?\UNC\server\share\...` → `\\server\share\...`
+/// - `\\?\C:\...` → `C:\...`
+/// - All other paths are returned unchanged.
+#[cfg(windows)]
+pub fn strip_windows_extended_prefix(path: std::path::PathBuf) -> std::path::PathBuf {
+	if let Some(s) = path.to_str() {
+		if s.starts_with(r"\\?\UNC\") {
+			// \\?\UNC\server\share\... → \\server\share\...
+			std::path::PathBuf::from(format!(r"\\{}", &s[8..]))
+		} else if let Some(stripped) = s.strip_prefix(r"\\?\") {
+			// Only strip \\?\ when followed by a drive letter (e.g. C:\).
+			// Leave volume GUIDs (\\?\Volume{...}\) and other verbatim
+			// forms untouched — they are invalid without the prefix.
+			if stripped.as_bytes().get(1) == Some(&b':') {
+				std::path::PathBuf::from(stripped)
+			} else {
+				path
+			}
+		} else {
+			path
+		}
+	} else {
+		path
+	}
+}
+
+/// No-op on non-Windows platforms.
+#[cfg(not(windows))]
+pub fn strip_windows_extended_prefix(path: std::path::PathBuf) -> std::path::PathBuf {
+	path
+}

core/src/domain/addressing.rs

@@ -682,7 +682,82 @@ impl SdPath {
 			Self::Physical { .. } => Ok(self.clone()),
 			Self::Cloud { .. } => Ok(self.clone()), // Cloud paths are already resolved
 			Self::Content { content_id } => {
-				// In the future, use job_ctx.library_db() to query for content instances
+				use sea_orm::{ColumnTrait, EntityTrait, ModelTrait, QueryFilter};
+				use crate::infra::db::entities::{
+					content_identity, device, location, ContentIdentity, Device, DirectoryPaths,
+					Entry, Location,
+				};
+
+				let db = job_ctx.library_db();
+				let current_device_id = get_current_device_id();
+				let current_device_slug = get_current_device_slug();
+
+				let ci = ContentIdentity::find()
+					.filter(content_identity::Column::Uuid.eq(Some(*content_id)))
+					.one(db)
+					.await
+					.map_err(|e| PathResolutionError::DatabaseError(e.to_string()))?
+					.ok_or(PathResolutionError::NoOnlineInstancesFound(*content_id))?;
+
+				let entries = Entry::find()
+					.filter(
+						crate::infra::db::entities::entry::Column::ContentId
+							.eq(Some(ci.id)),
+					)
+					.all(db)
+					.await
+					.map_err(|e| PathResolutionError::DatabaseError(e.to_string()))?;
+
+				for entry in entries {
+					let loc = Location::find()
+						.filter(location::Column::EntryId.eq(entry.id))
+						.one(db)
+						.await
+						.map_err(|e| PathResolutionError::DatabaseError(e.to_string()))?;
+
+					if let Some(loc) = loc {
+						let dev = Device::find_by_id(loc.device_id)
+							.one(db)
+							.await
+							.map_err(|e| PathResolutionError::DatabaseError(e.to_string()))?;
+
+						if dev.map(|d| d.uuid) == Some(current_device_id) {
+							// Build path from directory_paths cache
+							let path = if let Some(parent_id) = entry.parent_id {
+								let parent = DirectoryPaths::find_by_id(parent_id)
+									.one(db)
+									.await
+									.map_err(|e| {
+										PathResolutionError::DatabaseError(e.to_string())
+									})?
+									.ok_or_else(|| {
+										PathResolutionError::DatabaseError(format!(
+											"Parent path not found for entry {}",
+											entry.id
+										))
+									})?;
+								let filename = match &entry.extension {
+									Some(ext) => format!("{}.{}", entry.name, ext),
+									None => entry.name.clone(),
+								};
+								std::path::PathBuf::from(parent.path).join(filename)
+							} else {
+								return Err(PathResolutionError::DatabaseError(
+									format!(
+										"Entry {} has no parent_id, cannot build absolute path",
+										entry.id
+									),
+								));
+							};
+
+							return Ok(SdPath::Physical {
+								device_slug: current_device_slug,
+								path,
+							});
+						}
+					}
+				}
+
 				Err(PathResolutionError::NoOnlineInstancesFound(*content_id))
 			}
 			Self::Sidecar { content_id, .. } => {

core/src/location/manager.rs

@@ -46,6 +46,30 @@ impl LocationManager {
 		job_policies: Option<String>,
 		volume_manager: &crate::volume::VolumeManager,
 	) -> LocationResult<(Uuid, String)> {
+		// Canonicalize local physical paths to absolute form before storing.
+		// Relative paths break the watcher, volume resolution, and indexer.
+		// Only for local device — remote paths can't be resolved locally.
+		let sd_path = if sd_path.is_local() {
+			if let crate::domain::addressing::SdPath::Physical { device_slug, path } = sd_path {
+				let canonical = tokio::fs::canonicalize(&path).await.map_err(|e| {
+					LocationError::InvalidPath(format!(
+						"Failed to resolve path {}: {}",
+						path.display(),
+						e
+					))
+				})?;
+				let canonical = crate::common::utils::strip_windows_extended_prefix(canonical);
+				crate::domain::addressing::SdPath::Physical {
+					device_slug,
+					path: canonical,
+				}
+			} else {
+				sd_path
+			}
+		} else {
+			sd_path
+		};
+
 		info!("Adding location: {}", sd_path);
 
 		// Validate the path based on type

core/src/ops/addressing.rs

@@ -37,7 +37,9 @@ impl PathResolver {
 			// Cloud paths are already resolved (no additional resolution needed)
 			SdPath::Cloud { .. } => Ok(path.clone()),
 			// If content-based, find the optimal physical path
-			SdPath::Content { content_id } => unimplemented!(),
+			SdPath::Content { content_id } => {
+				Err(PathResolutionError::NoOnlineInstancesFound(*content_id))
+			}
 			// Sidecar paths need to be resolved to physical locations
 			SdPath::Sidecar {
 				content_id,

core/src/ops/files/delete/job.rs

@@ -1,6 +1,9 @@
 //! Delete job implementation
 
-use crate::{domain::addressing::SdPathBatch, infra::job::prelude::*};
+use crate::{
+	domain::addressing::SdPathBatch,
+	infra::job::{generic_progress::GenericProgress, prelude::*},
+};
 use serde::{Deserialize, Serialize};
 use std::{
 	path::PathBuf,
@@ -51,19 +54,6 @@ pub struct DeleteJob {
 	started_at: Instant,
 }
 
-/// Delete progress information
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct DeleteProgress {
-	pub current_file: String,
-	pub files_deleted: usize,
-	pub total_files: usize,
-	pub bytes_deleted: u64,
-	pub total_bytes: u64,
-	pub current_operation: String,
-	pub estimated_remaining: Option<Duration>,
-}
-
-impl JobProgress for DeleteProgress {}
 
 impl Job for DeleteJob {
 	const NAME: &'static str = "delete_files";
@@ -84,14 +74,21 @@ impl JobHandler for DeleteJob {
 	type Output = DeleteOutput;
 
 	async fn run(&mut self, ctx: JobContext<'_>) -> JobResult<Self::Output> {
+		let total_files = self.targets.paths.len();
+		let mode_str = match self.mode {
+			DeleteMode::Trash => "trash",
+			DeleteMode::Permanent => "permanent",
+			DeleteMode::Secure => "secure",
+		};
+
 		ctx.log(format!(
 			"Starting {} deletion of {} files",
-			match self.mode {
-				DeleteMode::Trash => "trash",
-				DeleteMode::Permanent => "permanent",
-				DeleteMode::Secure => "secure",
-			},
-			self.targets.paths.len()
+			mode_str, total_files
+		));
+
+		// Phase: Preparing
+		ctx.progress(Progress::Indeterminate(
+			format!("Validating {} targets", total_files),
 		));
 
 		// Safety check for permanent deletion
@@ -106,6 +103,20 @@ impl JobHandler for DeleteJob {
 		// Validate targets exist (only for local paths)
 		self.validate_targets(&ctx).await?;
 
+		// Phase: Resolving paths
+		ctx.progress(Progress::Indeterminate("Resolving paths".to_string()));
+
+		// Resolve Content paths to Physical paths before strategy selection
+		let mut resolved = Vec::with_capacity(self.targets.paths.len());
+		for path in &self.targets.paths {
+			resolved.push(
+				path.resolve_in_job(&ctx)
+					.await
+					.map_err(|e| JobError::execution(format!("Failed to resolve path: {e}")))?,
+			);
+		}
+		self.targets = SdPathBatch::new(resolved);
+
 		// Select strategy based on path topology
 		let volume_manager = ctx.volume_manager();
 		let strategy =
@@ -116,6 +127,11 @@ impl JobHandler for DeleteJob {
 			DeleteStrategyRouter::describe_strategy(&self.targets.paths).await;
 		ctx.log(format!("Using strategy: {}", strategy_description));
 
+		// Phase: Deleting
+		ctx.progress(Progress::Indeterminate(
+			format!("Deleting {} files ({})", total_files, mode_str),
+		));
+
 		// Execute deletion using selected strategy
 		let results = strategy
 			.execute(&ctx, &self.targets.paths, self.mode.clone())
@@ -140,6 +156,19 @@ impl JobHandler for DeleteJob {
 			})
 			.collect();
 
+		// Phase: Complete
+		ctx.progress(Progress::Generic(
+			GenericProgress::new(
+				1.0,
+				"Complete",
+				format!("{} deleted, {} failed", deleted_count, failed_count),
+			)
+			.with_completion(total_files as u64, total_files as u64)
+			.with_bytes(total_bytes, total_bytes)
+			.with_performance(0.0, None, Some(self.started_at.elapsed()))
+			.with_errors(failed_count as u64, 0),
+		));
+
 		ctx.log(format!(
 			"Delete operation completed: {} deleted, {} failed",
 			deleted_count, failed_count