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

.drone.yml

@@ -0,0 +1,24 @@
+---
+kind: pipeline
+type: docker
+
+platform:
+  os: linux
+  arch: amd64
+
+steps:
+  - name: image
+    image: plugins/docker
+    settings:
+      registry: git.itzana.me
+      repo: git.itzana.me/strafesnet/asset-tool
+      tags:
+        - latest
+      username:
+        from_secret: GIT_USER
+      password:
+        from_secret: GIT_PASS
+      dockerfile: Containerfile
+    when:
+      branch:
+        - master

Cargo.toml

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

Containerfile

@@ -1,6 +1,6 @@
 # Using the `rust-musl-builder` as base image, instead of 
 # the official Rust toolchain
-FROM clux/muslrust:stable AS chef
+FROM docker.io/clux/muslrust:stable AS chef
 USER root
 RUN cargo install cargo-chef
 WORKDIR /app
@@ -16,8 +16,8 @@ RUN cargo chef cook --release --target x86_64-unknown-linux-musl --recipe-path r
 COPY . .
 RUN cargo build --release --target x86_64-unknown-linux-musl --bin asset-tool
 
-FROM alpine AS runtime
+FROM docker.io/alpine:latest AS runtime
 RUN addgroup -S myuser && adduser -S myuser -G myuser
 COPY --from=builder /app/target/x86_64-unknown-linux-musl/release/asset-tool /usr/local/bin/
 USER myuser
-CMD ["/usr/local/bin/asset-tool"]
+ENTRYPOINT ["/usr/local/bin/asset-tool"]

README.md

@@ -1,3 +1,21 @@
 # asset-tool
 
+[![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/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rbx_asset"
-version = "0.2.0"
+version = "0.2.2"
 edition = "2021"
 publish = ["strafesnet"]
 

rbx_asset/src/cloud.rs

@@ -14,9 +14,33 @@ pub struct CreateAssetRequest{
 	pub displayName:String,
 }
 #[derive(Debug)]
+pub enum AssetOperationError{
+	Operation(OperationError),
+	Serialize(serde_json::Error),
+}
+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 AssetOperationError{}
+#[derive(Debug)]
+pub struct AssetOperation{
+	operation:RobloxOperation,
+}
+impl AssetOperation{
+	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(AssetOperationError::Operation)?
+		).map_err(AssetOperationError::Serialize)
+	}
+}
+#[derive(Debug)]
 pub enum CreateError{
-	ParseError(url::ParseError),
+	Parse(url::ParseError),
-	SerializeError(serde_json::Error),
+	Serialize(serde_json::Error),
 	Reqwest(reqwest::Error),
 }
 impl std::fmt::Display for CreateError{
@@ -35,24 +59,29 @@ pub struct UpdateAssetRequest{
 }
 
 //woo nested roblox stuff
-#[derive(Debug,serde::Deserialize,serde::Serialize)]
+#[derive(Clone,Debug,serde::Deserialize,serde::Serialize)]
 #[allow(nonstandard_style,dead_code)]
-pub struct Creator{
+pub enum Creator{
-	pub userId:u64,
+	userId(String),//u64 string
-	pub groupId:u64,
+	groupId(String),//u64 string
 }
 #[derive(Debug,serde::Deserialize,serde::Serialize)]
 #[allow(nonstandard_style,dead_code)]
 pub struct CreationContext{
 	pub creator:Creator,
-	pub expectedPrice:u64,
+	pub expectedPrice:Option<u64>,
 }
 #[derive(Debug,serde::Deserialize,serde::Serialize)]
 #[allow(nonstandard_style,dead_code)]
-pub enum ModerationResult{
+pub enum ModerationState{
-	MODERATION_STATE_REVIEWING,
+	Reviewing,
-	MODERATION_STATE_REJECTED,
+	Rejected,
-	MODERATION_STATE_APPROVED,
+	Approved,
+}
+#[derive(Debug,serde::Deserialize,serde::Serialize)]
+#[allow(nonstandard_style,dead_code)]
+pub struct ModerationResult{
+	pub moderationState:ModerationState,
 }
 #[derive(Debug,serde::Deserialize,serde::Serialize)]
 #[allow(nonstandard_style,dead_code)]
@@ -60,20 +89,6 @@ pub struct Preview{
 	pub asset:String,
 	pub altText:String,
 }
-#[derive(Debug,serde::Deserialize,serde::Serialize)]
-#[allow(nonstandard_style,dead_code)]
-pub struct AssetResponse{
-	pub assetId:u64,
-	pub creationContext:CreationContext,
-	pub description:String,
-	pub displayName:String,
-	pub path:String,
-	pub revisionId:u64,
-	pub revisionCreateTime:chrono::DateTime<chrono::Utc>,
-	pub moderationResult:ModerationResult,
-	pub icon:String,
-	pub previews:Vec<Preview>,
-}
 #[allow(nonstandard_style,dead_code)]
 pub struct UpdatePlaceRequest{
 	pub universeId:u64,
@@ -91,12 +106,59 @@ pub enum UpdateError{
 	Reqwest(reqwest::Error),
 }
 impl std::fmt::Display for UpdateError{
-	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:?}")
 	}
 }
 impl std::error::Error for UpdateError{}
 
+struct GetAssetOperationRequest{
+	operation_id:String,
+}
+pub struct GetAssetInfoRequest{
+	pub asset_id:u64,
+}
+/*
+{
+    "assetId": "5692158972",
+    "assetType": "Model",
+    "creationContext":{
+        "creator":
+        {
+            "groupId": "6980477"
+        }
+    },
+    "description": "DisplayName: Ares\nCreator: titanicguy54",
+    "displayName": "bhop_ares.rbxmx",
+    "path": "assets/5692158972",
+    "revisionCreateTime": "2020-09-14T16:08:05.063Z",
+    "revisionId": "1",
+    "moderationResult":{
+        "moderationState": "Approved"
+    },
+    "state": "Active"
+}
+*/
+#[derive(Debug,serde::Deserialize,serde::Serialize)]
+#[allow(nonstandard_style,dead_code)]
+pub struct AssetResponse{
+	pub assetId:String,//u64 wrapped in quotes wohoo!!
+	pub assetType:AssetType,
+	pub creationContext:CreationContext,
+	pub description:String,
+	pub displayName:String,
+	pub path:String,
+	pub revisionCreateTime:chrono::DateTime<chrono::Utc>,
+	pub revisionId:String,//u64
+	pub moderationResult:ModerationResult,
+	pub icon:Option<String>,
+	pub previews:Option<Vec<Preview>>,
+}
+#[allow(nonstandard_style,dead_code)]
+pub struct GetAssetVersionRequest{
+	pub asset_id:u64,
+	pub version:u64,
+}
 #[allow(nonstandard_style,dead_code)]
 pub struct GetAssetRequest{
 	pub asset_id:u64,
@@ -109,7 +171,7 @@ pub enum GetError{
 	IO(std::io::Error)
 }
 impl std::fmt::Display for GetError{
-	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:?}")
 	}
 }
@@ -119,7 +181,7 @@ pub struct AssetVersionsRequest{
 	pub asset_id:u64,
 	pub cursor:Option<String>,
 }
-#[derive(serde::Deserialize,serde::Serialize)]
+#[derive(Debug,serde::Deserialize,serde::Serialize)]
 #[allow(nonstandard_style,dead_code)]
 pub struct AssetVersion{
 	pub Id:u64,
@@ -131,7 +193,7 @@ pub struct AssetVersion{
 	pub created:chrono::DateTime<chrono::Utc>,
 	pub isPublished:bool,
 }
-#[derive(serde::Deserialize)]
+#[derive(Debug,serde::Deserialize)]
 #[allow(nonstandard_style,dead_code)]
 pub struct AssetVersionsResponse{
 	pub previousPageCursor:Option<String>,
@@ -144,7 +206,7 @@ pub enum AssetVersionsError{
 	Reqwest(reqwest::Error),
 }
 impl std::fmt::Display for AssetVersionsError{
-	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:?}")
 	}
 }
@@ -154,13 +216,13 @@ pub struct InventoryPageRequest{
 	pub group:u64,
 	pub cursor:Option<String>,
 }
-#[derive(serde::Deserialize,serde::Serialize)]
+#[derive(Debug,serde::Deserialize,serde::Serialize)]
 #[allow(nonstandard_style,dead_code)]
 pub struct InventoryItem{
 	pub id:u64,
 	pub name:String,
 }
-#[derive(serde::Deserialize,serde::Serialize)]
+#[derive(Debug,serde::Deserialize,serde::Serialize)]
 #[allow(nonstandard_style,dead_code)]
 pub struct InventoryPageResponse{
 	pub totalResults:u64,//up to 50
@@ -179,12 +241,54 @@ pub enum InventoryPageError{
 	Reqwest(reqwest::Error),
 }
 impl std::fmt::Display for InventoryPageError{
-	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:?}")
 	}
 }
 impl std::error::Error for InventoryPageError{}
 
