no need error

Cargo.toml

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

README.md

@@ -3,19 +3,3 @@
 [![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.
-
-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,27 +14,26 @@ pub struct CreateAssetRequest{
 	pub displayName:String,
 }
 #[derive(Debug)]
-pub enum AssetOperationError{
+pub enum CreateAssetResponseGetAssetError{
 	Operation(OperationError),
 	Serialize(serde_json::Error),
 }
-impl std::fmt::Display for AssetOperationError{
+impl std::fmt::Display for CreateAssetResponseGetAssetError{
 	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
 		write!(f,"{self:?}")
 	}
 }
-impl std::error::Error for AssetOperationError{}
-#[derive(Debug)]
-pub struct AssetOperation{
+impl std::error::Error for CreateAssetResponseGetAssetError{}
+pub struct CreateAssetResponse{
 	operation:RobloxOperation,
 }
-impl AssetOperation{
-	pub async fn try_get_asset(&self,context:&CloudContext)->Result<AssetResponse,AssetOperationError>{
+impl CreateAssetResponse{
+	pub async fn try_get_asset(&self,context:&CloudContext)->Result<AssetResponse,CreateAssetResponseGetAssetError>{
 		serde_json::from_value(
 			self.operation
 				.try_get_reponse(context).await
-				.map_err(AssetOperationError::Operation)?
-		).map_err(AssetOperationError::Serialize)
+				.map_err(CreateAssetResponseGetAssetError::Operation)?
+		).map_err(CreateAssetResponseGetAssetError::Serialize)
 	}
 }
 #[derive(Debug)]
@@ -112,8 +111,8 @@ impl std::fmt::Display for UpdateError{
 }
 impl std::error::Error for UpdateError{}
 
-struct GetAssetOperationRequest{
-	operation_id:String,
+pub struct GetAssetOperationRequest{
+	pub operation_id:String,
 }
 pub struct GetAssetInfoRequest{
 	pub asset_id:u64,
@@ -261,7 +260,7 @@ impl std::fmt::Display for OperationError{
 impl std::error::Error for OperationError{}
 #[derive(Debug,serde::Deserialize,serde::Serialize)]
 #[allow(nonstandard_style,dead_code)]
-struct RobloxOperation{
+pub struct RobloxOperation{
 	pub path:Option<String>,
 	pub metadata:Option<String>,
 	pub done:Option<bool>,
@@ -355,7 +354,7 @@ impl CloudContext{
 		.multipart(form)
 		.send().await
 	}
-	pub async fn create_asset(&self,config:CreateAssetRequest,body:impl Into<std::borrow::Cow<'static,[u8]>>)->Result<AssetOperation,CreateError>{
+	pub async fn create_asset(&self,config:CreateAssetRequest,body:impl Into<std::borrow::Cow<'static,[u8]>>)->Result<CreateAssetResponse,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)?;
@@ -368,16 +367,15 @@ 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(AssetOperation{
+		Ok(CreateAssetResponse{
 			operation,
 		})
 	}
-	pub async fn update_asset(&self,config:UpdateAssetRequest,body:impl Into<std::borrow::Cow<'static,[u8]>>)->Result<AssetOperation,UpdateError>{
+	pub async fn update_asset(&self,config:UpdateAssetRequest,body:impl Into<std::borrow::Cow<'static,[u8]>>)->Result<RobloxOperation,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)?;
 
@@ -387,17 +385,13 @@ impl CloudContext{
 		.text("request",request_config)
 		.part("fileContent",reqwest::multipart::Part::bytes(body));
 
-		let operation=self.patch_form(url,form).await
+		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)?;
-
-		Ok(AssetOperation{
-			operation,
-		})
+		.json::<RobloxOperation>().await.map_err(UpdateError::Reqwest)
 	}
-	async fn get_asset_operation(&self,config:GetAssetOperationRequest)->Result<RobloxOperation,GetError>{
+	pub 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,7 +38,6 @@ 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)]
@@ -58,7 +57,6 @@ struct DownloadHistorySubcommand{
 	#[arg(long)]
 	end_version:Option<u64>,
 }
-/// Download a single asset by id.
 #[derive(Args)]
 struct DownloadSubcommand{
 	#[arg(long,group="cookie",required=true)]
@@ -72,7 +70,6 @@ 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)]
@@ -86,7 +83,6 @@ 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)]
@@ -108,7 +104,6 @@ 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)]
@@ -133,8 +128,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>,
@@ -159,7 +154,6 @@ 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)]
@@ -183,7 +177,6 @@ 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)]
@@ -197,7 +190,6 @@ struct UpdateAssetMediaSubcommand{
 	#[arg(long)]
 	input_file:PathBuf,
 }
-/// Upload a place file (.rbxl, .rbxlx) to an existing place.
 #[derive(Args)]
 struct UpdatePlaceSubcommand{
 	#[arg(long)]
@@ -213,7 +205,6 @@ 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)]
@@ -225,7 +216,6 @@ 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)]
@@ -245,7 +235,6 @@ 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)]
@@ -265,7 +254,6 @@ 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)]
@@ -281,7 +269,6 @@ 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)]
@@ -303,13 +290,12 @@ 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,
-	#[arg(long)]
-	output_folder:Option<PathBuf>,
+	//currently output folder must be the current folder due to git2 limitations
+	//output_folder:cli.output.unwrap(),
 	#[arg(long)]
 	style:Style,
 	#[arg(long)]
