no more cookie

Cargo.lock

@@ -110,7 +110,7 @@ checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
 
 [[package]]
 name = "asset-tool"
-version = "0.3.1"
+version = "0.3.4"
 dependencies = [
  "anyhow",
  "clap",
@@ -890,6 +890,16 @@ version = "0.3.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
 
+[[package]]
+name = "mime_guess"
+version = "2.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4192263c238a5f0d0c6bfd21f336a313a4ce1c450542449ca191bb657b4642ef"
+dependencies = [
+ "mime",
+ "unicase",
+]
+
 [[package]]
 name = "miniz_oxide"
 version = "0.7.4"
@@ -1156,12 +1166,13 @@ dependencies = [
 
 [[package]]
 name = "rbx_asset"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "chrono",
  "flate2",
  "reqwest",
  "serde",
+ "serde_json",
  "url",
 ]
 
@@ -1294,6 +1305,7 @@ dependencies = [
  "js-sys",
  "log",
  "mime",
+ "mime_guess",
  "native-tls",
  "once_cell",
  "percent-encoding",
@@ -1745,6 +1757,15 @@ version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
 
+[[package]]
+name = "unicase"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7d2d4dafb69621809a81864c9c1b864479e1235c0dd4e199924b9742439ed89"
+dependencies = [
+ "version_check",
+]
+
 [[package]]
 name = "unicode-bidi"
 version = "0.3.15"
@@ -1795,6 +1816,12 @@ version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
 
+[[package]]
+name = "version_check"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+
 [[package]]
 name = "want"
 version = "0.3.1"

Cargo.toml

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

rbx_asset/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rbx_asset"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 publish = ["strafesnet"]
 
@@ -9,6 +9,7 @@ publish = ["strafesnet"]
 [dependencies]
 chrono = { version = "0.4.38", features = ["serde"] }
 flate2 = "1.0.29"
-reqwest = { version = "0.12.4", features = ["json"] }
+reqwest = { version = "0.12.4", features = ["json","multipart"] }
 serde = { version = "1.0.199", features = ["derive"] }
+serde_json = "1.0.111"
 url = "2.5.0"

rbx_asset/src/context.rs

@@ -1,28 +1,22 @@
-#[derive(Debug)]
-pub enum PostError{
-	Reqwest(reqwest::Error),
-	CSRF,
-}
-impl std::fmt::Display for PostError{
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		write!(f,"{self:?}")
-	}
-}
-impl std::error::Error for PostError{}
-
 #[derive(Debug,serde::Deserialize,serde::Serialize)]
 #[allow(nonstandard_style,dead_code)]
-pub struct CreateRequest{
-	pub name:String,
+pub enum AssetType{
+	Audio,
+	Decal,
+	Model,
+}
+#[derive(Debug,serde::Deserialize,serde::Serialize)]
+#[allow(nonstandard_style,dead_code)]
+pub struct CreateAssetRequest{
+	pub assetType:AssetType,
+	pub creationContext:CreationContext,
 	pub description:String,
-	pub ispublic:bool,
-	pub allowComments:bool,
-	pub groupId:Option<u64>,
+	pub displayName:String,
 }
 #[derive(Debug)]
 pub enum CreateError{
 	ParseError(url::ParseError),
-	PostError(PostError),
+	SerializeError(serde_json::Error),
 	Reqwest(reqwest::Error),
 }
 impl std::fmt::Display for CreateError{
@@ -32,54 +26,96 @@ impl std::fmt::Display for CreateError{
 }
 impl std::error::Error for CreateError{}
 
+#[derive(Debug,serde::Deserialize,serde::Serialize)]
 #[allow(nonstandard_style,dead_code)]
-pub struct UploadRequest{
-	pub assetid:u64,
-	pub name:Option<String>,
+pub struct UpdateAssetRequest{
+	pub assetId:u64,
+	pub displayName:Option<String>,
 	pub description:Option<String>,
-	pub ispublic:Option<bool>,
-	pub allowComments:Option<bool>,
-	pub groupId:Option<u64>,
+}
+
+//woo nested roblox stuff
+#[derive(Debug,serde::Deserialize,serde::Serialize)]
+#[allow(nonstandard_style,dead_code)]
+pub struct Creator{
+	pub userId:u64,
+	pub groupId:u64,
+}
+#[derive(Debug,serde::Deserialize,serde::Serialize)]
+#[allow(nonstandard_style,dead_code)]
+pub struct CreationContext{
+	pub creator:Creator,
+	pub expectedPrice:u64,
+}
+#[derive(Debug,serde::Deserialize,serde::Serialize)]
+#[allow(nonstandard_style,dead_code)]
+pub enum ModerationResult{
+	MODERATION_STATE_REVIEWING,
+	MODERATION_STATE_REJECTED,
+	MODERATION_STATE_APPROVED,
+}
+#[derive(Debug,serde::Deserialize,serde::Serialize)]
+#[allow(nonstandard_style,dead_code)]
+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,
+	pub placeId:u64,
+}
+#[derive(Debug,serde::Deserialize,serde::Serialize)]
+#[allow(nonstandard_style,dead_code)]
+pub struct UpdatePlaceResponse{
+	pub versionNumber:u64,
 }
 #[derive(Debug)]
-pub enum UploadError{
+pub enum UpdateError{
 	ParseError(url::ParseError),
-	PostError(PostError),
+	SerializeError(serde_json::Error),
 	Reqwest(reqwest::Error),
-	AssetIdIsZero,
 }
-impl std::fmt::Display for UploadError{
+impl std::fmt::Display for UpdateError{
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		write!(f,"{self:?}")
 	}
 }
-impl std::error::Error for UploadError{}
-#[derive(Debug,serde::Deserialize,serde::Serialize)]
-#[allow(nonstandard_style,dead_code)]
-pub struct UploadResponse{
-	pub AssetId:u64,
-	pub AssetVersionId:u64,
-}
+impl std::error::Error for UpdateError{}
 
 #[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 HistoryPageRequest{
+pub struct AssetVersionsRequest{
 	pub asset_id:u64,
 	pub cursor:Option<String>,
 }
@@ -97,22 +133,22 @@ pub struct AssetVersion{
 }
 #[derive(serde::Deserialize)]
 #[allow(nonstandard_style,dead_code)]
-pub struct HistoryPageResponse{
+pub struct AssetVersionsResponse{
 	pub previousPageCursor:Option<String>,
 	pub nextPageCursor:Option<String>,
 	pub data:Vec<AssetVersion>,
 }
 #[derive(Debug)]
-pub enum HistoryPageError{
+pub enum AssetVersionsError{
 	ParseError(url::ParseError),
 	Reqwest(reqwest::Error),
 }
-impl std::fmt::Display for HistoryPageError{
+impl std::fmt::Display for AssetVersionsError{
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		write!(f,"{self:?}")
 	}
 }
-impl std::error::Error for HistoryPageError{}
+impl std::error::Error for AssetVersionsError{}
 
 pub struct InventoryPageRequest{
 	pub group:u64,
@@ -170,97 +206,69 @@ fn read_readable(mut readable:impl std::io::Read)->std::io::Result<Vec<u8>>{
 
 #[derive(Clone)]
 pub struct RobloxContext{
-	pub cookie:String,
+	pub api_key:String,
 	pub client:reqwest::Client,
 }
 
 impl RobloxContext{
-	pub fn new(cookie:String)->Self{
+	pub fn new(api_key:String)->Self{
 		Self{
-			cookie,
+			api_key,
 			client:reqwest::Client::new(),
 		}
 	}
 	async fn get(&self,url:impl reqwest::IntoUrl)->Result<reqwest::Response,reqwest::Error>{
 		self.client.get(url)
-		.header("Cookie",self.cookie.as_str())
+		.header("x-api-key",self.api_key.as_str())
 		.send().await
 	}
-	async fn post(&self,url:url::Url,body:impl Into<reqwest::Body>+Clone)->Result<reqwest::Response,PostError>{
-		let mut resp=self.client.post(url.clone())
-		.header("Cookie",self.cookie.as_str())
-		.body(body.clone())
-		.send().await.map_err(PostError::Reqwest)?;
-
-		//This is called a CSRF challenge apparently
-		if resp.status()==reqwest::StatusCode::FORBIDDEN{
-			if let Some(csrf_token)=resp.headers().get("X-CSRF-Token"){
-				resp=self.client.post(url)
-				.header("X-CSRF-Token",csrf_token)
-				.header("Cookie",self.cookie.as_str())
-				.body(body)
-				.send().await.map_err(PostError::Reqwest)?;
-			}else{
-				Err(PostError::CSRF)?;
-			}
-		}
-
-		Ok(resp)
+	async fn post(&self,url:url::Url,body:impl Into<reqwest::Body>+Clone)->Result<reqwest::Response,reqwest::Error>{
+		self.client.post(url)
+		.header("x-api-key",self.api_key.as_str())
+		.body(body)
+		.send().await
 	}
-	pub async fn create(&self,config:CreateRequest,body:impl Into<reqwest::Body>+Clone)->Result<UploadResponse,CreateError>{
-		let mut url=reqwest::Url::parse("https://data.roblox.com/Data/Upload.ashx?json=1&type=Model&genreTypeId=1").map_err(CreateError::ParseError)?;
-		//url borrow scope
-		{
-			let mut query=url.query_pairs_mut();//borrow here
-			//archaic roblox api uses 0 for new asset
-			query.append_pair("assetid","0");
-			query.append_pair("name",config.name.as_str());
-			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{
-				Some(group_id)=>{query.append_pair("groupId",group_id.to_string().as_str());},
-				None=>(),
-			}
-		}
-
-		let resp=self.post(url,body).await.map_err(CreateError::PostError)?;
-
-		Ok(resp.json::<UploadResponse>().await.map_err(CreateError::Reqwest)?)
+	async fn patch_form(&self,url:url::Url,form:reqwest::multipart::Form)->Result<reqwest::Response,reqwest::Error>{
+		self.client.patch(url)
+		.header("x-api-key",self.api_key.as_str())
+		.multipart(form)
+		.send().await
 	}
-	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)?;
-		//url borrow scope
-		{
-			let mut query=url.query_pairs_mut();//borrow here
-			//archaic roblox api uses 0 for new asset
-			match config.assetid{
-				0=>return Err(UploadError::AssetIdIsZero),
-				assetid=>{query.append_pair("assetid",assetid.to_string().as_str());},
-			}
-			if let Some(name)=config.name.as_deref(){
-				query.append_pair("name",name);
-			}
-			if let Some(description)=config.description.as_deref(){
-				query.append_pair("description",description);
-			}
-			if let Some(ispublic)=config.ispublic{
-				query.append_pair("ispublic",if ispublic{"True"}else{"False"});
-			}
-			if let Some(allow_comments)=config.allowComments{
-				query.append_pair("allowComments",if allow_comments{"True"}else{"False"});
-			}
-			if let Some(group_id)=config.groupId{
-				query.append_pair("groupId",group_id.to_string().as_str());
-			}
-		}
-
-		let resp=self.post(url,body).await.map_err(UploadError::PostError)?;
-
-		Ok(resp.json::<UploadResponse>().await.map_err(UploadError::Reqwest)?)
+	async fn post_form(&self,url:url::Url,form:reqwest::multipart::Form)->Result<reqwest::Response,reqwest::Error>{
+		self.client.post(url)
+		.header("x-api-key",self.api_key.as_str())
+		.multipart(form)
+		.send().await
 	}
-	pub async fn download(&self,config:DownloadRequest)->Result<Vec<u8>,DownloadError>{
-		let mut url=reqwest::Url::parse("https://assetdelivery.roblox.com/v1/asset/").map_err(DownloadError::ParseError)?;
+	pub async fn create_asset(&self,config:CreateAssetRequest,body:impl Into<std::borrow::Cow<'static,[u8]>>)->Result<AssetResponse,CreateError>{
+		let url=reqwest::Url::parse("https://apis.roblox.com/assets/v1/assets").map_err(CreateError::ParseError)?;
+
+		let request_config=serde_json::to_string(&config).map_err(CreateError::SerializeError)?;
+
+		let form=reqwest::multipart::Form::new()
+		.text("request",request_config)
+		.part("fileContent",reqwest::multipart::Part::bytes(body));
+
+		let resp=self.post_form(url,form).await.map_err(CreateError::Reqwest)?;
+
+		Ok(resp.json::<AssetResponse>().await.map_err(CreateError::Reqwest)?)
+	}
+	pub async fn update_asset(&self,config:UpdateAssetRequest,body:impl Into<std::borrow::Cow<'static,[u8]>>)->Result<AssetResponse,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)?;
+
+		let request_config=serde_json::to_string(&config).map_err(UpdateError::SerializeError)?;
+
+		let form=reqwest::multipart::Form::new()
+		.text("request",request_config)
+		.part("fileContent",reqwest::multipart::Part::bytes(body));
+
+		let resp=self.patch_form(url,form).await.map_err(UpdateError::Reqwest)?;
+
+		Ok(resp.json::<AssetResponse>().await.map_err(UpdateError::Reqwest)?)
+	}
+	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(GetError::ParseError)?;
 		//url borrow scope
 		{
 			let mut query=url.query_pairs_mut();//borrow here
@@ -269,31 +277,22 @@ impl RobloxContext{
 				query.append_pair("version",version.to_string().as_str());
 			}
 		}
-		let resp=self.get(url).await.map_err(DownloadError::Reqwest)?;
+		let resp=self.get(url).await.map_err(GetError::Reqwest)?;
 
-		let body=resp.bytes().await.map_err(DownloadError::Reqwest)?;
+		let body=resp.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 history_page(&self,config:HistoryPageRequest)->Result<HistoryPageResponse,HistoryPageError>{
-		let mut url=reqwest::Url::parse(format!("https://develop.roblox.com/v1/assets/{}/saved-versions",config.asset_id).as_str()).map_err(HistoryPageError::ParseError)?;
-		//url borrow scope
-		{
-			let mut query=url.query_pairs_mut();//borrow here
-			//query.append_pair("sortOrder","Asc");
-			//query.append_pair("limit","100");
-			//query.append_pair("count","100");
-			if let Some(cursor)=config.cursor.as_deref(){
-				query.append_pair("cursor",cursor);
-			}
-		}
+	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(HistoryPageError::Reqwest)?
-		.json::<HistoryPageResponse>().await.map_err(HistoryPageError::Reqwest)?)
+		Ok(self.get(url).await.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)?;
@@ -308,4 +307,12 @@ impl RobloxContext{
 		Ok(self.get(url).await.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 resp=self.post(url,body).await.map_err(UpdateError::Reqwest)?;
+
+		Ok(resp.json::<UpdatePlaceResponse>().await.map_err(UpdateError::Reqwest)?)
+	}
+}

rox_compiler/src/compile.rs

@@ -237,7 +237,10 @@ struct CompileNode{
 pub enum CompileNodeError{
 	IO(std::io::Error),
 	ScriptWithOverrides(ScriptWithOverridesError),
-	InvalidHintOrClass(Option<String>,ScriptHint),
+	InvalidClassOrHint{
+		class:Option<String>,
+		hint:ScriptHint
+	},
 	QueryResolveError(QueryResolveError),
 	/// Conversion from OsString to String failed
 	FileName(std::ffi::OsString),
@@ -277,7 +280,7 @@ impl CompileNode{
 				|(None,ScriptHint::LocalScript)=>CompileClass::LocalScript(script_with_overrides.source),
 				(Some("Script"),_)
 				|(None,ScriptHint::Script)=>CompileClass::Script(script_with_overrides.source),
-				other=>Err(CompileNodeError::InvalidHintOrClass(other.0.map(|s|s.to_owned()),other.1))?,
+				(class,hint)=>Err(CompileNodeError::InvalidClassOrHint{class:class.map(|s|s.to_owned()),hint})?,
 			},
 		})
 	}
@@ -429,17 +432,21 @@ impl std::fmt::Display for CompileError{
 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();
 	//add in scripts and models
 	let mut folder=config.input_folder.clone();
 	let mut stack:Vec<CompileStackInstruction>=vec![CompileStackInstruction::TraverseReferent(dom.root_ref(),None)];
 	while let Some(instruction)=stack.pop(){
 		match instruction{
 			CompileStackInstruction::TraverseReferent(item_ref,blacklist)=>{
-				let sans={
+				//scope to avoid holding item ref
+				{
 					let item=dom.get_by_ref(item_ref).ok_or(CompileError::NullChildRef)?;
-					sanitize(item.name.as_str()).to_string()
-				};
-				folder.push(sans.as_str());
+					let folder_name=sanitize(item.name.as_str());
+					folder.push(folder_name.as_ref());
+					//drop item
+				}
 				stack.push(CompileStackInstruction::PopFolder);
 				//check if a folder exists with item.name
 				if let Ok(dir)=tokio::fs::read_dir(folder.as_path()).await{
@@ -476,7 +483,7 @@ pub async fn compile(config:CompileConfig,mut dom:&mut rbx_dom_weak::WeakDom)->R
 								}else{
 									TooComplicated::Stop
 								};
-								Ok::<_,std::io::Error>(ret2)
+								Ok(ret2)
 							})().await
 						};
 						match ret1{
@@ -515,7 +522,8 @@ pub async fn compile(config:CompileConfig,mut dom:&mut rbx_dom_weak::WeakDom)->R
 					.map(|f|async{f}).buffer_unordered(32)
 
 					//begin processing immediately
-					.try_fold((&mut stack,&mut dom),|(stack,dom):(&mut Vec<CompileStackInstruction>,_),bog|async{
+					//TODO: fix dom being &mut &mut inside the closure
+					.try_fold((&mut stack,&mut dom),|(stack,dom),bog|async{
 						//push child objects onto dom serially as they arrive
 						match bog{
 							Some((blacklist,data))=>{

rox_compiler/src/lib.rs

@@ -1,9 +1,9 @@
 mod common;
 mod compile;
 mod decompile;
-//export specific types
+//export minimal interface
 pub use common::Style;
 pub use compile::CompileConfig;
-pub use compile::compile;//cringe non standardized interface
-pub use decompile::DecompiledContext;
+pub use compile::compile;//cringe unstandardized interface
 pub use decompile::WriteConfig;
+pub use decompile::DecompiledContext;

src/main.rs

@@ -2,7 +2,7 @@ use std::{io::Read,path::PathBuf};
 use clap::{Args,Parser,Subcommand};
 use anyhow::Result as AResult;
 use futures::StreamExt;
-use rbx_asset::context::{RobloxContext,InventoryItem,AssetVersion};
+use rbx_asset::context::{AssetVersion,InventoryItem,RobloxContext};
 
 type AssetID=u64;
 type AssetIDFileMap=Vec<(AssetID,PathBuf)>;
@@ -21,10 +21,14 @@ struct Cli{
 enum Commands{
 	DownloadHistory(DownloadHistorySubcommand),
 	Download(DownloadSubcommand),
+	DownloadDecompile(DownloadDecompileSubcommand),
 	DownloadGroupInventoryJson(DownloadGroupInventoryJsonSubcommand),
-	Create(CreateSubcommand),
-	Upload(UploadSubcommand),
+	CreateAsset(CreateAssetSubcommand),
+	UploadAsset(UpdateAssetSubcommand),
+	UploadPlace(UpdatePlaceSubcommand),
 	Compile(CompileSubcommand),
+	CompileUploadAsset(CompileUploadAssetSubcommand),
+	CompileUploadPlace(CompileUploadPlaceSubcommand),
 	Decompile(DecompileSubcommand),
 	DecompileHistoryIntoGit(DecompileHistoryIntoGitSubcommand),
 	DownloadAndDecompileHistoryIntoGit(DownloadAndDecompileHistoryIntoGitSubcommand),
@@ -34,10 +38,12 @@ enum Commands{
 struct DownloadHistorySubcommand{
 	#[arg(long)]
 	asset_id:AssetID,
-	#[arg(long)]
-	cookie_type:CookieType,
-	#[arg(long)]
-	cookie:String,
+	#[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)]
 	output_folder:Option<PathBuf>,
 	#[arg(long)]
@@ -49,10 +55,12 @@ struct DownloadHistorySubcommand{
 }
 #[derive(Args)]
 struct DownloadSubcommand{
-	#[arg(long)]
-	cookie_type:CookieType,
-	#[arg(long)]
-	cookie:String,
+	#[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)]
 	output_folder:Option<PathBuf>,
 	#[arg(required=true)]
@@ -60,21 +68,25 @@ struct DownloadSubcommand{
 }
 #[derive(Args)]
 struct DownloadGroupInventoryJsonSubcommand{
-	#[arg(long)]
-	cookie_type:CookieType,
-	#[arg(long)]
-	cookie:String,
+	#[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)]
 	output_folder:Option<PathBuf>,
 	#[arg(long)]
 	group:u64,
 }
 #[derive(Args)]
-struct CreateSubcommand{
-	#[arg(long)]
-	cookie_type:CookieType,
-	#[arg(long)]
-	cookie:String,
+struct CreateAssetSubcommand{
+	#[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)]
 	model_name:String,
 	#[arg(long)]
@@ -83,23 +95,34 @@ struct CreateSubcommand{
 	input_file:PathBuf,
 	#[arg(long)]
 	group:Option<u64>,
-	#[arg(long)]
-	free_model:Option<bool>,
-	#[arg(long)]
-	allow_comments:Option<bool>,
 }
 #[derive(Args)]
-struct UploadSubcommand{
+struct UpdateAssetSubcommand{
 	#[arg(long)]
 	asset_id:AssetID,
-	#[arg(long)]
-	cookie_type:CookieType,
-	#[arg(long)]
-	cookie:String,
+	#[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)]
 	input_file:PathBuf,
+}
+#[derive(Args)]
+struct UpdatePlaceSubcommand{
 	#[arg(long)]
-	group:Option<u64>,
+	place_id:u64,
+	#[arg(long)]
+	universe_id:u64,
+	#[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)]
+	input_file:PathBuf,
 }
 #[derive(Args)]
 struct CompileSubcommand{
@@ -113,6 +136,46 @@ struct CompileSubcommand{
 	template:Option<PathBuf>,
 }
 #[derive(Args)]
+struct CompileUploadAssetSubcommand{
+	#[arg(long)]
+	asset_id:AssetID,
+	#[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)]
+	input_file:PathBuf,
+	#[arg(long)]
+	input_folder:Option<PathBuf>,
+	#[arg(long)]
+	style:Option<Style>,
+	#[arg(long)]
+	template:Option<PathBuf>,
+}
+#[derive(Args)]
+struct CompileUploadPlaceSubcommand{
+	#[arg(long)]
+	place_id:u64,
+	#[arg(long)]
+	universe_id:u64,
+	#[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)]
+	input_file:PathBuf,
+	#[arg(long)]
+	input_folder:Option<PathBuf>,
+	#[arg(long)]
+	style:Option<Style>,
+	#[arg(long)]
+	template:Option<PathBuf>,
+}
+#[derive(Args)]
 struct DecompileSubcommand{
 	#[arg(long)]
 	input_file:PathBuf,
@@ -128,6 +191,27 @@ struct DecompileSubcommand{
 	write_scripts:Option<bool>,
 }
 #[derive(Args)]
+struct DownloadDecompileSubcommand{
+	#[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)]
+	output_folder:Option<PathBuf>,
+	#[arg(long)]
+	asset_id:AssetID,
+	#[arg(long)]
+	style:Style,
+	#[arg(long)]
+	write_template:Option<bool>,
+	#[arg(long)]
+	write_models:Option<bool>,
+	#[arg(long)]
+	write_scripts:Option<bool>,
+}
+#[derive(Args)]
 struct DecompileHistoryIntoGitSubcommand{
 	#[arg(long)]
 	input_folder:PathBuf,
@@ -150,10 +234,12 @@ struct DecompileHistoryIntoGitSubcommand{
 struct DownloadAndDecompileHistoryIntoGitSubcommand{
 	#[arg(long)]
 	asset_id:AssetID,
-	#[arg(long)]
-	cookie_type:CookieType,
-	#[arg(long)]
-	cookie:String,
+	#[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>,
 	//currently output folder must be the current folder due to git2 limitations
 	//output_folder:cli.output.unwrap(),
 	#[arg(long)]
@@ -170,15 +256,8 @@ struct DownloadAndDecompileHistoryIntoGitSubcommand{
 	write_scripts:Option<bool>,
 }
 
-#[derive(Clone,clap::ValueEnum)]
-enum CookieType{
-	Literal,
-	Environment,
-	File,
-}
-
 #[derive(Clone,Copy,Debug,clap::ValueEnum)]
-pub enum Style{
+enum Style{
 	Rox,
 	Rojo,
 	RoxRojo,
@@ -202,13 +281,21 @@ async fn main()->AResult<()>{
 			end_version:subcommand.end_version,
 			start_version:subcommand.start_version.unwrap_or(0),
 			output_folder:subcommand.output_folder.unwrap_or_else(||std::env::current_dir().unwrap()),
-			cookie:Cookie::from_type(subcommand.cookie_type,subcommand.cookie).await?.0,
+			api_key:ApiKey::from_args(
+				subcommand.api_key_literal,
+				subcommand.api_key_envvar,
+				subcommand.api_key_file,
+			).await?.get(),
 			asset_id:subcommand.asset_id,
 		}).await,
 		Commands::Download(subcommand)=>{
 			let output_folder=subcommand.output_folder.unwrap_or_else(||std::env::current_dir().unwrap());
 			download_list(
-				Cookie::from_type(subcommand.cookie_type,subcommand.cookie).await?.0,
+				ApiKey::from_args(
+					subcommand.api_key_literal,
+					subcommand.api_key_envvar,
+					subcommand.api_key_file,
+				).await?.get(),
 				subcommand.asset_ids.into_iter().map(|asset_id|{
 					let mut path=output_folder.clone();
 					path.push(asset_id.to_string());
@@ -216,33 +303,91 @@ async fn main()->AResult<()>{
 				}).collect()
 			).await
 		},
+		Commands::DownloadDecompile(subcommand)=>{
+			download_decompile(DownloadDecompileConfig{
+				api_key:ApiKey::from_args(
+					subcommand.api_key_literal,
+					subcommand.api_key_envvar,
+					subcommand.api_key_file,
+				).await?.get(),
+				asset_id:subcommand.asset_id,
+				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),
+				write_scripts:subcommand.write_scripts.unwrap_or(true),
+			}).await
+		},
 		Commands::DownloadGroupInventoryJson(subcommand)=>download_group_inventory_json(
-			Cookie::from_type(subcommand.cookie_type,subcommand.cookie).await?.0,
+			ApiKey::from_args(
+				subcommand.api_key_literal,
+				subcommand.api_key_envvar,
+				subcommand.api_key_file,
+			).await?.get(),
 			subcommand.group,
 			subcommand.output_folder.unwrap_or_else(||std::env::current_dir().unwrap()),
 		).await,
-		Commands::Create(subcommand)=>create(CreateConfig{
-			cookie:Cookie::from_type(subcommand.cookie_type,subcommand.cookie).await?.0,
+		Commands::CreateAsset(subcommand)=>create(CreateConfig{
+			api_key:ApiKey::from_args(
+				subcommand.api_key_literal,
+				subcommand.api_key_envvar,
+				subcommand.api_key_file,
+			).await?.get(),
 			group:subcommand.group,
 			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::Upload(subcommand)=>upload_list(
-			Cookie::from_type(subcommand.cookie_type,subcommand.cookie).await?.0,
-			subcommand.group,
-			vec![(subcommand.asset_id,subcommand.input_file)]
-		).await,
+		Commands::UploadAsset(subcommand)=>upload_asset(UploadAssetConfig{
+			api_key:ApiKey::from_args(
+				subcommand.api_key_literal,
+				subcommand.api_key_envvar,
+				subcommand.api_key_file,
+			).await?.get(),
+			asset_id:subcommand.asset_id,
+			input_file:subcommand.input_file,
+		}).await,
+		Commands::UploadPlace(subcommand)=>upload_place(UploadPlaceConfig{
+			api_key:ApiKey::from_args(
+				subcommand.api_key_literal,
+				subcommand.api_key_envvar,
+				subcommand.api_key_file,
+			).await?.get(),
+			place_id:subcommand.place_id,
+			universe_id:subcommand.universe_id,
+			input_file:subcommand.input_file,
+		}).await,
 		Commands::Compile(subcommand)=>compile(CompileConfig{
 			input_folder:subcommand.input_folder.unwrap_or_else(||std::env::current_dir().unwrap()),
 			output_file:subcommand.output_file,
 			template:subcommand.template,
-			style:subcommand.style,
+			style:subcommand.style.map(|s|s.rox()),
+		}).await,
+		Commands::CompileUploadAsset(subcommand)=>compile_upload_asset(CompileUploadAssetConfig{
+			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:ApiKey::from_args(
+				subcommand.api_key_literal,
+				subcommand.api_key_envvar,
+				subcommand.api_key_file,
+			).await?.get(),
+			asset_id:subcommand.asset_id,
+		}).await,
+		Commands::CompileUploadPlace(subcommand)=>compile_upload_place(CompileUploadPlaceConfig{
+			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:ApiKey::from_args(
+				subcommand.api_key_literal,
+				subcommand.api_key_envvar,
+				subcommand.api_key_file,
+			).await?.get(),
+			place_id:subcommand.place_id,
+			universe_id:subcommand.universe_id,
 		}).await,
 		Commands::Decompile(subcommand)=>decompile(DecompileConfig{
-			style:subcommand.style,
+			style:subcommand.style.rox(),
 			input_file:subcommand.input_file,
 			output_folder:subcommand.output_folder.unwrap_or_else(||std::env::current_dir().unwrap()),
 			write_template:subcommand.write_template.unwrap_or(false),
@@ -254,7 +399,7 @@ async fn main()->AResult<()>{
 			git_committer_email:subcommand.git_committer_email,
 			input_folder:subcommand.input_folder,
 			output_folder:std::env::current_dir()?,
-			style:subcommand.style,
+			style:subcommand.style.rox(),
 			write_template:subcommand.write_template.unwrap_or(false),
 			write_models:subcommand.write_models.unwrap_or(false),
 			write_scripts:subcommand.write_scripts.unwrap_or(true),
@@ -262,10 +407,14 @@ 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,
-			cookie:Cookie::from_type(subcommand.cookie_type,subcommand.cookie).await?.0,
+			api_key:ApiKey::from_args(
+				subcommand.api_key_literal,
+				subcommand.api_key_envvar,
+				subcommand.api_key_file,
+			).await?.get(),
 			asset_id:subcommand.asset_id,
 			output_folder:std::env::current_dir()?,
-			style:subcommand.style,
+			style:subcommand.style.rox(),
 			write_template:subcommand.write_template.unwrap_or(false),
 			write_models:subcommand.write_models.unwrap_or(false),
 			write_scripts:subcommand.write_scripts.unwrap_or(true),
@@ -273,76 +422,86 @@ async fn main()->AResult<()>{
 	}
 }
 
-struct Cookie(String);
-impl Cookie{
-	async fn from_type(cookie_type:CookieType,cookie_string:String)->AResult<Self>{
-		Ok(Self(format!(".ROBLOSECURITY={}",match cookie_type{
-			CookieType::Literal=>cookie_string,
-			CookieType::Environment=>std::env::var(cookie_string)?,
-			CookieType::File=>tokio::fs::read_to_string(cookie_string).await?,
-		})))
+struct ApiKey(String);
+impl ApiKey{
+	fn get(self)->String{
+		self.0
+	}
+	async fn from_args(literal:Option<String>,environment:Option<String>,file:Option<PathBuf>)->AResult<Self>{
+		let api_key=match (literal,environment,file){
+			(Some(api_key_literal),None,None)=>api_key_literal,
+			(None,Some(api_key_environment),None)=>std::env::var(api_key_environment)?,
+			(None,None,Some(api_key_file))=>tokio::fs::read_to_string(api_key_file).await?,
+			_=>Err(anyhow::Error::msg("Illegal api key argument triple"))?,
+		};
+		Ok(Self(api_key))
 	}
 }
 
 struct CreateConfig{
-	cookie:String,
+	api_key:String,
 	model_name:String,
 	description:String,
 	input_file:PathBuf,
 	group:Option<u64>,
-	free_model:bool,
-	allow_comments:bool,
 }
 
+///This is hardcoded to create models atm
 async fn create(config:CreateConfig)->AResult<()>{
-	let resp=RobloxContext::new(config.cookie)
-	.create(rbx_asset::context::CreateRequest{
-		name:config.model_name,
+	let resp=RobloxContext::new(config.api_key)
+	.create_asset(rbx_asset::context::CreateAssetRequest{
+		assetType:rbx_asset::context::AssetType::Model,
+		displayName:config.model_name,
 		description:config.description,
-		ispublic:config.free_model,
-		allowComments:config.allow_comments,
-		groupId:config.group,
+		creationContext:rbx_asset::context::CreationContext{
+			creator:rbx_asset::context::Creator{
+				userId:0,//ever needed? roblox should implicitly know this
+				groupId:config.group.unwrap_or(0),
+			},
+			expectedPrice:0,
+		}
 	},tokio::fs::read(config.input_file).await?).await?;
 	println!("UploadResponse={:?}",resp);
 	Ok(())
 }
 
-async fn upload_list(cookie:String,group:Option<u64>,asset_id_file_map:AssetIDFileMap)->AResult<()>{
-	let context=RobloxContext::new(cookie);
-	//this is calling map on the vec because the closure produces an iterator of futures
-	futures::stream::iter(asset_id_file_map.into_iter()
-	.map(|(asset_id,file)|{
-		let context=&context;
-		async move{
-			Ok((asset_id,context.upload(rbx_asset::context::UploadRequest{
-				assetid:asset_id,
-				name:None,
-				description:None,
-				ispublic:None,
-				allowComments:None,
-				groupId:group,
-			},tokio::fs::read(file).await?).await?))
-		}
-	}))
-	.buffer_unordered(CONCURRENT_REQUESTS)
-	.for_each(|b:AResult<_>|async{
-			match b{
-				Ok((asset_id,body))=>{
-					println!("asset_id={} UploadResponse={:?}",asset_id,body);
-				},
-				Err(e)=>eprintln!("ul error: {}",e),
-			}
-		}).await;
+struct UploadAssetConfig{
+	api_key:String,
+	asset_id:u64,
+	input_file:PathBuf,
+}
+async fn upload_asset(config:UploadAssetConfig)->AResult<()>{
+	let context=RobloxContext::new(config.api_key);
+	context.update_asset(rbx_asset::context::UpdateAssetRequest{
+		assetId:config.asset_id,
+		displayName:None,
+		description:None,
+	},tokio::fs::read(config.input_file).await?).await?;
 	Ok(())
 }
 
-async fn download_list(cookie:String,asset_id_file_map:AssetIDFileMap)->AResult<()>{
-	let context=RobloxContext::new(cookie);
+struct UploadPlaceConfig{
+	api_key:String,
+	place_id:u64,
+	universe_id:u64,
+	input_file:PathBuf,
+}
+async fn upload_place(config:UploadPlaceConfig)->AResult<()>{
+	let context=RobloxContext::new(config.api_key);
+	context.update_place(rbx_asset::context::UpdatePlaceRequest{
+		placeId:config.place_id,
+		universeId:config.universe_id,
+	},tokio::fs::read(config.input_file).await?).await?;
+	Ok(())
+}
+
+async fn download_list(api_key:String,asset_id_file_map:AssetIDFileMap)->AResult<()>{
+	let context=RobloxContext::new(api_key);
 	futures::stream::iter(asset_id_file_map.into_iter()
 	.map(|(asset_id,file)|{
 		let context=&context;
 		async move{
-			Ok((file,context.download(rbx_asset::context::DownloadRequest{asset_id,version:None}).await?))
+			Ok((file,context.get_asset(rbx_asset::context::GetAssetRequest{asset_id,version:None}).await?))
 		}
 	}))
 	.buffer_unordered(CONCURRENT_REQUESTS)
@@ -374,8 +533,8 @@ async fn get_inventory_pages(context:&RobloxContext,group:u64)->AResult<Vec<Inve
 	Ok(asset_list)
 }
 
-async fn download_group_inventory_json(cookie:String,group:u64,output_folder:PathBuf)->AResult<()>{
-	let context=RobloxContext::new(cookie);
+async fn download_group_inventory_json(api_key:String,group:u64,output_folder:PathBuf)->AResult<()>{
+	let context=RobloxContext::new(api_key);
 	let item_list=get_inventory_pages(&context,group).await?;
 
 	let mut path=output_folder.clone();
@@ -389,7 +548,7 @@ async fn get_version_history(context:&RobloxContext,asset_id:AssetID)->AResult<V
 	let mut cursor:Option<String>=None;
 	let mut asset_list=Vec::new();
 	loop{
-		let mut page=context.history_page(rbx_asset::context::HistoryPageRequest{asset_id,cursor}).await?;
+		let mut page=context.get_asset_versions(rbx_asset::context::AssetVersionsRequest{asset_id,cursor}).await?;
 		asset_list.append(&mut page.data);
 		if page.nextPageCursor.is_none(){
 			break;
@@ -405,7 +564,7 @@ struct DownloadHistoryConfig{
 	end_version:Option<u64>,
 	start_version:u64,
 	output_folder:PathBuf,
-	cookie:String,
+	api_key:String,
 	asset_id:AssetID,
 }
 
@@ -446,7 +605,7 @@ async fn download_history(mut config:DownloadHistoryConfig)->AResult<()>{
 			None=>Err(anyhow::Error::msg("Cannot continue from versions.json - there are no previous versions"))?,
 		}
 	}
-	let context=RobloxContext::new(config.cookie);
+	let context=RobloxContext::new(config.api_key);
 
 	//limit concurrent downloads
 	let mut join_set=tokio::task::JoinSet::new();
@@ -454,7 +613,7 @@ async fn download_history(mut config:DownloadHistoryConfig)->AResult<()>{
 	//poll paged list of all asset versions
 	let mut cursor:Option<String>=None;
 	loop{
-		let mut page=context.history_page(rbx_asset::context::HistoryPageRequest{asset_id:config.asset_id,cursor}).await?;
+		let mut page=context.get_asset_versions(rbx_asset::context::AssetVersionsRequest{asset_id:config.asset_id,cursor}).await?;
 		let context=&context;
 		let output_folder=config.output_folder.clone();
 		let data=&page.data;
@@ -484,7 +643,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.download(rbx_asset::context::DownloadRequest{asset_id:config.asset_id,version:Some(version_number)}).await?;
+				let file=context.get_asset(rbx_asset::context::GetAssetRequest{asset_id:config.asset_id,version:Some(version_number)}).await?;
 
 				tokio::fs::write(path,file).await?;
 
@@ -546,7 +705,7 @@ fn load_dom<R:Read>(input:R)->AResult<rbx_dom_weak::WeakDom>{
 
 
 struct DecompileConfig{
-	style:Style,
+	style:rox_compiler::Style,
 	input_file:PathBuf,
 	output_folder:PathBuf,
 	write_template:bool,
@@ -568,7 +727,35 @@ async fn decompile(config:DecompileConfig)->AResult<()>{
 	//generate folders, models, and scripts
 	//delete models and scripts from dom
 	context.write_files(rox_compiler::WriteConfig{
-		style:config.style.rox(),
+		style:config.style,
+		output_folder:config.output_folder,
+		write_template:config.write_template,
+		write_models:config.write_models,
+		write_scripts:config.write_scripts,
+	}).await?;
+
+	Ok(())
+}
+
+struct DownloadDecompileConfig{
+	api_key:String,
+	asset_id:AssetID,
+	style:rox_compiler::Style,
+	output_folder:PathBuf,
+	write_template:bool,
+	write_models:bool,
+	write_scripts:bool,
+}
+
+async fn download_decompile(config:DownloadDecompileConfig)->AResult<()>{
+	let context=RobloxContext::new(config.api_key);
+	let file=context.get_asset(rbx_asset::context::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);
+
+	context.write_files(rox_compiler::WriteConfig{
+		style:config.style,
 		output_folder:config.output_folder,
 		write_template:config.write_template,
 		write_models:config.write_models,
@@ -582,7 +769,7 @@ struct WriteCommitConfig{
 	git_committer_name:String,
 	git_committer_email:String,
 	output_folder:PathBuf,
-	style:Style,
+	style:rox_compiler::Style,
 	write_template:bool,
 	write_models:bool,
 	write_scripts:bool,
@@ -612,7 +799,7 @@ async fn write_commit(config:WriteCommitConfig,b:Result<AResult<(AssetVersion,ro
 
 	//write files
 	context.write_files(rox_compiler::WriteConfig{
-		style:config.style.rox(),
+		style:config.style,
 		output_folder:config.output_folder.clone(),
 		write_template:config.write_template,
 		write_models:config.write_models,
@@ -673,7 +860,7 @@ struct DecompileHistoryConfig{
 	git_committer_name:String,
 	git_committer_email:String,
 	input_folder:PathBuf,
-	style:Style,
+	style:rox_compiler::Style,
 	output_folder:PathBuf,
 	write_template:bool,
 	write_models:bool,
@@ -719,11 +906,11 @@ async fn decompile_history_into_git(config:DecompileHistoryConfig)->AResult<()>{
 }
 
 struct DownloadAndDecompileHistoryConfig{
-	cookie:String,
+	api_key:String,
 	asset_id:AssetID,
 	git_committer_name:String,
 	git_committer_email:String,
-	style:Style,
+	style:rox_compiler::Style,
 	output_folder:PathBuf,
 	write_template:bool,
 	write_models:bool,
@@ -731,7 +918,7 @@ struct DownloadAndDecompileHistoryConfig{
 }
 
 async fn download_and_decompile_history_into_git(config:DownloadAndDecompileHistoryConfig)->AResult<()>{
-	let context=RobloxContext::new(config.cookie);
+	let context=RobloxContext::new(config.api_key);
 
 	//poll paged list of all asset versions
 	let asset_list=get_version_history(&context,config.asset_id).await?;
@@ -744,7 +931,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.download(rbx_asset::context::DownloadRequest{asset_id,version:Some(asset_version.assetVersionNumber)}).await?;
+			let file=context.get_asset(rbx_asset::context::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)))
 		})
@@ -771,7 +958,7 @@ struct CompileConfig{
 	input_folder:PathBuf,
 	output_file:PathBuf,
 	template:Option<PathBuf>,
-	style:Option<Style>,
+	style:Option<rox_compiler::Style>,
 }
 
 async fn compile(config:CompileConfig)->AResult<()>{
@@ -780,14 +967,12 @@ async fn compile(config:CompileConfig)->AResult<()>{
 	let mut dom=match config.template{
 		//mr dom doesn't like tokio files
 		Some(template_path)=>load_dom(std::io::BufReader::new(std::fs::File::open(template_path)?))?,
-		None=>rbx_dom_weak::WeakDom::default(),
+		None=>rbx_dom_weak::WeakDom::new(rbx_dom_weak::InstanceBuilder::new("DataModel")),
 	};
-	//hack to traverse root folder as the root object
-	dom.root_mut().name="src".to_owned();
 
 	rox_compiler::compile(rox_compiler::CompileConfig{
 		input_folder:config.input_folder,
-		style:config.style.map(|s|s.rox()),
+		style:config.style,
 	},&mut dom).await?;
 
 	let mut output_place=config.output_file.clone();
@@ -799,3 +984,69 @@ async fn compile(config:CompileConfig)->AResult<()>{
 	rbx_binary::to_writer(output,&dom,dom.root().children())?;
 	Ok(())
 }
+
+struct CompileUploadAssetConfig{
+	input_folder:PathBuf,
+	template:Option<PathBuf>,
+	style:Option<rox_compiler::Style>,
+	api_key:String,
+	asset_id:AssetID,
+}
+async fn compile_upload_asset(config:CompileUploadAssetConfig)->AResult<()>{
+	let mut dom=match config.template{
+		//mr dom doesn't like tokio files
+		Some(template_path)=>load_dom(std::io::BufReader::new(std::fs::File::open(template_path)?))?,
+		None=>rbx_dom_weak::WeakDom::new(rbx_dom_weak::InstanceBuilder::new("DataModel")),
+	};
+
+	rox_compiler::compile(rox_compiler::CompileConfig{
+		input_folder:config.input_folder,
+		style:config.style,
+	},&mut dom).await?;
+
+	//make a binary file in a buffer in memory
+	let mut data=Vec::new();
+	rbx_binary::to_writer(std::io::Cursor::new(&mut data),&dom,dom.root().children())?;
+
+	//upload it
+	let context=RobloxContext::new(config.api_key);
+	context.update_asset(rbx_asset::context::UpdateAssetRequest{
+		assetId:config.asset_id,
+		displayName:None,
+		description:None,
+	},data).await?;
+	Ok(())
+}
+
+struct CompileUploadPlaceConfig{
+	input_folder:PathBuf,
+	template:Option<PathBuf>,
+	style:Option<rox_compiler::Style>,
+	api_key:String,
+	place_id:u64,
+	universe_id:u64,
+}
+async fn compile_upload_place(config:CompileUploadPlaceConfig)->AResult<()>{
+	let mut dom=match config.template{
+		//mr dom doesn't like tokio files
+		Some(template_path)=>load_dom(std::io::BufReader::new(std::fs::File::open(template_path)?))?,
+		None=>rbx_dom_weak::WeakDom::new(rbx_dom_weak::InstanceBuilder::new("DataModel")),
+	};
+
+	rox_compiler::compile(rox_compiler::CompileConfig{
+		input_folder:config.input_folder,
+		style:config.style,
+	},&mut dom).await?;
+
+	//make a binary file in a buffer in memory
+	let mut data=Vec::new();
+	rbx_binary::to_writer(std::io::Cursor::new(&mut data),&dom,dom.root().children())?;
+
+	//upload it
+	let context=RobloxContext::new(config.api_key);
+	context.update_place(rbx_asset::context::UpdatePlaceRequest{
+		universeId:config.universe_id,
+		placeId:config.place_id,
+	},data).await?;
+	Ok(())
+}