+#[derive(Debug)]
+pub enum OperationError{
+	Get(GetError),
+	NoOperationId,
+	NotDone,
+}
+impl std::fmt::Display for OperationError{
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for OperationError{}
+#[derive(Debug,serde::Deserialize,serde::Serialize)]
+#[allow(nonstandard_style,dead_code)]
+struct RobloxOperation{
+	pub path:Option<String>,
+	pub metadata:Option<String>,
+	pub done:Option<bool>,
+	pub error:Option<String>,
+	pub response:Option<serde_json::Value>,
+	pub operationId:Option<String>,
+}
+impl RobloxOperation{
+	pub fn operation_id(&self)->Option<&str>{
+		match self.operationId.as_deref(){
+			//try getting it from undocumented operationId first
+			Some(operation_id)=>Some(operation_id),
+			//skip the first 11 characters
+			//operations/[uuid]
+			None=>self.path.as_deref()?.get(11..),
+		}
+	}
+	pub async fn try_get_reponse(&self,context:&CloudContext)->Result<serde_json::Value,OperationError>{
+		context.get_asset_operation(GetAssetOperationRequest{
+			operation_id:self.operation_id()
+				.ok_or(OperationError::NoOperationId)?
+				.to_owned(),
+		}).await.map_err(OperationError::Get)?
+		.response.ok_or(OperationError::NotDone)
+	}
+}
+
 //idk how to do this better
 enum ReaderType<R:std::io::Read>{
 	GZip(flate2::read::GzDecoder<std::io::BufReader<R>>),
@@ -251,20 +355,29 @@ impl CloudContext{
 		.multipart(form)
 		.send().await
 	}
-	pub async fn create_asset(&self,config:CreateAssetRequest,body:impl Into<std::borrow::Cow<'static,[u8]>>)->Result<AssetResponse,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::ParseError)?;
+		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::SerializeError)?;
+		let request_config=serde_json::to_string(&config).map_err(CreateError::Serialize)?;
+
+		let part=reqwest::multipart::Part::bytes(body)
+		//you must have a file name or roblox will 400!!!!!!!!!
+		.file_name("image");
 
 		let form=reqwest::multipart::Form::new()
 		.text("request",request_config)
-		.part("fileContent",reqwest::multipart::Part::bytes(body));
+		.part("fileContent",part);
 
-		let resp=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(resp.json::<AssetResponse>().await.map_err(CreateError::Reqwest)?)
+		Ok(AssetOperation{
+			operation,
+		})
 	}
-	pub async fn update_asset(&self,config:UpdateAssetRequest,body:impl Into<std::borrow::Cow<'static,[u8]>>)->Result<AssetResponse,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)?;
 
@@ -274,23 +387,39 @@ impl CloudContext{
 		.text("request",request_config)
 		.part("fileContent",reqwest::multipart::Part::bytes(body));
 
-		let resp=self.patch_form(url,form).await.map_err(UpdateError::Reqwest)?;
+		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)?;
 
-		Ok(resp.json::<AssetResponse>().await.map_err(UpdateError::Reqwest)?)
+		Ok(AssetOperation{
+			operation,
+		})
 	}
-	pub async fn get_asset(&self,config:GetAssetRequest)->Result<Vec<u8>,GetError>{
+	async fn get_asset_operation(&self,config:GetAssetOperationRequest)->Result<RobloxOperation,GetError>{
-		let mut url=reqwest::Url::parse("https://assetdelivery.roblox.com/v1/asset/").map_err(GetError::ParseError)?;
+		let raw_url=format!("https://apis.roblox.com/assets/v1/operations/{}",config.operation_id);
-		//url borrow scope
+		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::ParseError)?;
-		{
-			let mut query=url.query_pairs_mut();//borrow here
-			query.append_pair("ID",config.asset_id.to_string().as_str());
-			if let Some(version)=config.version{
-				query.append_pair("version",version.to_string().as_str());
-			}
-		}
-		let resp=self.get(url).await.map_err(GetError::Reqwest)?;
 
-		let body=resp.bytes().await.map_err(GetError::Reqwest)?;
+		self.get(url).await.map_err(GetError::Reqwest)?
+		.error_for_status().map_err(GetError::Reqwest)?
+		.json::<RobloxOperation>().await.map_err(GetError::Reqwest)
+	}
+	pub async fn get_asset_info(&self,config:GetAssetInfoRequest)->Result<AssetResponse,GetError>{
+		let raw_url=format!("https://apis.roblox.com/assets/v1/assets/{}",config.asset_id);
+		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::ParseError)?;
+
+		self.get(url).await.map_err(GetError::Reqwest)?
+		.error_for_status().map_err(GetError::Reqwest)?
+		.json::<AssetResponse>().await.map_err(GetError::Reqwest)
+	}
+	pub async fn get_asset_version(&self,config:GetAssetVersionRequest)->Result<Vec<u8>,GetError>{
+		let raw_url=format!("https://apis.roblox.com/assets/v1/assets/{}/versions/{}",config.asset_id,config.version);
+		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::ParseError)?;
+
+		let body=self.get(url).await.map_err(GetError::Reqwest)?
+		.error_for_status().map_err(GetError::Reqwest)?
+		.bytes().await.map_err(GetError::Reqwest)?;
 
 		match maybe_gzip_decode(&mut std::io::Cursor::new(body)){
 			Ok(ReaderType::GZip(readable))=>read_readable(readable),
@@ -298,12 +427,23 @@ impl CloudContext{
 			Err(e)=>Err(e),
 		}.map_err(GetError::IO)
 	}
+	pub async fn get_asset(&self,config:GetAssetRequest)->Result<Vec<u8>,GetError>{
+		let version=match config.version{
+			Some(version)=>version,
+			None=>self.get_asset_info(GetAssetInfoRequest{asset_id:config.asset_id}).await?.revisionId.parse().unwrap(),
+		};
+		self.get_asset_version(GetAssetVersionRequest{
+			asset_id:config.asset_id,
+			version,
+		}).await
+	}
 	pub async fn get_asset_versions(&self,config:AssetVersionsRequest)->Result<AssetVersionsResponse,AssetVersionsError>{
 		let raw_url=format!("https://apis.roblox.com/assets/v1/assets/{}/versions",config.asset_id);
 		let url=reqwest::Url::parse(raw_url.as_str()).map_err(AssetVersionsError::ParseError)?;
 
-		Ok(self.get(url).await.map_err(AssetVersionsError::Reqwest)?
+		self.get(url).await.map_err(AssetVersionsError::Reqwest)?
-		.json::<AssetVersionsResponse>().await.map_err(AssetVersionsError::Reqwest)?)
+		.error_for_status().map_err(AssetVersionsError::Reqwest)?
+		.json::<AssetVersionsResponse>().await.map_err(AssetVersionsError::Reqwest)
 	}
 	pub async fn inventory_page(&self,config:InventoryPageRequest)->Result<InventoryPageResponse,InventoryPageError>{
 		let mut url=reqwest::Url::parse(format!("https://apis.roblox.com/toolbox-service/v1/creations/group/{}/10?limit=50",config.group).as_str()).map_err(InventoryPageError::ParseError)?;
@@ -315,15 +455,21 @@ impl CloudContext{
 			}
 		}
 
-		Ok(self.get(url).await.map_err(InventoryPageError::Reqwest)?
+		self.get(url).await.map_err(InventoryPageError::Reqwest)?
-		.json::<InventoryPageResponse>().await.map_err(InventoryPageError::Reqwest)?)
+		.error_for_status().map_err(InventoryPageError::Reqwest)?
+		.json::<InventoryPageResponse>().await.map_err(InventoryPageError::Reqwest)
 	}
 	pub async fn update_place(&self,config:UpdatePlaceRequest,body:impl Into<reqwest::Body>+Clone)->Result<UpdatePlaceResponse,UpdateError>{
 		let raw_url=format!("https://apis.roblox.com/universes/v1/{}/places/{}/versions",config.universeId,config.placeId);
-		let url=reqwest::Url::parse(raw_url.as_str()).map_err(UpdateError::ParseError)?;
+		let mut url=reqwest::Url::parse(raw_url.as_str()).map_err(UpdateError::ParseError)?;
+		//url borrow scope
+		{
+			let mut query=url.query_pairs_mut();//borrow here
+			query.append_pair("versionType","Published");
+		}
 
-		let resp=self.post(url,body).await.map_err(UpdateError::Reqwest)?;
+		self.post(url,body).await.map_err(UpdateError::Reqwest)?
-
+		.error_for_status().map_err(UpdateError::Reqwest)?
-		Ok(resp.json::<UpdatePlaceResponse>().await.map_err(UpdateError::Reqwest)?)
+		.json::<UpdatePlaceResponse>().await.map_err(UpdateError::Reqwest)
 	}
 }