@@ -323,7 +309,6 @@ 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)]
@@ -334,8 +319,8 @@ struct DownloadAndDecompileHistoryIntoGitSubcommand{
 	cookie_envvar:Option<String>,
 	#[arg(long,group="cookie",required=true)]
 	cookie_file:Option<PathBuf>,
-	#[arg(long)]
-	output_folder:Option<PathBuf>,
+	//currently output folder must be the current folder due to git2 limitations
+	//output_folder:cli.output.unwrap(),
 	#[arg(long)]
 	style:Style,
 	#[arg(long)]
@@ -561,7 +546,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:subcommand.output_folder.unwrap_or_else(||std::env::current_dir().unwrap()),
+			output_folder:std::env::current_dir()?,
 			style:subcommand.style.rox(),
 			write_template:subcommand.write_template.unwrap_or(false),
 			write_models:subcommand.write_models.unwrap_or(false),
@@ -576,7 +561,7 @@ async fn main()->AResult<()>{
 				subcommand.cookie_file,
 			).await?,
 			asset_id:subcommand.asset_id,
-			output_folder:subcommand.output_folder.unwrap_or_else(||std::env::current_dir().unwrap()),
+			output_folder:std::env::current_dir()?,
 			style:subcommand.style.rox(),
 			write_template:subcommand.write_template.unwrap_or(false),
 			write_models:subcommand.write_models.unwrap_or(false),
@@ -639,20 +624,20 @@ struct CreateAssetMediaConfig{
 
 async fn get_asset_exp_backoff(
 	context:&CloudContext,
-	asset_operation:&rbx_asset::cloud::AssetOperation
-)->Result<rbx_asset::cloud::AssetResponse,rbx_asset::cloud::AssetOperationError>{
-	const BACKOFF_MUL:f32=1.3956124250860895286;//exp(1/3)
-	let mut backoff=1000f32;
+	create_asset_response:&rbx_asset::cloud::CreateAssetResponse
+)->Result<rbx_asset::cloud::AssetResponse,rbx_asset::cloud::CreateAssetResponseGetAssetError>{
+	let mut backoff:u64=0;
 	loop{
-		match asset_operation.try_get_asset(&context).await{
+		match create_asset_response.try_get_asset(&context).await{
 			//try again when the operation is not done
-			Err(rbx_asset::cloud::AssetOperationError::Operation(rbx_asset::cloud::OperationError::NotDone))=>(),
+			Err(rbx_asset::cloud::CreateAssetResponseGetAssetError::Operation(rbx_asset::cloud::OperationError::NotDone))=>(),
 			//return all other results
 			other_result=>return other_result,
 		}
-		println!("Operation not complete; waiting {:.0}ms...",backoff);
-		tokio::time::sleep(std::time::Duration::from_millis(backoff as u64)).await;
-		backoff*=BACKOFF_MUL;
+		let wait=f32::exp(backoff as f32/3.0)*1000f32;
+		println!("Operation not complete; waiting {:.0}ms...",wait);
+		tokio::time::sleep(std::time::Duration::from_millis(wait as u64)).await;
+		backoff+=1;
 	}
 }
 
@@ -687,12 +672,9 @@ struct CreateAssetMediasConfig{
 }
 
 #[derive(Debug)]
-#[allow(dead_code)]
 enum CreateAssetMediasError{
 	NoFileStem(PathBuf),
-	IO(std::io::Error),
-	UnknownFourCC(Option<[u8;4]>),
-	Create(rbx_asset::cloud::CreateError),
+	UnknownFourCC(Option<Vec<u8>>),
 }
 impl std::fmt::Display for CreateAssetMediasError{
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>)->std::fmt::Result{
@@ -702,22 +684,7 @@ 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),
@@ -736,19 +703,18 @@ 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));
-	futures::stream::iter(config.input_files.into_iter()
+	let asset_id_list=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_else(||CreateAssetMediasError::NoFileStem(path.clone()))?
+			.ok_or(CreateAssetMediasError::NoFileStem(path.clone()))?
 			.to_owned();
-			let file=tokio::fs::read(path).await.map_err(CreateAssetMediasError::IO)?;
+			let file=tokio::fs::read(path).await?;
 			let asset_type=match file.get(0..4){
 				//png
 				Some(b"\x89PNG")=>rbx_asset::cloud::AssetType::Decal,
@@ -756,9 +722,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(|s|s.try_into().unwrap())))?,
+				fourcc=>Err(CreateAssetMediasError::UnknownFourCC(fourcc.map(<[u8]>::to_owned)))?,
 			};
