support output-folder option for git-related features

Repository-based logic seems to automatically be made relative to the top-level path the repo was initialised with, so we can actually support an output folder with no issues here

Cargo.toml

@@ -1,7 +1,7 @@
 workspace = { members = ["rbx_asset", "rox_compiler"] }
 [package]
 name = "asset-tool"
-version = "0.4.4"
+version = "0.4.6"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

README.md

@@ -2,4 +2,20 @@
 
 [![Build Status](https://ci.itzana.me/api/badges/StrafesNET/asset-tool/status.svg?ref=refs/heads/master)](https://ci.itzana.me/StrafesNET/asset-tool)
 
-For uploading and downloading roblox assets.
+For uploading and downloading roblox assets.
+
+See [releases](https://git.itzana.me/StrafesNET/asset-tool/releases) for downloads.
+
+To get started, you will need an api key and/or cookie depending on which command you use.  Api keys can be created from the open cloud section on the creator hub, cookies must be extracted from a browser session.  Do not share your cookie file with anyone or use it with tools that you do not trust, as it gives unrestricted permissions to do any account actions on your behalf.  The api keys are significantly more safe because you can choose exactly what permissions the given key has, and which ip addresses can use it.
+
+The help text lists available commands:
+
+`asset-tool --help`
+
+For help with a specific command:
+
+`asset-tool download --help`
+
+Example incantation to download a list of models:
+
+`asset-tool download --cookie-file Documents\mycookie.txt 255299419 1213190363`

rbx_asset/src/cloud.rs

@@ -14,26 +14,27 @@ pub struct CreateAssetRequest{
 	pub displayName:String,
 }
 #[derive(Debug)]
-pub enum CreateAssetResponseGetAssetError{
+pub enum AssetOperationError{
 	Operation(OperationError),
 	Serialize(serde_json::Error),
 }
-impl std::fmt::Display for CreateAssetResponseGetAssetError{
+impl std::fmt::Display for AssetOperationError{
 	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
 		write!(f,"{self:?}")
 	}
 }
-impl std::error::Error for CreateAssetResponseGetAssetError{}
+impl std::error::Error for AssetOperationError{}
-pub struct CreateAssetResponse{
+#[derive(Debug)]
+pub struct AssetOperation{
 	operation:RobloxOperation,
 }
-impl CreateAssetResponse{
+impl AssetOperation{
-	pub async fn try_get_asset(&self,context:&CloudContext)->Result<AssetResponse,CreateAssetResponseGetAssetError>{
+	pub async fn try_get_asset(&self,context:&CloudContext)->Result<AssetResponse,AssetOperationError>{
 		serde_json::from_value(
 			self.operation
 				.try_get_reponse(context).await
-				.map_err(CreateAssetResponseGetAssetError::Operation)?
+				.map_err(AssetOperationError::Operation)?
-		).map_err(CreateAssetResponseGetAssetError::Serialize)
+		).map_err(AssetOperationError::Serialize)
 	}
 }
 #[derive(Debug)]
@@ -111,8 +112,8 @@ impl std::fmt::Display for UpdateError{
 }
 impl std::error::Error for UpdateError{}
 
-pub struct GetAssetOperationRequest{
+struct GetAssetOperationRequest{
-	pub operation_id:String,
+	operation_id:String,
 }
 pub struct GetAssetInfoRequest{
 	pub asset_id:u64,
@@ -260,7 +261,7 @@ impl std::fmt::Display for OperationError{
 impl std::error::Error for OperationError{}
 #[derive(Debug,serde::Deserialize,serde::Serialize)]
 #[allow(nonstandard_style,dead_code)]
-pub struct RobloxOperation{
+struct RobloxOperation{
 	pub path:Option<String>,
 	pub metadata:Option<String>,
 	pub done:Option<bool>,
@@ -354,7 +355,7 @@ impl CloudContext{
 		.multipart(form)
 		.send().await
 	}
-	pub async fn create_asset(&self,config:CreateAssetRequest,body:impl Into<std::borrow::Cow<'static,[u8]>>)->Result<CreateAssetResponse,CreateError>{
+	pub async fn create_asset(&self,config:CreateAssetRequest,body:impl Into<std::borrow::Cow<'static,[u8]>>)->Result<AssetOperation,CreateError>{
 		let url=reqwest::Url::parse("https://apis.roblox.com/assets/v1/assets").map_err(CreateError::Parse)?;
 
 		let request_config=serde_json::to_string(&config).map_err(CreateError::Serialize)?;
@@ -367,15 +368,16 @@ impl CloudContext{
 		.text("request",request_config)
 		.part("fileContent",part);
 
-		let operation=self.post_form(url,form).await.map_err(CreateError::Reqwest)?
+		let operation=self.post_form(url,form).await
+		.map_err(CreateError::Reqwest)?
 		.error_for_status().map_err(CreateError::Reqwest)?
 		.json::<RobloxOperation>().await.map_err(CreateError::Reqwest)?;
 
-		Ok(CreateAssetResponse{
+		Ok(AssetOperation{
 			operation,
 		})
 	}
-	pub async fn update_asset(&self,config:UpdateAssetRequest,body:impl Into<std::borrow::Cow<'static,[u8]>>)->Result<RobloxOperation,UpdateError>{
+	pub async fn update_asset(&self,config:UpdateAssetRequest,body:impl Into<std::borrow::Cow<'static,[u8]>>)->Result<AssetOperation,UpdateError>{
 		let raw_url=format!("https://apis.roblox.com/assets/v1/assets/{}",config.assetId);
 		let url=reqwest::Url::parse(raw_url.as_str()).map_err(UpdateError::ParseError)?;
 
@@ -385,13 +387,17 @@ impl CloudContext{
 		.text("request",request_config)
 		.part("fileContent",reqwest::multipart::Part::bytes(body));
 
-		self.patch_form(url,form).await
+		let operation=self.patch_form(url,form).await
 		.map_err(UpdateError::Reqwest)?
 		//roblox api documentation is very poor, just give the status code and drop the json
 		.error_for_status().map_err(UpdateError::Reqwest)?
-		.json::<RobloxOperation>().await.map_err(UpdateError::Reqwest)
+		.json::<RobloxOperation>().await.map_err(UpdateError::Reqwest)?;
+
+		Ok(AssetOperation{
+			operation,
+		})
 	}
-	pub async fn get_asset_operation(&self,config:GetAssetOperationRequest)->Result<RobloxOperation,GetError>{
+	async fn get_asset_operation(&self,config:GetAssetOperationRequest)->Result<RobloxOperation,GetError>{
 		let raw_url=format!("https://apis.roblox.com/assets/v1/operations/{}",config.operation_id);
 		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::ParseError)?;
 

rox_compiler/src/decompile.rs

@@ -234,7 +234,7 @@ impl DecompiledContext{
 				WriteStackInstruction::Node(node,name_count)=>{
 					//track properties that must be overriden to compile folder structure back into a place file
 					let mut properties=PropertiesOverride::default();
-					let has_children=node.children.is_empty();
+					let has_children=!node.children.is_empty();
 					match node.class{
 						Class::Folder=>(),
 						Class::ModuleScript=>(),//.lua files are ModuleScript by default

src/main.rs

@@ -38,6 +38,7 @@ enum Commands{
 	DownloadAndDecompileHistoryIntoGit(DownloadAndDecompileHistoryIntoGitSubcommand),
 }
 
+/// Download a range of assets from the asset version history.  Download summary is saved to `output_folder/versions.json`, and can be optionally used to download only new versions the next time.
 #[derive(Args)]
 struct DownloadHistorySubcommand{
 	#[arg(long)]
@@ -57,6 +58,7 @@ struct DownloadHistorySubcommand{
 	#[arg(long)]
 	end_version:Option<u64>,
 }
+/// Download a single asset by id.
 #[derive(Args)]
 struct DownloadSubcommand{
 	#[arg(long,group="cookie",required=true)]
@@ -70,6 +72,7 @@ struct DownloadSubcommand{
 	#[arg(required=true)]
 	asset_ids:Vec<AssetID>,
 }
+/// Download the list of asset ids (not the assets themselves) in a group inventory.  The output is written to `output_folder/versions.json`
 #[derive(Args)]
 struct DownloadGroupInventoryJsonSubcommand{
 	#[arg(long,group="cookie",required=true)]
@@ -83,6 +86,7 @@ struct DownloadGroupInventoryJsonSubcommand{
 	#[arg(long)]
 	group:u64,
 }
+/// Upload a (.rbxm, .rbxmx) model file, creating a new asset.  Can be any type of model, including modulescripts.
 #[derive(Args)]
 struct CreateAssetSubcommand{
 	#[arg(long,group="cookie",required=true)]
@@ -104,6 +108,7 @@ struct CreateAssetSubcommand{
 	#[arg(long)]
 	allow_comments:Option<bool>,
 }
+/// Upload a media file (.jpg, .png) to a new asset and print the asset id
 #[derive(Args)]
 struct CreateAssetMediaSubcommand{
 	#[arg(long,group="api_key",required=true)]
@@ -128,8 +133,8 @@ struct CreateAssetMediaSubcommand{
 	#[arg(long)]
 	expected_price:Option<u64>,
 }
+/// Upload multiple media files (.jpg, .png) Automatically detect the media type from file extension and generate asset name and description.  If you want support for more file types (.fbx, .mp3, .ogg) it should be fairly straightforward, just ask.
 #[derive(Args)]
-/// Automatically detect the media type from file extension and generate asset name and description
 struct CreateAssetMediasSubcommand{
 	#[arg(long,group="api_key",required=true)]
 	api_key_literal:Option<String>,
@@ -154,6 +159,7 @@ struct CreateAssetMediasSubcommand{
 	expected_price:Option<u64>,
 	input_files:Vec<PathBuf>,
 }
+/// Upload a (.rbxm, .rbxmx) model file to an existing asset.  Can be any type of model, including modulescripts.
 #[derive(Args)]
 struct UpdateAssetSubcommand{
 	#[arg(long)]
@@ -177,6 +183,7 @@ struct UpdateAssetSubcommand{
 	#[arg(long)]
 	change_allow_comments:Option<bool>,
 }
+/// Upload a media file (.jpg, .png) to an existing asset.
 #[derive(Args)]
 struct UpdateAssetMediaSubcommand{
 	#[arg(long)]
@@ -190,6 +197,7 @@ struct UpdateAssetMediaSubcommand{
 	#[arg(long)]
 	input_file:PathBuf,
 }
+/// Upload a place file (.rbxl, .rbxlx) to an existing place.
 #[derive(Args)]
 struct UpdatePlaceSubcommand{
 	#[arg(long)]
@@ -205,6 +213,7 @@ struct UpdatePlaceSubcommand{
 	#[arg(long)]
 	input_file:PathBuf,
 }
+/// Take an input folder containing scripts and models and turn it into a roblox file.  The two types of files (.rbxl: place, .rbxm: model) are actually the same file format, only the contents differ.
 #[derive(Args)]
 struct CompileSubcommand{
 	#[arg(long)]
@@ -216,6 +225,7 @@ struct CompileSubcommand{
 	#[arg(long)]
 	template:Option<PathBuf>,
 }
+/// Take an input folder containing scripts and models and turn it into a roblox file, then upload it to the specified asset id.  Does not work for places.
 #[derive(Args)]
 struct CompileUploadAssetSubcommand{
 	#[arg(long)]
@@ -235,6 +245,7 @@ struct CompileUploadAssetSubcommand{
 	#[arg(long)]
 	template:Option<PathBuf>,
 }
+/// Take an input folder containing scripts and models and turn it into a roblox file, then upload it to the specified place id.  Does not work for model asset ids.
 #[derive(Args)]
 struct CompileUploadPlaceSubcommand{
 	#[arg(long)]
@@ -254,6 +265,7 @@ struct CompileUploadPlaceSubcommand{
 	#[arg(long)]
 	template:Option<PathBuf>,
 }
+/// Take a roblox file (.rbxm, .rbxl) and turn it into a folder containing scripts and models.  Rox style means property overrides are written to the top of scripts, Rojo style means property overrides are written to the script file extension (Script.server.lua).
 #[derive(Args)]
 struct DecompileSubcommand{
 	#[arg(long)]
@@ -269,6 +281,7 @@ struct DecompileSubcommand{
 	#[arg(long)]
 	write_scripts:Option<bool>,
 }
+/// Download a model from the specified asset id, and decompile it into a folder in one swift motion.  The model file is not saved to disk.  This also works for places.
 #[derive(Args)]
 struct DownloadDecompileSubcommand{
 	#[arg(long,group="cookie",required=true)]
@@ -290,12 +303,13 @@ struct DownloadDecompileSubcommand{
 	#[arg(long)]
 	write_scripts:Option<bool>,
 }
+/// Take a folder of asset history (containing `versions.json`) and decompile each version into its own git commit.  This must be run with the desired output folder as the current directory due to git2 limitations.
 #[derive(Args)]
 struct DecompileHistoryIntoGitSubcommand{
 	#[arg(long)]
 	input_folder:PathBuf,
-	//currently output folder must be the current folder due to git2 limitations
+	#[arg(long)]
-	//output_folder:cli.output.unwrap(),
+	output_folder:Option<PathBuf>,
 	#[arg(long)]
 	style:Style,
 	#[arg(long)]
@@ -309,6 +323,7 @@ struct DecompileHistoryIntoGitSubcommand{
 	#[arg(long)]
 	write_scripts:Option<bool>,
 }
+/// Download asset history, download asset versions, decompile into folder, create a git commit for each version.  This is a combination of two commands (download-history, decompile-history-into-git) except without intermediate files.
 #[derive(Args)]
 struct DownloadAndDecompileHistoryIntoGitSubcommand{
 	#[arg(long)]
@@ -319,8 +334,8 @@ struct DownloadAndDecompileHistoryIntoGitSubcommand{
 	cookie_envvar:Option<String>,
 	#[arg(long,group="cookie",required=true)]
 	cookie_file:Option<PathBuf>,
-	//currently output folder must be the current folder due to git2 limitations
+	#[arg(long)]
-	//output_folder:cli.output.unwrap(),
+	output_folder:Option<PathBuf>,
 	#[arg(long)]
 	style:Style,
 	#[arg(long)]
@@ -546,7 +561,7 @@ async fn main()->AResult<()>{
 			git_committer_name:subcommand.git_committer_name,
 			git_committer_email:subcommand.git_committer_email,
 			input_folder:subcommand.input_folder,
-			output_folder:std::env::current_dir()?,
+			output_folder:subcommand.output_folder.unwrap_or_else(||std::env::current_dir().unwrap()),
 			style:subcommand.style.rox(),
 			write_template:subcommand.write_template.unwrap_or(false),
 			write_models:subcommand.write_models.unwrap_or(false),
@@ -561,7 +576,7 @@ async fn main()->AResult<()>{
 				subcommand.cookie_file,
 			).await?,
 			asset_id:subcommand.asset_id,
-			output_folder:std::env::current_dir()?,
+			output_folder:subcommand.output_folder.unwrap_or_else(||std::env::current_dir().unwrap()),
 			style:subcommand.style.rox(),
 			write_template:subcommand.write_template.unwrap_or(false),
 			write_models:subcommand.write_models.unwrap_or(false),
@@ -624,20 +639,20 @@ struct CreateAssetMediaConfig{
 
 async fn get_asset_exp_backoff(
 	context:&CloudContext,
-	create_asset_response:&rbx_asset::cloud::CreateAssetResponse
+	asset_operation:&rbx_asset::cloud::AssetOperation
-)->Result<rbx_asset::cloud::AssetResponse,rbx_asset::cloud::CreateAssetResponseGetAssetError>{
+)->Result<rbx_asset::cloud::AssetResponse,rbx_asset::cloud::AssetOperationError>{
-	let mut backoff:u64=0;
+	const BACKOFF_MUL:f32=1.3956124250860895286;//exp(1/3)
+	let mut backoff=1000f32;
 	loop{
-		match create_asset_response.try_get_asset(&context).await{
+		match asset_operation.try_get_asset(&context).await{
 			//try again when the operation is not done
-			Err(rbx_asset::cloud::CreateAssetResponseGetAssetError::Operation(rbx_asset::cloud::OperationError::NotDone))=>(),
+			Err(rbx_asset::cloud::AssetOperationError::Operation(rbx_asset::cloud::OperationError::NotDone))=>(),
 			//return all other results
 			other_result=>return other_result,
 		}
-		let wait=f32::exp(backoff as f32/3.0)*1000f32;
+		println!("Operation not complete; waiting {:.0}ms...",backoff);
-		println!("Operation not complete; waiting {:.0}ms...",wait);
+		tokio::time::sleep(std::time::Duration::from_millis(backoff as u64)).await;
-		tokio::time::sleep(std::time::Duration::from_millis(wait as u64)).await;
+		backoff*=BACKOFF_MUL;
-		backoff+=1;
 	}
 }
 
@@ -672,9 +687,12 @@ struct CreateAssetMediasConfig{
 }
 
 #[derive(Debug)]
+#[allow(dead_code)]
 enum CreateAssetMediasError{
 	NoFileStem(PathBuf),
-	UnknownFourCC(Option<Vec<u8>>),
+	IO(std::io::Error),
+	UnknownFourCC(Option<[u8;4]>),
+	Create(rbx_asset::cloud::CreateError),
 }
 impl std::fmt::Display for CreateAssetMediasError{
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>)->std::fmt::Result{
@@ -684,7 +702,22 @@ impl std::fmt::Display for CreateAssetMediasError{
 impl std::error::Error for CreateAssetMediasError{}
 
 #[derive(Debug)]
+#[allow(dead_code)]
+enum PollOperationError{
+	CreateAssetMedias(CreateAssetMediasError),
+	AssetOperation(rbx_asset::cloud::AssetOperationError),
+}
+impl std::fmt::Display for PollOperationError{
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for PollOperationError{}
+
+#[derive(Debug)]
+#[allow(dead_code)]
 enum DownloadDecalError{
+	PollOperation(PollOperationError),
 	ParseInt(std::num::ParseIntError),
 	Get(rbx_asset::cookie::GetError),
 	LoadDom(LoadDomError),
@@ -693,7 +726,7 @@ enum DownloadDecalError{
 	TexturePropertyInvalid,
 }
 impl std::fmt::Display for DownloadDecalError{
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>)->std::fmt::Result{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
 		write!(f,"{self:?}")
 	}
 }
@@ -703,18 +736,19 @@ async fn create_asset_medias(config:CreateAssetMediasConfig)->AResult<()>{
 	let context=CloudContext::new(config.api_key);
 	let cookie_context=CookieContext::new(config.cookie);
 	let expected_price=Some(config.expected_price.unwrap_or(0));
-	let asset_id_list=futures::stream::iter(config.input_files.into_iter()
+	futures::stream::iter(config.input_files.into_iter()
 	//step 1: read file, make create request
 	.map(|path|{
 		let description=&config.description;
 		let creator=&config.creator;
 		let context=&context;
+		async move{(path.clone(),
 		async move{
 			let model_name=path.file_stem()
 			.and_then(std::ffi::OsStr::to_str)
-			.ok_or(CreateAssetMediasError::NoFileStem(path.clone()))?
+			.ok_or_else(||CreateAssetMediasError::NoFileStem(path.clone()))?
 			.to_owned();
-			let file=tokio::fs::read(path).await?;
+			let file=tokio::fs::read(path).await.map_err(CreateAssetMediasError::IO)?;
 			let asset_type=match file.get(0..4){
 				//png
 				Some(b"\x89PNG")=>rbx_asset::cloud::AssetType::Decal,
@@ -722,9 +756,9 @@ async fn create_asset_medias(config:CreateAssetMediasConfig)->AResult<()>{
 				Some(b"\xFF\xD8\xFF\xE0")=>rbx_asset::cloud::AssetType::Decal,
 				//Some("fbx")=>rbx_asset::cloud::AssetType::Model,
 				//Some("ogg")=>rbx_asset::cloud::AssetType::Audio,
-				fourcc=>Err(CreateAssetMediasError::UnknownFourCC(fourcc.map(<[u8]>::to_owned)))?,
+				fourcc=>Err(CreateAssetMediasError::UnknownFourCC(fourcc.map(|s|s.try_into().unwrap())))?,
 			};
-			Ok(context.create_asset(rbx_asset::cloud::CreateAssetRequest{
+			context.create_asset(rbx_asset::cloud::CreateAssetRequest{
 				assetType:asset_type,
 				displayName:model_name,
 				description:description.clone(),
@@ -732,59 +766,51 @@ async fn create_asset_medias(config:CreateAssetMediasConfig)->AResult<()>{
 					creator:creator.clone(),
 					expectedPrice:expected_price,
 				}
-			},file).await?)
+			},file).await.map_err(CreateAssetMediasError::Create)
 		}
+		.await)}
 	}))
 	//parallel requests
 	.buffer_unordered(CONCURRENT_REQUESTS)
-	//step 2: poll operation until it completes (as fast as possible no exp backoff or anything just hammer roblox)
+	//step 2: poll operation until it completes
-	.filter_map(|create_result:AResult<_>|{
+	.then(|(path,create_result)|{
 		let context=&context;
+		async{(path,
 		async{
-			match create_result{
+			let asset_operation=create_result.map_err(PollOperationError::CreateAssetMedias)?;
-				Ok(create_asset_response)=>match get_asset_exp_backoff(context,&create_asset_response).await{
+			get_asset_exp_backoff(context,&asset_operation).await.map_err(PollOperationError::AssetOperation)
-					Ok(asset_response)=>Some(asset_response),
-					Err(e)=>{
-						eprintln!("operation error: {}",e);
-						None
-					},
-				},
-				Err(e)=>{
-					eprintln!("create_asset error: {}",e);
-					None
-				},
-			}
 		}
+		.await)}
 	})
-	//step 3: read decal id from operation and download it
+	//step 3: read decal id from operation and download it, decode it as a roblox file and extract the texture content url
-	.filter_map(|asset_response|{
+	.then(|(path,asset_response_result)|{
-		let parse_result=asset_response.assetId.parse();
+		let cookie_context=&cookie_context;
-		async{
+		async move{(path,
-			match async{
+		async move{
-				let file=cookie_context.get_asset(rbx_asset::cookie::GetAssetRequest{
+			let asset_response=asset_response_result.map_err(DownloadDecalError::PollOperation)?;
-					asset_id:parse_result.map_err(DownloadDecalError::ParseInt)?,
+			let file=cookie_context.get_asset(rbx_asset::cookie::GetAssetRequest{
-					version:None,
+				asset_id:asset_response.assetId.parse().map_err(DownloadDecalError::ParseInt)?,
-				}).await.map_err(DownloadDecalError::Get)?;
+				version:None,
-				let dom=load_dom(std::io::Cursor::new(file)).map_err(DownloadDecalError::LoadDom)?;
+			}).await.map_err(DownloadDecalError::Get)?;
-				let instance=dom.get_by_ref(
+			let dom=load_dom(std::io::Cursor::new(file)).map_err(DownloadDecalError::LoadDom)?;
-					*dom.root().children().first().ok_or(DownloadDecalError::NoFirstInstance)?
+			let instance=dom.get_by_ref(
-				).ok_or(DownloadDecalError::NoFirstInstance)?;
+				*dom.root().children().first().ok_or(DownloadDecalError::NoFirstInstance)?
-				match instance.properties.get("Texture").ok_or(DownloadDecalError::NoTextureProperty)?{
+			).ok_or(DownloadDecalError::NoFirstInstance)?;
-					rbx_dom_weak::types::Variant::Content(url)=>Ok(url.clone().into_string()),
+			let texture=instance.properties.get("Texture").ok_or(DownloadDecalError::NoTextureProperty)?;
-					_=>Err(DownloadDecalError::TexturePropertyInvalid),
+			let asset_url=match texture{
-				}
+				rbx_dom_weak::types::Variant::Content(url)=>url.clone().into_string(),
-			}.await{
+				_=>Err(DownloadDecalError::TexturePropertyInvalid)?,
-				Ok(asset_url)=>Some((asset_response.displayName,asset_url)),
+			};
-				Err(e)=>{
+			Ok::<_,DownloadDecalError>((asset_response.displayName,asset_url))
-					eprintln!("get_asset error: {}",e);
-					None
-				},
-			}
 		}
-	}).collect::<Vec<(String,String)>>().await;
+		.await)}
-	for (file_name,asset_url) in asset_id_list{
+	})
-		println!("{}={}",file_name,asset_url);
+	.for_each(|(path,download_decal_result)|async move{
-	}
+		match download_decal_result{
+			Ok((file_name,asset_url))=>println!("{}={}",file_name,asset_url),
+			Err(e)=>eprintln!("ERROR file={:?} error={e}",path),
+		}
+	}).await;
 	Ok(())
 }
 
@@ -1034,6 +1060,7 @@ async fn download_history(mut config:DownloadHistoryConfig)->AResult<()>{
 }
 
 #[derive(Debug)]
+#[allow(dead_code)]
 enum LoadDomError{
 	IO(std::io::Error),
 	RbxBinary(rbx_binary::DecodeError),
@@ -1171,11 +1198,11 @@ async fn write_commit(config:WriteCommitConfig,b:Result<AResult<(AssetVersion,ro
 	let sig=git2::Signature::new(config.git_committer_name.as_str(),config.git_committer_email.as_str(),&git2::Time::new(date.timestamp(),0)).unwrap();
 	let tree_id={
 		let mut tree_index = repo.index()?;
-		match tree_index.add_all(std::iter::once(config.output_folder.as_path()),git2::IndexAddOption::DEFAULT,None){
+		match tree_index.add_all(std::iter::once("*"),git2::IndexAddOption::DEFAULT,None){
 			Ok(_)=>(),
 			Err(e)=>println!("tree_index.add_all error: {}",e),
 		}
-		match tree_index.update_all(std::iter::once(config.output_folder.as_path()),None){
+		match tree_index.update_all(std::iter::once("*"),None){
 			Ok(_)=>(),
 			Err(e)=>println!("tree_index.update_all error: {}",e),
 		}