rbx_asset/src/cookie.rs

@@ -62,22 +62,22 @@ pub struct UploadResponse{
 }
 
 #[allow(nonstandard_style,dead_code)]
-pub struct DownloadRequest{
+pub struct GetAssetRequest{
 	pub asset_id:u64,
 	pub version:Option<u64>,
 }
 #[derive(Debug)]
-pub enum DownloadError{
+pub enum GetError{
 	ParseError(url::ParseError),
 	Reqwest(reqwest::Error),
 	IO(std::io::Error)
 }
-impl std::fmt::Display for DownloadError{
+impl std::fmt::Display for GetError{
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		write!(f,"{self:?}")
 	}
 }
-impl std::error::Error for DownloadError{}
+impl std::error::Error for GetError{}
 
 pub struct AssetVersionsPageRequest{
 	pub asset_id:u64,
@@ -228,15 +228,14 @@ impl CookieContext{
 			query.append_pair("description",config.description.as_str());
 			query.append_pair("ispublic",if config.ispublic{"True"}else{"False"});
 			query.append_pair("allowComments",if config.allowComments{"True"}else{"False"});
-			match config.groupId{
+			if let Some(group_id)=config.groupId{
-				Some(group_id)=>{query.append_pair("groupId",group_id.to_string().as_str());},
+				query.append_pair("groupId",group_id.to_string().as_str());
-				None=>(),
 			}
 		}
 
-		let resp=self.post(url,body).await.map_err(CreateError::PostError)?;
+		self.post(url,body).await.map_err(CreateError::PostError)?
-
+		.error_for_status().map_err(CreateError::Reqwest)?
-		Ok(resp.json::<UploadResponse>().await.map_err(CreateError::Reqwest)?)
+		.json::<UploadResponse>().await.map_err(CreateError::Reqwest)
 	}
 	pub async fn upload(&self,config:UploadRequest,body:impl Into<reqwest::Body>+Clone)->Result<UploadResponse,UploadError>{
 		let mut url=reqwest::Url::parse("https://data.roblox.com/Data/Upload.ashx?json=1&type=Model&genreTypeId=1").map_err(UploadError::ParseError)?;
@@ -265,12 +264,12 @@ impl CookieContext{
 			}
 		}
 
-		let resp=self.post(url,body).await.map_err(UploadError::PostError)?;
+		self.post(url,body).await.map_err(UploadError::PostError)?
-
+		.error_for_status().map_err(UploadError::Reqwest)?
-		Ok(resp.json::<UploadResponse>().await.map_err(UploadError::Reqwest)?)
+		.json::<UploadResponse>().await.map_err(UploadError::Reqwest)
 	}
-	pub async fn download(&self,config:DownloadRequest)->Result<Vec<u8>,DownloadError>{
+	pub async fn get_asset(&self,config:GetAssetRequest)->Result<Vec<u8>,GetError>{
-		let mut url=reqwest::Url::parse("https://assetdelivery.roblox.com/v1/asset/").map_err(DownloadError::ParseError)?;
+		let mut url=reqwest::Url::parse("https://assetdelivery.roblox.com/v1/asset/").map_err(GetError::ParseError)?;
 		//url borrow scope
 		{
 			let mut query=url.query_pairs_mut();//borrow here
@@ -279,15 +278,15 @@ impl CookieContext{
 				query.append_pair("version",version.to_string().as_str());
 			}
 		}
-		let resp=self.get(url).await.map_err(DownloadError::Reqwest)?;
+		let body=self.get(url).await.map_err(GetError::Reqwest)?
-
+		.error_for_status().map_err(GetError::Reqwest)?
-		let body=resp.bytes().await.map_err(DownloadError::Reqwest)?;
+		.bytes().await.map_err(GetError::Reqwest)?;
 
 		match maybe_gzip_decode(&mut std::io::Cursor::new(body)){
 			Ok(ReaderType::GZip(readable))=>read_readable(readable),
 			Ok(ReaderType::Raw(readable))=>read_readable(readable),
 			Err(e)=>Err(e),
-		}.map_err(DownloadError::IO)
+		}.map_err(GetError::IO)
 	}
 	pub async fn get_asset_versions_page(&self,config:AssetVersionsPageRequest)->Result<AssetVersionsPageResponse,AssetVersionsPageError>{
 		let mut url=reqwest::Url::parse(format!("https://develop.roblox.com/v1/assets/{}/saved-versions",config.asset_id).as_str()).map_err(AssetVersionsPageError::ParseError)?;
@@ -302,10 +301,11 @@ impl CookieContext{
 			}
 		}
 
-		Ok(self.get(url).await.map_err(AssetVersionsPageError::Reqwest)?
+		self.get(url).await.map_err(AssetVersionsPageError::Reqwest)?
-		.json::<AssetVersionsPageResponse>().await.map_err(AssetVersionsPageError::Reqwest)?)
+		.error_for_status().map_err(AssetVersionsPageError::Reqwest)?
+		.json::<AssetVersionsPageResponse>().await.map_err(AssetVersionsPageError::Reqwest)
 	}
-	pub async fn inventory_page(&self,config:InventoryPageRequest)->Result<InventoryPageResponse,InventoryPageError>{
+	pub async fn get_inventory_page(&self,config:InventoryPageRequest)->Result<InventoryPageResponse,InventoryPageError>{
 		let mut url=reqwest::Url::parse(format!("https://apis.roblox.com/toolbox-service/v1/creations/group/{}/10?limit=50",config.group).as_str()).map_err(InventoryPageError::ParseError)?;
 		//url borrow scope
 		{
@@ -315,7 +315,8 @@ impl CookieContext{
 			}
 		}
 
-		Ok(self.get(url).await.map_err(InventoryPageError::Reqwest)?
+		self.get(url).await.map_err(InventoryPageError::Reqwest)?
-		.json::<InventoryPageResponse>().await.map_err(InventoryPageError::Reqwest)?)
+		.error_for_status().map_err(InventoryPageError::Reqwest)?
+		.json::<InventoryPageResponse>().await.map_err(InventoryPageError::Reqwest)
 	}
 }

rox_compiler/src/common.rs

@@ -19,15 +19,15 @@ impl PropertiesOverride{
 impl std::fmt::Display for PropertiesOverride{
 	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
 		if let Some(name)=self.name.as_deref(){
-			writeln!(f,"--!Properties.Name = \"{}\"",name)?;
+			writeln!(f,"-- Properties.Name = \"{}\"",name)?;
 		}
 		if let Some(class)=self.class.as_deref(){
-			writeln!(f,"--!Properties.ClassName = \"{}\"",class)?;
+			writeln!(f,"-- Properties.ClassName = \"{}\"",class)?;
 		}
 		Ok(())
 	}
 }
 
-pub(crate) fn sanitize<'a>(s:&'a str)->std::borrow::Cow<'a,str>{
+pub(crate) fn sanitize(s:&str)->std::borrow::Cow<'_,str>{
-	lazy_regex::regex!(r"[^A-z0-9.-]").replace_all(s,"_")
+	lazy_regex::regex!(r"[^A-Za-z0-9.-]").replace_all(s,"_")
 }

rox_compiler/src/compile.rs

@@ -1,4 +1,4 @@
-use std::path::PathBuf;
+use std::path::{Path,PathBuf};
 use futures::{StreamExt, TryStreamExt};
 use tokio::io::AsyncReadExt;
 