-			context.create_asset(rbx_asset::cloud::CreateAssetRequest{
+			Ok(context.create_asset(rbx_asset::cloud::CreateAssetRequest{
 				assetType:asset_type,
 				displayName:model_name,
 				description:description.clone(),
@@ -766,51 +732,59 @@ async fn create_asset_medias(config:CreateAssetMediasConfig)->AResult<()>{
 					creator:creator.clone(),
 					expectedPrice:expected_price,
 				}
-			},file).await.map_err(CreateAssetMediasError::Create)
+			},file).await?)
 		}
-		.await)}
 	}))
 	//parallel requests
 	.buffer_unordered(CONCURRENT_REQUESTS)
-	//step 2: poll operation until it completes
-	.then(|(path,create_result)|{
+	//step 2: poll operation until it completes (as fast as possible no exp backoff or anything just hammer roblox)
+	.filter_map(|create_result:AResult<_>|{
 		let context=&context;
-		async{(path,
 		async{
-			let asset_operation=create_result.map_err(PollOperationError::CreateAssetMedias)?;
-			get_asset_exp_backoff(context,&asset_operation).await.map_err(PollOperationError::AssetOperation)
+			match create_result{
+				Ok(create_asset_response)=>match get_asset_exp_backoff(context,&create_asset_response).await{
+					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, decode it as a roblox file and extract the texture content url
-	.then(|(path,asset_response_result)|{
-		let cookie_context=&cookie_context;
-		async move{(path,
-		async move{
-			let asset_response=asset_response_result.map_err(DownloadDecalError::PollOperation)?;
+	//step 3: read decal id from operation and download it
+	.filter_map(|asset_response|{
+		let parse_result=asset_response.assetId.parse();
+		async{
+			match async{
 				let file=cookie_context.get_asset(rbx_asset::cookie::GetAssetRequest{
-				asset_id:asset_response.assetId.parse().map_err(DownloadDecalError::ParseInt)?,
+					asset_id:parse_result.map_err(DownloadDecalError::ParseInt)?,
 					version:None,
 				}).await.map_err(DownloadDecalError::Get)?;
 				let dom=load_dom(std::io::Cursor::new(file)).map_err(DownloadDecalError::LoadDom)?;
 				let instance=dom.get_by_ref(
 					*dom.root().children().first().ok_or(DownloadDecalError::NoFirstInstance)?
 				).ok_or(DownloadDecalError::NoFirstInstance)?;
-			let texture=instance.properties.get("Texture").ok_or(DownloadDecalError::NoTextureProperty)?;
-			let asset_url=match texture{
-				rbx_dom_weak::types::Variant::Content(url)=>url.clone().into_string(),
-				_=>Err(DownloadDecalError::TexturePropertyInvalid)?,
-			};
-			Ok::<_,DownloadDecalError>((asset_response.displayName,asset_url))
+				match instance.properties.get("Texture").ok_or(DownloadDecalError::NoTextureProperty)?{
+					rbx_dom_weak::types::Variant::Content(url)=>Ok(url.clone().into_string()),
+					_=>Err(DownloadDecalError::TexturePropertyInvalid),
 				}
-		.await)}
-	})
-	.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(asset_url)=>Some((asset_response.displayName,asset_url)),
+				Err(e)=>{
+					eprintln!("get_asset error: {}",e);
+					None
+				},
+			}
+		}
+	}).collect::<Vec<(String,String)>>().await;
+	for (file_name,asset_url) in asset_id_list{
+		println!("{}={}",file_name,asset_url);
 	}
-	}).await;
 	Ok(())
 }
 
@@ -1060,7 +1034,6 @@ async fn download_history(mut config:DownloadHistoryConfig)->AResult<()>{
 }
 
 #[derive(Debug)]
-#[allow(dead_code)]
 enum LoadDomError{
 	IO(std::io::Error),
 	RbxBinary(rbx_binary::DecodeError),
@@ -1198,11 +1171,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("*"),git2::IndexAddOption::DEFAULT,None){
+		match tree_index.add_all(std::iter::once(config.output_folder.as_path()),git2::IndexAddOption::DEFAULT,None){
 			Ok(_)=>(),
 			Err(e)=>println!("tree_index.add_all error: {}",e),
 		}
-		match tree_index.update_all(std::iter::once("*"),None){
+		match tree_index.update_all(std::iter::once(config.output_folder.as_path()),None){
 			Ok(_)=>(),
 			Err(e)=>println!("tree_index.update_all error: {}",e),
 		}