fix: align packaged cli integration cleanup

Author: TrueNine

cli/integrate-tests/src/lib.rs

@@ -575,7 +575,7 @@ pub fn pack_cli_artifacts() -> Option<PackedArtifacts> {
 
   eprintln!("[tnmsc-integrate-tests] running assemble-npm...");
   let assemble = run_tnmsc_with_env(
-    &["assemble-npm"],
+    &["assemble-npm", "--profile", "debug"],
     &workspace_root(),
     &[
       ("TNMSC_NPM_PACKAGE_ROOT", package_root.as_str()),
@@ -629,7 +629,7 @@ pub fn pack_cli_artifacts() -> Option<PackedArtifacts> {
       );
 
       let assemble_cross = run_tnmsc_with_env(
-        &["assemble-npm"],
+        &["assemble-npm", "--profile", "debug"],
         &workspace_root(),
         &[
           ("TNMSC_NPM_PACKAGE_ROOT", package_root.as_str()),

sdk/src/infra/desk_paths.rs

@@ -215,38 +215,80 @@ pub fn delete_path_sync<P: AsRef<Path>>(path: P) -> io::Result<()> {
   delete_path(path).map(|_| ())
 }
 
+#[cfg(windows)]
+fn strip_windows_extended_prefix(path: &Path) -> Option<PathBuf> {
+  let raw = path.to_string_lossy();
+
+  if let Some(stripped) = raw.strip_prefix(r"\\?\UNC\") {
+    return Some(PathBuf::from(format!(r"\\{}", stripped.replace('/', "\\"))));
+  }
+
+  if let Some(stripped) = raw.strip_prefix(r"\\?\") {
+    return Some(PathBuf::from(stripped.replace('/', "\\")));
+  }
+
+  if let Some(stripped) = raw.strip_prefix("//?/UNC/") {
+    return Some(PathBuf::from(format!(r"\\{}", stripped.replace('/', "\\"))));
+  }
+
+  if let Some(stripped) = raw.strip_prefix("//?/") {
+    return Some(PathBuf::from(stripped.replace('/', "\\")));
+  }
+
+  None
+}
+
+fn resolve_delete_path(path: &Path) -> io::Result<Option<(PathBuf, fs::Metadata)>> {
+  match fs::symlink_metadata(path) {
+    Ok(metadata) => Ok(Some((path.to_path_buf(), metadata))),
+    Err(err) if err.kind() == io::ErrorKind::NotFound => {
+      #[cfg(windows)]
+      if let Some(fallback) = strip_windows_extended_prefix(path)
+        && fallback != path
+      {
+        return match fs::symlink_metadata(&fallback) {
+          Ok(metadata) => Ok(Some((fallback, metadata))),
+          Err(fallback_err) if fallback_err.kind() == io::ErrorKind::NotFound => Ok(None),
+          Err(fallback_err) => Err(fallback_err),
+        };
+      }
+
+      Ok(None)
+    }
+    Err(err) => Err(err),
+  }
+}
+
 fn delete_path(path: impl AsRef<Path>) -> io::Result<bool> {
-  let path = path.as_ref();
-  let metadata = match fs::symlink_metadata(path) {
-    Ok(metadata) => metadata,
-    Err(err) if err.kind() == io::ErrorKind::NotFound => return Ok(false),
-    Err(err) => return Err(err),
+  let (path, metadata) = match resolve_delete_path(path.as_ref())? {
+    Some(resolved) => resolved,
+    None => return Ok(false),
   };
 
   if metadata.file_type().is_symlink() {
     #[cfg(windows)]
     {
-      return fs::metadata(path)
+      return fs::metadata(&path)
         .map(|resolved| resolved.is_dir())
         .unwrap_or(false)
-        .then(|| fs::remove_dir(path).or_else(|_| fs::remove_file(path)))
-        .unwrap_or_else(|| fs::remove_file(path).or_else(|_| fs::remove_dir(path)))
+        .then(|| fs::remove_dir(&path).or_else(|_| fs::remove_file(&path)))
+        .unwrap_or_else(|| fs::remove_file(&path).or_else(|_| fs::remove_dir(&path)))
         .map(|_| true);
     }
     #[cfg(not(windows))]
     {
-      return fs::remove_file(path).map(|_| true);
+      return fs::remove_file(&path).map(|_| true);
     }
   }
 
   if metadata.is_dir() {
-    match fs::remove_dir_all(path) {
+    match fs::remove_dir_all(&path) {
       Ok(()) => Ok(true),
       Err(err) if err.kind() == io::ErrorKind::NotFound => Ok(false),
       Err(err) => Err(err),
     }
   } else {
-    match fs::remove_file(path) {
+    match fs::remove_file(&path) {
       Ok(()) => Ok(true),
       Err(err) if err.kind() == io::ErrorKind::NotFound => Ok(false),
       Err(err) => Err(err),
@@ -293,18 +335,16 @@ pub struct DeleteTargetsResult {
 }
 
 fn delete_empty_directory(path: impl AsRef<Path>) -> io::Result<bool> {
-  let path = path.as_ref();
-  let metadata = match fs::symlink_metadata(path) {
-    Ok(metadata) => metadata,
-    Err(err) if err.kind() == io::ErrorKind::NotFound => return Ok(false),
-    Err(err) => return Err(err),
+  let (path, metadata) = match resolve_delete_path(path.as_ref())? {
+    Some(resolved) => resolved,
+    None => return Ok(false),
   };
 
   if metadata.file_type().is_symlink() || !metadata.is_dir() {
     return Ok(false);
   }
 
-  match fs::remove_dir(path) {
+  match fs::remove_dir(&path) {
     Ok(()) => Ok(true),
     Err(err)
       if err.kind() == io::ErrorKind::NotFound
@@ -708,6 +748,36 @@ mod tests {
     assert!(target_dir.exists());
   }
 
+  #[cfg(windows)]
+  #[test]
+  fn delete_files_handles_windows_extended_prefix_paths() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("artifact.txt");
+    fs::write(&file, b"data").unwrap();
+
+    let extended = format!(r"\\?\{}", file.display());
+    let result = delete_files(&[extended]);
+
+    assert_eq!(result.deleted, 1);
+    assert!(result.errors.is_empty());
+    assert!(!file.exists());
+  }
+
+  #[cfg(windows)]
+  #[test]
+  fn delete_files_handles_windows_slash_extended_prefix_paths() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("artifact.txt");
+    fs::write(&file, b"data").unwrap();
+
+    let slash_extended = format!("//?/{}", file.display().to_string().replace('\\', "/"));
+    let result = delete_files(&[slash_extended]);
+
+    assert_eq!(result.deleted, 1);
+    assert!(result.errors.is_empty());
+    assert!(!file.exists());
+  }
+
   #[test]
   fn compact_deletion_targets_removes_covered_paths() {
     let dir = tempdir().unwrap();

sdk/src/services/clean_service.rs

@@ -73,26 +73,58 @@ pub fn clean(options: MemorySyncCommandOptions) -> Result<MemorySyncCommandResul
   } else {
     let result =
       crate::policy::cleanup::perform_cleanup(snapshot).map_err(|e| CliError::ExecutionError(e))?;
+    let blocked = !result.violations.is_empty() || !result.conflicts.is_empty();
+    let success = !blocked && result.errors.is_empty();
+    let mut warnings = result
+      .violations
+      .iter()
+      .map(|v| {
+        json!({
+          "type": "violation",
+          "target": v.target_path,
+          "protected": v.protected_path,
+          "reason": v.reason
+        })
+      })
+      .collect::<Vec<_>>();
+    let mut errors = result
+      .conflicts
+      .iter()
+      .map(|c| {
+        json!({
+          "type": "conflict",
+          "output": c.output_path,
+          "protected": c.protected_path,
+          "reason": c.reason
+        })
+      })
+      .collect::<Vec<_>>();
+    errors.extend(result.errors.iter().map(|e| {
+      json!({
+        "path": e.path,
+        "kind": format!("{:?}", e.kind),
+        "error": e.error
+      })
+    }));
+
     Ok(MemorySyncCommandResult {
-      success: result.errors.is_empty(),
+      success,
       files_affected: result.deleted_files as i32,
       dirs_affected: result.deleted_dirs as i32,
-      message: Some(format!(
-        "Deleted {} files and {} directories",
-        result.deleted_files, result.deleted_dirs
-      )),
-      warnings: Vec::new(),
-      errors: result
-        .errors
-        .iter()
-        .map(|e| {
-          json!({
-            "path": e.path,
-            "kind": format!("{:?}", e.kind),
-            "error": e.error
-          })
-        })
-        .collect(),
+      message: Some(if blocked {
+        format!(
+          "Cleanup blocked: {} conflicts, {} violations",
+          result.conflicts.len(),
+          result.violations.len()
+        )
+      } else {
+        format!(
+          "Deleted {} files and {} directories",
+          result.deleted_files, result.deleted_dirs
+        )
+      }),
+      warnings: std::mem::take(&mut warnings),
+      errors,
     })
   }
 }