@@ -55,9 +55,9 @@ struct QuerySingle{
 	script:QueryHandle,
 }
 impl QuerySingle{
-	fn rox(search_path:&PathBuf,search_name:&str)->Self{
+	fn rox(search_path:&Path,search_name:&str)->Self{
 		Self{
-			script:tokio::spawn(get_file_async(search_path.clone(),format!("{}.lua",search_name)))
+			script:tokio::spawn(get_file_async(search_path.to_owned(),format!("{}.lua",search_name)))
 		}
 	}
 }
@@ -76,7 +76,7 @@ struct QueryTriple{
 	client:QueryHandle,
 }
 impl QueryTriple{
-	fn rox_rojo(search_path:&PathBuf,search_name:&str,search_module:bool)->Self{
+	fn rox_rojo(search_path:&Path,search_name:&str,search_module:bool)->Self{
 		//this should be implemented as constructors of Triplet and Quadruplet to fully support Trey's suggestion
 		let module_name=if search_module{
 			format!("{}.module.lua",search_name)
@@ -84,12 +84,12 @@ impl QueryTriple{
 			format!("{}.lua",search_name)
 		};
 		Self{
-			module:tokio::spawn(get_file_async(search_path.clone(),module_name)),
+			module:tokio::spawn(get_file_async(search_path.to_owned(),module_name)),
-			server:tokio::spawn(get_file_async(search_path.clone(),format!("{}.server.lua",search_name))),
+			server:tokio::spawn(get_file_async(search_path.to_owned(),format!("{}.server.lua",search_name))),
-			client:tokio::spawn(get_file_async(search_path.clone(),format!("{}.client.lua",search_name))),
+			client:tokio::spawn(get_file_async(search_path.to_owned(),format!("{}.client.lua",search_name))),
 		}
 	}
-	fn rojo(search_path:&PathBuf)->Self{
+	fn rojo(search_path:&Path)->Self{
 		QueryTriple::rox_rojo(search_path,"init",false)
 	}
 }
@@ -146,9 +146,9 @@ impl Query for QueryTriple{
 	async fn resolve(self)->QueryHintResult{
 		let (module,server,client)=tokio::join!(self.module,self.server,self.client);
 		mega_triple_join((
-			module.map_err(|e|QueryResolveError::JoinError(e))?.map(|file|FileHint{file,hint:ScriptHint::ModuleScript}),
+			module.map_err(QueryResolveError::JoinError)?.map(|file|FileHint{file,hint:ScriptHint::ModuleScript}),
-			server.map_err(|e|QueryResolveError::JoinError(e))?.map(|file|FileHint{file,hint:ScriptHint::Script}),
+			server.map_err(QueryResolveError::JoinError)?.map(|file|FileHint{file,hint:ScriptHint::Script}),
-			client.map_err(|e|QueryResolveError::JoinError(e))?.map(|file|FileHint{file,hint:ScriptHint::LocalScript}),
+			client.map_err(QueryResolveError::JoinError)?.map(|file|FileHint{file,hint:ScriptHint::LocalScript}),
 		))
 	}
 }
@@ -159,7 +159,7 @@ struct QueryQuad{
 	client:QueryHandle,
 }
 impl QueryQuad{
-	fn rox_rojo(search_path:&PathBuf,search_name:&str)->Self{
+	fn rox_rojo(search_path:&Path,search_name:&str)->Self{
 		let fill=QueryTriple::rox_rojo(search_path,search_name,true);
 		Self{
 			module_implicit:QuerySingle::rox(search_path,search_name).script,//Script.lua
@@ -173,10 +173,10 @@ impl Query for QueryQuad{
 	async fn resolve(self)->QueryHintResult{
 		let (module_implicit,module_explicit,server,client)=tokio::join!(self.module_implicit,self.module_explicit,self.server,self.client);
 		mega_quadruple_join((
-			module_implicit.map_err(|e|QueryResolveError::JoinError(e))?.map(|file|FileHint{file,hint:ScriptHint::ModuleScript}),
+			module_implicit.map_err(QueryResolveError::JoinError)?.map(|file|FileHint{file,hint:ScriptHint::ModuleScript}),
-			module_explicit.map_err(|e|QueryResolveError::JoinError(e))?.map(|file|FileHint{file,hint:ScriptHint::ModuleScript}),
+			module_explicit.map_err(QueryResolveError::JoinError)?.map(|file|FileHint{file,hint:ScriptHint::ModuleScript}),
-			server.map_err(|e|QueryResolveError::JoinError(e))?.map(|file|FileHint{file,hint:ScriptHint::Script}),
+			server.map_err(QueryResolveError::JoinError)?.map(|file|FileHint{file,hint:ScriptHint::Script}),
-			client.map_err(|e|QueryResolveError::JoinError(e))?.map(|file|FileHint{file,hint:ScriptHint::LocalScript}),
+			client.map_err(QueryResolveError::JoinError)?.map(|file|FileHint{file,hint:ScriptHint::LocalScript}),
 		))
 	}
 }
@@ -203,7 +203,7 @@ impl ScriptWithOverrides{
 		let mut count=0;
 		for line in source.lines(){
 			//only string type properties are supported atm
-			if let Some(captures)=lazy_regex::regex!(r#"^\-\-\!\s*Properties\.([A-z]\w*)\s*\=\s*"(\w+)"$"#)
+			if let Some(captures)=lazy_regex::regex!(r#"^\-\-\s*Properties\.([A-Za-z]\w*)\s*\=\s*"(\w+)"$"#)
 			.captures(line){
 				count+=line.len();
 				match &captures[1]{
@@ -248,7 +248,7 @@ pub enum CompileNodeError{
 		extension:String,
 		style:Option<Style>,
 	},
-	NoExtension,
+	UnknownExtension,
 }
 impl std::fmt::Display for CompileNodeError{
 	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
@@ -338,12 +338,9 @@ impl CompileNode{
 		.into_string()
 		.map_err(CompileNodeError::FileName)?;
 		//reject goobers
-		let is_goober=match style{
+		let is_goober=matches!(style,Some(Style::Rojo));
-			Some(Style::Rojo)=>true,
-			_=>false,
-		};
 		let (ext_len,file_discernment)={
-			if let Some(captures)=lazy_regex::regex!(r"^.*(.module.lua|.client.lua|.server.lua|.rbxmx|.lua)$")
+			if let Some(captures)=lazy_regex::regex!(r"^.*(\.module\.lua|\.client\.lua|\.server\.lua)$")
 			.captures(file_name.as_str()){
 				let ext=&captures[1];
 				(ext.len(),match ext{
@@ -355,6 +352,12 @@ impl CompileNode{
 					},
 					".client.lua"=>FileDiscernment::Script(ScriptHint::LocalScript),
 					".server.lua"=>FileDiscernment::Script(ScriptHint::Script),
+					_=>panic!("Regex failed"),
+				})
+			}else if let Some(captures)=lazy_regex::regex!(r"^.*(\.rbxmx|\.lua)$")
+			.captures(file_name.as_str()){
+				let ext=&captures[1];
+				(ext.len(),match ext{
 					".rbxmx"=>{
 						if is_goober{
 							Err(CompileNodeError::ExtensionNotSupportedInStyle{extension:ext.to_owned(),style})?;
@@ -365,7 +368,7 @@ impl CompileNode{
 					_=>panic!("Regex failed"),
 				})
 			}else{
-				return Err(CompileNodeError::NoExtension);
+				return Err(CompileNodeError::UnknownExtension);
 			}
 		};
 		file_name.truncate(file_name.len()-ext_len);
@@ -433,7 +436,7 @@ impl std::error::Error for CompileError{}
 
 pub async fn compile(config:CompileConfig,mut dom:&mut rbx_dom_weak::WeakDom)->Result<(),CompileError>{
 	//hack to traverse root folder as the root object
-	dom.root_mut().name="src".to_owned();
+	"src".clone_into(&mut dom.root_mut().name);
 	//add in scripts and models
 	let mut folder=config.input_folder.clone();
 	let mut stack:Vec<CompileStackInstruction>=vec![CompileStackInstruction::TraverseReferent(dom.root_ref(),None)];
@@ -453,9 +456,9 @@ pub async fn compile(config:CompileConfig,mut dom:&mut rbx_dom_weak::WeakDom)->R
 					let mut exist_names:std::collections::HashSet<String>={
 						let item=dom.get_by_ref(item_ref).ok_or(CompileError::NullChildRef)?;
 						//push existing dom children objects onto stack (unrelated to exist_names)
-						stack.extend(item.children().into_iter().map(|&referent|CompileStackInstruction::TraverseReferent(referent,None)));
+						stack.extend(item.children().iter().map(|&referent|CompileStackInstruction::TraverseReferent(referent,None)));
 						//get names of existing objects
-						item.children().into_iter().map(|&child_ref|{
+						item.children().iter().map(|&child_ref|{
 							let child=dom.get_by_ref(child_ref).ok_or(CompileError::NullChildRef)?;
 							Ok::<_,CompileError>(sanitize(child.name.as_str()).to_string())
 						}).collect::<Result<_,CompileError>>()?
@@ -472,7 +475,7 @@ pub async fn compile(config:CompileConfig,mut dom:&mut rbx_dom_weak::WeakDom)->R
 						let ret1={
 							//capture a scoped mutable reference so we can forward dir to the next call even on an error
 							let dir2=&mut dir1;
-							(||async move{//error catcher so I can use ?
+							async move{//error catcher so I can use ?
 								let ret2=if let Some(entry)=dir2.next_entry().await?{
 									//cull early even if supporting things with identical names is possible
 									if exist_names.contains(entry.file_name().to_str().unwrap()){
@@ -484,7 +487,7 @@ pub async fn compile(config:CompileConfig,mut dom:&mut rbx_dom_weak::WeakDom)->R
 									TooComplicated::Stop
 								};
 								Ok(ret2)
-							})().await
+							}.await
 						};
 						match ret1{
 							Ok(TooComplicated::Stop)=>None,
@@ -500,10 +503,19 @@ pub async fn compile(config:CompileConfig,mut dom:&mut rbx_dom_weak::WeakDom)->R
 							Ok(Some(entry))=>tokio::spawn(async move{
 								let met=entry.metadata().await.map_err(CompileError::IO)?;
 								//discern that bad boy
-								let compile_class=match met.is_dir(){
+								let compile_class={
+									let result=match met.is_dir(){
 										true=>CompileNode::from_folder(&entry,style).await,
 										false=>CompileNode::from_file(&entry,style).await,
-								}.map_err(CompileError::CompileNode)?;
+									};
+									match result{
+										Ok(compile_class)=>compile_class,
+										Err(e)=>{
+											println!("Ignoring file {entry:?} due to error {e}");
+											return Ok(None);
+										},
+									}
+								};
 								//prepare data structure
 								Ok(Some((compile_class.blacklist,match compile_class.class{
 									CompileClass::Folder=>PreparedData::Builder(rbx_dom_weak::InstanceBuilder::new("Folder").with_name(compile_class.name.as_str())),

rox_compiler/src/decompile.rs

@@ -147,10 +147,7 @@ impl DecompiledContext{
 				"Model"=>Class::Model,
 				_=>Class::Folder,
 			};
-			let skip=match class{
+			let skip=class==Class::Model;
-				Class::Model=>true,
-				_=>false,
-			};
 			if let Some(parent_node)=tree_refs.get_mut(&item.parent()){
 				let referent=item.referent();
 				let node=TreeNode::new(item.name.clone(),referent,parent_node.referent,class);
@@ -182,14 +179,14 @@ impl DecompiledContext{
 						if node.class==Class::Folder&&script_count!=0{
 							node.class=Class::Model
 						}
-						if node.class==Class::Folder&&node.children.len()==0{
+						if node.class==Class::Folder&&node.children.is_empty(){
 							delete=Some(node.parent);
 						}else{
 							//how the hell do I do this better without recursion
-							let is_script=match node.class{
+							let is_script=matches!(
-								Class::ModuleScript|Class::LocalScript|Class::Script=>true,
+								node.class,
-								_=>false,
+								Class::ModuleScript|Class::LocalScript|Class::Script
-							};
+							);
 							//stack is popped from back
 							if is_script{
 								stack.push(TrimStackInstruction::DecrementScript);
@@ -237,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.len()!=0;
+					let has_children=!node.children.is_empty();
 					match node.class{
 						Class::Folder=>(),
 						Class::ModuleScript=>(),//.lua files are ModuleScript by default
@@ -297,7 +294,7 @@ impl DecompiledContext{
 			let write_models=config.write_models;
 			let write_scripts=config.write_scripts;
 			let results:Vec<Result<(),WriteError>>=rayon::iter::ParallelIterator::collect(rayon::iter::ParallelIterator::map(rayon::iter::IntoParallelIterator::into_par_iter(write_queue),|(write_path,node,node_name_override,properties,style)|{
-				write_item(&dom,write_path,node,node_name_override,properties,style,write_models,write_scripts)
+				write_item(dom,write_path,node,node_name_override,properties,style,write_models,write_scripts)
 			}));
 			for result in results{
 				result?;

src/main.rs

@@ -1,9 +1,9 @@
 use std::{io::Read,path::PathBuf};
 use clap::{Args,Parser,Subcommand};
-use anyhow::Result as AResult;
+use anyhow::{anyhow,Result as AResult};
 use futures::StreamExt;
-use rbx_asset::cloud::{ApiKey,CloudContext,InventoryItem};
+use rbx_asset::cloud::{ApiKey,CloudContext};
-use rbx_asset::cookie::{Cookie,CookieContext,AssetVersion};
+use rbx_asset::cookie::{Cookie,CookieContext,AssetVersion,InventoryItem};
 
 type AssetID=u64;
 type AssetIDFileMap=Vec<(AssetID,PathBuf)>;
@@ -25,7 +25,10 @@ enum Commands{
 	DownloadDecompile(DownloadDecompileSubcommand),
 	DownloadGroupInventoryJson(DownloadGroupInventoryJsonSubcommand),
 	CreateAsset(CreateAssetSubcommand),
+	CreateAssetMedia(CreateAssetMediaSubcommand),
+	CreateAssetMedias(CreateAssetMediasSubcommand),
 	UploadAsset(UpdateAssetSubcommand),
+	UploadAssetMedia(UpdateAssetMediaSubcommand),
 	UploadPlace(UpdatePlaceSubcommand),
 	Compile(CompileSubcommand),
 	CompileUploadAsset(CompileUploadAssetSubcommand),
@@ -35,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)]
@@ -54,19 +58,21 @@ struct DownloadHistorySubcommand{
 	#[arg(long)]
 	end_version:Option<u64>,
 }
+/// Download a single asset by id.
 #[derive(Args)]
 struct DownloadSubcommand{
-	#[arg(long,group="api_key",required=true)]
+	#[arg(long,group="cookie",required=true)]
-	api_key_literal:Option<String>,
+	cookie_literal:Option<String>,
-	#[arg(long,group="api_key",required=true)]
+	#[arg(long,group="cookie",required=true)]
-	api_key_envvar:Option<String>,
+	cookie_envvar:Option<String>,
-	#[arg(long,group="api_key",required=true)]
+	#[arg(long,group="cookie",required=true)]
-	api_key_file:Option<PathBuf>,
+	cookie_file:Option<PathBuf>,
 	#[arg(long)]
 	output_folder:Option<PathBuf>,
 	#[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)]
@@ -80,8 +86,31 @@ 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)]
+	cookie_literal:Option<String>,
+	#[arg(long,group="cookie",required=true)]
+	cookie_envvar:Option<String>,
+	#[arg(long,group="cookie",required=true)]
+	cookie_file:Option<PathBuf>,
+	#[arg(long)]
+	group_id:Option<u64>,
+	#[arg(long)]
+	input_file:PathBuf,
+	#[arg(long)]
+	model_name:String,
+	#[arg(long)]
+	description:Option<String>,
+	#[arg(long)]
+	free_model:Option<bool>,
+	#[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)]
 	api_key_literal:Option<String>,
 	#[arg(long,group="api_key",required=true)]
@@ -95,12 +124,68 @@ struct CreateAssetSubcommand{
 	#[arg(long)]
 	input_file:PathBuf,
 	#[arg(long)]
-	creator_user_id:u64,
+	asset_type:AssetType,
-	#[arg(long)]
+	#[arg(long,group="creator",required=true)]
+	creator_user_id:Option<u64>,
+	#[arg(long,group="creator",required=true)]
 	creator_group_id:Option<u64>,
+	/// Expected price limits how much robux can be spent to create the asset (defaults to 0)
+	#[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)]
+struct CreateAssetMediasSubcommand{
+	#[arg(long,group="api_key",required=true)]
+	api_key_literal:Option<String>,
+	#[arg(long,group="api_key",required=true)]
+	api_key_envvar:Option<String>,
+	#[arg(long,group="api_key",required=true)]
+	api_key_file:Option<PathBuf>,
+	#[arg(long,group="cookie",required=true)]
+	cookie_literal:Option<String>,
+	#[arg(long,group="cookie",required=true)]
+	cookie_envvar:Option<String>,
+	#[arg(long,group="cookie",required=true)]
+	cookie_file:Option<PathBuf>,
+	#[arg(long)]
+	description:Option<String>,
+	#[arg(long,group="creator",required=true)]
+	creator_user_id:Option<u64>,
+	#[arg(long,group="creator",required=true)]
+	creator_group_id:Option<u64>,
+	/// Expected price limits how much robux can be spent to create the asset (defaults to 0)
+	#[arg(long)]
+	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)]
+	asset_id:AssetID,
+	#[arg(long,group="cookie",required=true)]
+	cookie_literal:Option<String>,
+	#[arg(long,group="cookie",required=true)]
+	cookie_envvar:Option<String>,
+	#[arg(long,group="cookie",required=true)]
+	cookie_file:Option<PathBuf>,
+	#[arg(long)]
+	group_id:Option<u64>,
+	#[arg(long)]
+	input_file:PathBuf,
+	#[arg(long)]
+	change_name:Option<String>,
+	#[arg(long)]
+	change_description:Option<String>,
+	#[arg(long)]
+	change_free_model:Option<bool>,
+	#[arg(long)]
+	change_allow_comments:Option<bool>,
+}
+/// Upload a media file (.jpg, .png) to an existing asset.
+#[derive(Args)]
+struct UpdateAssetMediaSubcommand{
 	#[arg(long)]
 	asset_id:AssetID,
 	#[arg(long,group="api_key",required=true)]
@@ -112,6 +197,7 @@ struct UpdateAssetSubcommand{
 	#[arg(long)]
 	input_file:PathBuf,
 }
+/// Upload a place file (.rbxl, .rbxlx) to an existing place.
 #[derive(Args)]
 struct UpdatePlaceSubcommand{
 	#[arg(long)]
@@ -127,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)]
@@ -138,18 +225,19 @@ 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)]
 	asset_id:AssetID,
-	#[arg(long,group="api_key",required=true)]
+	#[arg(long,group="cookie",required=true)]
-	api_key_literal:Option<String>,
+	cookie_literal:Option<String>,
-	#[arg(long,group="api_key",required=true)]
+	#[arg(long,group="cookie",required=true)]
-	api_key_envvar:Option<String>,
+	cookie_envvar:Option<String>,
-	#[arg(long,group="api_key",required=true)]
+	#[arg(long,group="cookie",required=true)]
-	api_key_file:Option<PathBuf>,
+	cookie_file:Option<PathBuf>,
 	#[arg(long)]
-	input_file:PathBuf,
+	group_id:Option<u64>,
 	#[arg(long)]
 	input_folder:Option<PathBuf>,
 	#[arg(long)]
@@ -157,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)]
@@ -170,14 +259,13 @@ struct CompileUploadPlaceSubcommand{
 	#[arg(long,group="api_key",required=true)]
 	api_key_file:Option<PathBuf>,
 	#[arg(long)]
-	input_file:PathBuf,
-	#[arg(long)]
 	input_folder:Option<PathBuf>,
 	#[arg(long)]
 	style:Option<Style>,
 	#[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)]
@@ -193,14 +281,15 @@ 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="api_key",required=true)]
+	#[arg(long,group="cookie",required=true)]
-	api_key_literal:Option<String>,
+	cookie_literal:Option<String>,
-	#[arg(long,group="api_key",required=true)]
+	#[arg(long,group="cookie",required=true)]
-	api_key_envvar:Option<String>,
+	cookie_envvar:Option<String>,
-	#[arg(long,group="api_key",required=true)]
+	#[arg(long,group="cookie",required=true)]
-	api_key_file:Option<PathBuf>,
+	cookie_file:Option<PathBuf>,
 	#[arg(long)]
 	output_folder:Option<PathBuf>,
 	#[arg(long)]
@@ -214,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)]
@@ -233,18 +323,19 @@ 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)]
 	asset_id:AssetID,
-	#[arg(long,group="api_key",required=true)]
+	#[arg(long,group="cookie",required=true)]
-	api_key_literal:Option<String>,
+	cookie_literal:Option<String>,
-	#[arg(long,group="api_key",required=true)]
+	#[arg(long,group="cookie",required=true)]
-	api_key_envvar:Option<String>,
+	cookie_envvar:Option<String>,
-	#[arg(long,group="api_key",required=true)]
+	#[arg(long,group="cookie",required=true)]
-	api_key_file:Option<PathBuf>,
+	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)]
@@ -274,6 +365,21 @@ impl Style{
 		}
 	}
 }
+#[derive(Clone,Copy,Debug,clap::ValueEnum)]
+enum AssetType{
+	Audio,
+	Decal,
+	Model,
+}
+impl AssetType{
+	fn cloud(&self)->rbx_asset::cloud::AssetType{
+		match self{
+			AssetType::Audio=>rbx_asset::cloud::AssetType::Audio,
+			AssetType::Decal=>rbx_asset::cloud::AssetType::Decal,
+			AssetType::Model=>rbx_asset::cloud::AssetType::Model,
+		}
+	}
+}
 
 #[tokio::main]
 async fn main()->AResult<()>{
@@ -294,10 +400,10 @@ async fn main()->AResult<()>{
 		Commands::Download(subcommand)=>{
 			let output_folder=subcommand.output_folder.unwrap_or_else(||std::env::current_dir().unwrap());
 			download_list(
-				api_key_from_args(
+				cookie_from_args(
-					subcommand.api_key_literal,
+					subcommand.cookie_literal,
-					subcommand.api_key_envvar,
+					subcommand.cookie_envvar,
-					subcommand.api_key_file,
+					subcommand.cookie_file,
 				).await?,
 				subcommand.asset_ids.into_iter().map(|asset_id|{
 					let mut path=output_folder.clone();
@@ -308,10 +414,10 @@ async fn main()->AResult<()>{
 		},
 		Commands::DownloadDecompile(subcommand)=>{
 			download_decompile(DownloadDecompileConfig{
-				api_key:api_key_from_args(
+				cookie:cookie_from_args(
-					subcommand.api_key_literal,
+					subcommand.cookie_literal,
-					subcommand.api_key_envvar,
+					subcommand.cookie_envvar,
-					subcommand.api_key_file,
+					subcommand.cookie_file,
 				).await?,
 				asset_id:subcommand.asset_id,
 				output_folder:subcommand.output_folder.unwrap_or_else(||std::env::current_dir().unwrap()),
@@ -330,19 +436,71 @@ async fn main()->AResult<()>{
 			subcommand.group,
 			subcommand.output_folder.unwrap_or_else(||std::env::current_dir().unwrap()),
 		).await,
-		Commands::CreateAsset(subcommand)=>create(CreateConfig{
+		Commands::CreateAsset(subcommand)=>create_asset(CreateAssetConfig{
+			cookie:cookie_from_args(
+					subcommand.cookie_literal,
+					subcommand.cookie_envvar,
+					subcommand.cookie_file,
+				).await?,
+			group:subcommand.group_id,
+			input_file:subcommand.input_file,
+			model_name:subcommand.model_name,
+			description:subcommand.description.unwrap_or_else(||String::with_capacity(0)),
+			free_model:subcommand.free_model.unwrap_or(false),
+			allow_comments:subcommand.allow_comments.unwrap_or(false),
+		}).await,
+		Commands::CreateAssetMedia(subcommand)=>create_asset_media(CreateAssetMediaConfig{
 			api_key:api_key_from_args(
 				subcommand.api_key_literal,
 				subcommand.api_key_envvar,
 				subcommand.api_key_file,
 			).await?,
-			creator_user_id:subcommand.creator_user_id,
+			creator:match (subcommand.creator_user_id,subcommand.creator_group_id){
-			creator_group_id:subcommand.creator_group_id,
+				(Some(user_id),None)=>rbx_asset::cloud::Creator::userId(user_id.to_string()),
+				(None,Some(group_id))=>rbx_asset::cloud::Creator::groupId(group_id.to_string()),
+				other=>Err(anyhow!("Invalid creator {other:?}"))?,
+			},
 			input_file:subcommand.input_file,
+			asset_type:subcommand.asset_type.cloud(),
 			model_name:subcommand.model_name,
 			description:subcommand.description.unwrap_or_else(||String::with_capacity(0)),
+			expected_price:subcommand.expected_price,
+		}).await,
+		Commands::CreateAssetMedias(subcommand)=>create_asset_medias(CreateAssetMediasConfig{
+			api_key:api_key_from_args(
+				subcommand.api_key_literal,
+				subcommand.api_key_envvar,
+				subcommand.api_key_file,
+			).await?,
+			cookie:cookie_from_args(
+				subcommand.cookie_literal,
+				subcommand.cookie_envvar,
+				subcommand.cookie_file,
+			).await?,
+			creator:match (subcommand.creator_user_id,subcommand.creator_group_id){
+				(Some(user_id),None)=>rbx_asset::cloud::Creator::userId(user_id.to_string()),
+				(None,Some(group_id))=>rbx_asset::cloud::Creator::groupId(group_id.to_string()),
+				other=>Err(anyhow!("Invalid creator {other:?}"))?,
+			},
+			description:subcommand.description.unwrap_or_else(||String::with_capacity(0)),
+			input_files:subcommand.input_files,
+			expected_price:subcommand.expected_price,
 		}).await,
 		Commands::UploadAsset(subcommand)=>upload_asset(UploadAssetConfig{
+			cookie:cookie_from_args(
+					subcommand.cookie_literal,
+					subcommand.cookie_envvar,
+					subcommand.cookie_file,
+				).await?,
+			asset_id:subcommand.asset_id,
+			group_id:subcommand.group_id,
+			input_file:subcommand.input_file,
+			change_name:subcommand.change_name,
+			change_description:subcommand.change_description,
+			change_free_model:subcommand.change_free_model,
+			change_allow_comments:subcommand.change_allow_comments,
+		}).await,
+		Commands::UploadAssetMedia(subcommand)=>upload_asset_media(UploadAssetMediaConfig{
 			api_key:api_key_from_args(
 				subcommand.api_key_literal,
 				subcommand.api_key_envvar,
@@ -371,12 +529,13 @@ async fn main()->AResult<()>{
 			input_folder:subcommand.input_folder.unwrap_or_else(||std::env::current_dir().unwrap()),
 			template:subcommand.template,
 			style:subcommand.style.map(|s|s.rox()),
-			api_key:api_key_from_args(
+			cookie:cookie_from_args(
-				subcommand.api_key_literal,
+				subcommand.cookie_literal,
-				subcommand.api_key_envvar,
+				subcommand.cookie_envvar,
-				subcommand.api_key_file,
+				subcommand.cookie_file,
 			).await?,
 			asset_id:subcommand.asset_id,
+			group_id:subcommand.group_id,
 		}).await,
 		Commands::CompileUploadPlace(subcommand)=>compile_upload_place(CompileUploadPlaceConfig{
 			input_folder:subcommand.input_folder.unwrap_or_else(||std::env::current_dir().unwrap()),
@@ -402,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),
@@ -411,13 +570,13 @@ async fn main()->AResult<()>{
 		Commands::DownloadAndDecompileHistoryIntoGit(subcommand)=>download_and_decompile_history_into_git(DownloadAndDecompileHistoryConfig{
 			git_committer_name:subcommand.git_committer_name,
 			git_committer_email:subcommand.git_committer_email,
-			api_key:api_key_from_args(
+			cookie:cookie_from_args(
-				subcommand.api_key_literal,
+				subcommand.cookie_literal,
-				subcommand.api_key_envvar,
+				subcommand.cookie_envvar,
-				subcommand.api_key_file,
+				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),
@@ -431,9 +590,9 @@ async fn cookie_from_args(literal:Option<String>,environment:Option<String>,file
 		(Some(cookie_literal),None,None)=>cookie_literal,
 		(None,Some(cookie_environment),None)=>std::env::var(cookie_environment)?,
 		(None,None,Some(cookie_file))=>tokio::fs::read_to_string(cookie_file).await?,
-		_=>Err(anyhow::Error::msg("Illegal api key argument triple"))?,
+		_=>Err(anyhow::Error::msg("Illegal cookie argument triple"))?,
 	};
-	Ok(Cookie::new(cookie))
+	Ok(Cookie::new(format!(".ROBLOSECURITY={cookie}")))
 }
 async fn api_key_from_args(literal:Option<String>,environment:Option<String>,file:Option<PathBuf>)->AResult<ApiKey>{
 	let api_key=match (literal,environment,file){
@@ -445,46 +604,253 @@ async fn api_key_from_args(literal:Option<String>,environment:Option<String>,fil
 	Ok(ApiKey::new(api_key))
 }
 
-struct CreateConfig{
+struct CreateAssetConfig{
-	api_key:ApiKey,
+	cookie:Cookie,
 	model_name:String,
 	description:String,
 	input_file:PathBuf,
-	creator_user_id:u64,
+	group:Option<u64>,
-	creator_group_id:Option<u64>,
+	free_model:bool,
+	allow_comments:bool,
 }
 
-///This is hardcoded to create models atm
+async fn create_asset(config:CreateAssetConfig)->AResult<()>{
-async fn create(config:CreateConfig)->AResult<()>{
+	let resp=CookieContext::new(config.cookie)
-	let resp=CloudContext::new(config.api_key)
+	.create(rbx_asset::cookie::CreateRequest{
-	.create_asset(rbx_asset::cloud::CreateAssetRequest{
+		name:config.model_name,
-		assetType:rbx_asset::cloud::AssetType::Model,
-		displayName:config.model_name,
 		description:config.description,
-		creationContext:rbx_asset::cloud::CreationContext{
+		ispublic:config.free_model,
-			creator:rbx_asset::cloud::Creator{
+		allowComments:config.allow_comments,
-				userId:config.creator_user_id,
+		groupId:config.group,
-				groupId:config.creator_group_id.unwrap_or(0),
-			},
-			expectedPrice:0,
-		}
 	},tokio::fs::read(config.input_file).await?).await?;
 	println!("UploadResponse={:?}",resp);
 	Ok(())
 }
 
+struct CreateAssetMediaConfig{
+	api_key:ApiKey,
+	asset_type:rbx_asset::cloud::AssetType,
+	model_name:String,
+	description:String,
+	input_file:PathBuf,
+	creator:rbx_asset::cloud::Creator,
+	expected_price:Option<u64>,
+}
+
+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;
+	loop{
+		match asset_operation.try_get_asset(&context).await{
+			//try again when the operation is not done
+			Err(rbx_asset::cloud::AssetOperationError::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;
+	}
+}
+
+async fn create_asset_media(config:CreateAssetMediaConfig)->AResult<()>{
+	let context=CloudContext::new(config.api_key);
+	let asset_response=context
+	.create_asset(rbx_asset::cloud::CreateAssetRequest{
+		assetType:config.asset_type,
+		displayName:config.model_name,
+		description:config.description,
+		creationContext:rbx_asset::cloud::CreationContext{
+			creator:config.creator,
+			expectedPrice:Some(config.expected_price.unwrap_or(0)),
+		}
+	},tokio::fs::read(config.input_file).await?).await?;
+	//hardcode a 2 second sleep because roblox be slow
+	println!("Asset submitted, waiting 2s...");
+	tokio::time::sleep(std::time::Duration::from_secs(2)).await;
+	let asset=get_asset_exp_backoff(&context,&asset_response).await?;
+	println!("CreateResponse={:?}",asset);
+	Ok(())
+}
+
+// complex operation requires both api key and cookie! how horrible! roblox please fix!
+struct CreateAssetMediasConfig{
+	api_key:ApiKey,
+	cookie:Cookie,
+	description:String,
+	input_files:Vec<PathBuf>,
+	creator:rbx_asset::cloud::Creator,
+	expected_price:Option<u64>,
+}
+
+#[derive(Debug)]
+#[allow(dead_code)]
+enum CreateAssetMediasError{
+	NoFileStem(PathBuf),
+	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{
+		write!(f,"{self:?}")
+	}
+}
+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),
+	NoFirstInstance,
+	NoTextureProperty,
+	TexturePropertyInvalid,
+}
+impl std::fmt::Display for DownloadDecalError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for DownloadDecalError{}
+
+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()
+	//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()))?
+			.to_owned();
+			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,
+				//jpeg
+				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())))?,
+			};
+			context.create_asset(rbx_asset::cloud::CreateAssetRequest{
+				assetType:asset_type,
+				displayName:model_name,
+				description:description.clone(),
+				creationContext:rbx_asset::cloud::CreationContext{
+					creator:creator.clone(),
+					expectedPrice:expected_price,
+				}
+			},file).await.map_err(CreateAssetMediasError::Create)
+		}
+		.await)}
+	}))
+	//parallel requests
+	.buffer_unordered(CONCURRENT_REQUESTS)
+	//step 2: poll operation until it completes
+	.then(|(path,create_result)|{
+		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)
+		}
+		.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)?;
+			let file=cookie_context.get_asset(rbx_asset::cookie::GetAssetRequest{
+				asset_id:asset_response.assetId.parse().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))
+		}
+		.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(())
+}
+
 struct UploadAssetConfig{
+	cookie:Cookie,
+	asset_id:AssetID,
+	change_name:Option<String>,
+	change_description:Option<String>,
+	change_free_model:Option<bool>,
+	change_allow_comments:Option<bool>,
+	group_id:Option<u64>,
+	input_file:PathBuf,
+}
+async fn upload_asset(config:UploadAssetConfig)->AResult<()>{
+	let context=CookieContext::new(config.cookie);
+	let resp=context.upload(rbx_asset::cookie::UploadRequest{
+		assetid:config.asset_id,
+		name:config.change_name,
+		description:config.change_description,
+		ispublic:config.change_free_model,
+		allowComments:config.change_allow_comments,
+		groupId:config.group_id,
+	},tokio::fs::read(config.input_file).await?).await?;
+	println!("UploadResponse={:?}",resp);
+	Ok(())
+}
+
+struct UploadAssetMediaConfig{
 	api_key:ApiKey,
 	asset_id:u64,
 	input_file:PathBuf,
 }
-async fn upload_asset(config:UploadAssetConfig)->AResult<()>{
+async fn upload_asset_media(config:UploadAssetMediaConfig)->AResult<()>{
 	let context=CloudContext::new(config.api_key);
-	context.update_asset(rbx_asset::cloud::UpdateAssetRequest{
+	let resp=context.update_asset(rbx_asset::cloud::UpdateAssetRequest{
 		assetId:config.asset_id,
 		displayName:None,
 		description:None,
 	},tokio::fs::read(config.input_file).await?).await?;
+	println!("UploadResponse={:?}",resp);
 	Ok(())
 }
 
@@ -503,23 +869,20 @@ async fn upload_place(config:UploadPlaceConfig)->AResult<()>{
 	Ok(())
 }
 
-async fn download_list(api_key:ApiKey,asset_id_file_map:AssetIDFileMap)->AResult<()>{
+async fn download_list(cookie:Cookie,asset_id_file_map:AssetIDFileMap)->AResult<()>{
-	let context=CloudContext::new(api_key);
+	let context=CookieContext::new(cookie);
 	futures::stream::iter(asset_id_file_map.into_iter()
 	.map(|(asset_id,file)|{
 		let context=&context;
 		async move{
-			Ok((file,context.get_asset(rbx_asset::cloud::GetAssetRequest{asset_id,version:None}).await?))
+			Ok((file,context.get_asset(rbx_asset::cookie::GetAssetRequest{asset_id,version:None}).await?))
 		}
 	}))
 	.buffer_unordered(CONCURRENT_REQUESTS)
 	.for_each(|b:AResult<_>|async{
 			match b{
-				Ok((dest,data))=>{
+				Ok((dest,data))=>if let Err(e)=tokio::fs::write(dest,data).await{
-					match tokio::fs::write(dest,data).await{
+					eprintln!("fs error: {}",e);
-						Err(e)=>eprintln!("fs error: {}",e),
-						_=>(),
-					}
 				},
 				Err(e)=>eprintln!("dl error: {}",e),
 			}
@@ -531,7 +894,7 @@ async fn get_inventory_pages(context:&CookieContext,group:u64)->AResult<Vec<Inve
 	let mut cursor:Option<String>=None;
 	let mut asset_list=Vec::new();
 	loop{
-		let mut page=context.inventory_page(rbx_asset::cookie::InventoryPageRequest{group,cursor}).await?;
+		let mut page=context.get_inventory_page(rbx_asset::cookie::InventoryPageRequest{group,cursor}).await?;
 		asset_list.append(&mut page.data);
 		if page.nextPageCursor.is_none(){
 			break;
@@ -552,11 +915,11 @@ async fn download_group_inventory_json(cookie:Cookie,group:u64,output_folder:Pat
 	Ok(())
 }
 
-async fn get_version_history(context:&CloudContext,asset_id:AssetID)->AResult<Vec<AssetVersion>>{
+async fn get_version_history(context:&CookieContext,asset_id:AssetID)->AResult<Vec<AssetVersion>>{
 	let mut cursor:Option<String>=None;
 	let mut asset_list=Vec::new();
 	loop{
-		let mut page=context.get_asset_versions(rbx_asset::cloud::AssetVersionsRequest{asset_id,cursor}).await?;
+		let mut page=context.get_asset_versions_page(rbx_asset::cookie::AssetVersionsPageRequest{asset_id,cursor}).await?;
 		asset_list.append(&mut page.data);
 		if page.nextPageCursor.is_none(){
 			break;
@@ -651,7 +1014,7 @@ async fn download_history(mut config:DownloadHistoryConfig)->AResult<()>{
 			let mut path=output_folder.clone();
 			path.push(format!("{}_v{}.rbxl",config.asset_id,version_number));
 			join_set.spawn(async move{
-				let file=context.get_asset(rbx_asset::cloud::GetAssetRequest{asset_id:config.asset_id,version:Some(version_number)}).await?;
+				let file=context.get_asset(rbx_asset::cookie::GetAssetRequest{asset_id:config.asset_id,version:Some(version_number)}).await?;
 
 				tokio::fs::write(path,file).await?;
 
@@ -696,18 +1059,34 @@ async fn download_history(mut config:DownloadHistoryConfig)->AResult<()>{
 	Ok(())
 }
 
-fn load_dom<R:Read>(input:R)->AResult<rbx_dom_weak::WeakDom>{
+#[derive(Debug)]
+#[allow(dead_code)]
+enum LoadDomError{
+	IO(std::io::Error),
+	RbxBinary(rbx_binary::DecodeError),
+	RbxXml(rbx_xml::DecodeError),
+	UnknownRobloxFile([u8;4]),
+	UnsupportedFile,
+}
+impl std::fmt::Display for LoadDomError{
+	fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for LoadDomError{}
+
+fn load_dom<R:Read>(input:R)->Result<rbx_dom_weak::WeakDom,LoadDomError>{
 	let mut buf=std::io::BufReader::new(input);
-	let peek=std::io::BufRead::fill_buf(&mut buf)?;
+	let peek=std::io::BufRead::fill_buf(&mut buf).map_err(LoadDomError::IO)?;
 	match &peek[0..4]{
 		b"<rob"=>{
 			match &peek[4..8]{
-				b"lox!"=>rbx_binary::from_reader(buf).map_err(anyhow::Error::msg),
+				b"lox!"=>rbx_binary::from_reader(buf).map_err(LoadDomError::RbxBinary),
-				b"lox "=>rbx_xml::from_reader_default(buf).map_err(anyhow::Error::msg),
+				b"lox "=>rbx_xml::from_reader_default(buf).map_err(LoadDomError::RbxXml),
-				other=>Err(anyhow::Error::msg(format!("Unknown Roblox file type {:?}",other))),
+				other=>Err(LoadDomError::UnknownRobloxFile(other.try_into().unwrap())),
 			}
 		},
-		_=>Err(anyhow::Error::msg("unsupported file type")),
+		_=>Err(LoadDomError::UnsupportedFile),
 	}
 }
 
@@ -746,7 +1125,7 @@ async fn decompile(config:DecompileConfig)->AResult<()>{
 }
 
 struct DownloadDecompileConfig{
-	api_key:ApiKey,
+	cookie:Cookie,
 	asset_id:AssetID,
 	style:rox_compiler::Style,
 	output_folder:PathBuf,
@@ -756,8 +1135,8 @@ struct DownloadDecompileConfig{
 }
 
 async fn download_decompile(config:DownloadDecompileConfig)->AResult<()>{
-	let context=CloudContext::new(config.api_key);
+	let context=CookieContext::new(config.cookie);
-	let file=context.get_asset(rbx_asset::cloud::GetAssetRequest{asset_id:config.asset_id,version:None}).await?;
+	let file=context.get_asset(rbx_asset::cookie::GetAssetRequest{asset_id:config.asset_id,version:None}).await?;
 
 	let dom=load_dom(std::io::Cursor::new(file))?;
 	let context=rox_compiler::DecompiledContext::from_dom(dom);
@@ -819,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),
 		}
@@ -914,7 +1293,7 @@ async fn decompile_history_into_git(config:DecompileHistoryConfig)->AResult<()>{
 }
 
 struct DownloadAndDecompileHistoryConfig{
-	api_key:ApiKey,
+	cookie:Cookie,
 	asset_id:AssetID,
 	git_committer_name:String,
 	git_committer_email:String,
@@ -926,7 +1305,7 @@ struct DownloadAndDecompileHistoryConfig{
 }
 
 async fn download_and_decompile_history_into_git(config:DownloadAndDecompileHistoryConfig)->AResult<()>{
-	let context=CloudContext::new(config.api_key);
+	let context=CookieContext::new(config.cookie);
 
 	//poll paged list of all asset versions
 	let asset_list=get_version_history(&context,config.asset_id).await?;
@@ -939,7 +1318,7 @@ async fn download_and_decompile_history_into_git(config:DownloadAndDecompileHist
 	.map(|asset_version|{
 		let context=context.clone();
 		tokio::task::spawn(async move{
-			let file=context.get_asset(rbx_asset::cloud::GetAssetRequest{asset_id,version:Some(asset_version.assetVersionNumber)}).await?;
+			let file=context.get_asset(rbx_asset::cookie::GetAssetRequest{asset_id,version:Some(asset_version.assetVersionNumber)}).await?;
 			let dom=load_dom(std::io::Cursor::new(file))?;
 			Ok::<_,anyhow::Error>((asset_version,rox_compiler::DecompiledContext::from_dom(dom)))
 		})
@@ -997,7 +1376,8 @@ struct CompileUploadAssetConfig{
 	input_folder:PathBuf,
 	template:Option<PathBuf>,
 	style:Option<rox_compiler::Style>,
-	api_key:ApiKey,
+	cookie:Cookie,
+	group_id:Option<u64>,
 	asset_id:AssetID,
 }
 async fn compile_upload_asset(config:CompileUploadAssetConfig)->AResult<()>{
@@ -1017,12 +1397,16 @@ async fn compile_upload_asset(config:CompileUploadAssetConfig)->AResult<()>{
 	rbx_binary::to_writer(std::io::Cursor::new(&mut data),&dom,dom.root().children())?;
 
 	//upload it
-	let context=CloudContext::new(config.api_key);
+	let context=CookieContext::new(config.cookie);
-	context.update_asset(rbx_asset::cloud::UpdateAssetRequest{
+	let resp=context.upload(rbx_asset::cookie::UploadRequest{
-		assetId:config.asset_id,
+		groupId:config.group_id,
-		displayName:None,
+		assetid:config.asset_id,
+		name:None,
 		description:None,
+		ispublic:None,
+		allowComments:None,
 	},data).await?;
+	println!("UploadResponse={:?}",resp);
 	Ok(())
 }
 
@@ -1052,9 +1436,10 @@ async fn compile_upload_place(config:CompileUploadPlaceConfig)->AResult<()>{
 
 	//upload it
 	let context=CloudContext::new(config.api_key);
-	context.update_place(rbx_asset::cloud::UpdatePlaceRequest{
+	let resp=context.update_place(rbx_asset::cloud::UpdatePlaceRequest{
 		universeId:config.universe_id,
 		placeId:config.place_id,
 	},data).await?;
+	println!("UploadResponse={:?}",resp);
 	Ok(())
 }