investigate podman container from the inside

Reviewed-on: StrafesNET/asset-tool#1

.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.lock

@@ -110,7 +110,7 @@ checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
 
 [[package]]
 name = "asset-tool"
-version = "0.3.4"
+version = "0.4.1"
 dependencies = [
  "anyhow",
  "clap",
@@ -1166,7 +1166,7 @@ dependencies = [
 
 [[package]]
 name = "rbx_asset"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "chrono",
  "flate2",

Cargo.toml

@@ -1,7 +1,7 @@
 workspace = { members = ["rbx_asset", "rox_compiler"] }
 [package]
 name = "asset-tool"
-version = "0.3.4"
+version = "0.4.1"
 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,5 @@
 # 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.

rbx_asset/Cargo.toml

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

rbx_asset/src/cloud.rs

@@ -60,20 +60,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,
@@ -119,7 +105,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 +117,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>,
@@ -154,13 +140,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
@@ -185,6 +171,16 @@ impl std::fmt::Display for InventoryPageError{
 }
 impl std::error::Error for InventoryPageError{}
 
+#[derive(Debug,serde::Deserialize,serde::Serialize)]
+#[allow(nonstandard_style,dead_code)]
+pub struct RobloxOperation{
+	pub path:Option<std::path::PathBuf>,
+	pub metadata:Option<String>,
+	pub done:Option<bool>,
+	pub error:Option<String>,
+	pub response:Option<String>,
+}
+
 //idk how to do this better
 enum ReaderType<R:std::io::Read>{
 	GZip(flate2::read::GzDecoder<std::io::BufReader<R>>),
@@ -205,15 +201,26 @@ fn read_readable(mut readable:impl std::io::Read)->std::io::Result<Vec<u8>>{
 }
 
 #[derive(Clone)]
-pub struct RobloxContext{
+pub struct ApiKey(String);
+impl ApiKey{
+	pub fn new(api_key:String)->Self{
+		Self(api_key)
+	}
+	pub fn get(self)->String{
+		self.0
+	}
+}
+
+#[derive(Clone)]
+pub struct CloudContext{
 	pub api_key:String,
 	pub client:reqwest::Client,
 }
 
-impl RobloxContext{
+impl CloudContext{
-	pub fn new(api_key:String)->Self{
+	pub fn new(api_key:ApiKey)->Self{
 		Self{
-			api_key,
+			api_key:api_key.get(),
 			client:reqwest::Client::new(),
 		}
 	}
@@ -240,7 +247,7 @@ impl RobloxContext{
 		.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<RobloxOperation,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)?;
@@ -249,11 +256,12 @@ impl RobloxContext{
 		.text("request",request_config)
 		.part("fileContent",reqwest::multipart::Part::bytes(body));
 
-		let resp=self.post_form(url,form).await.map_err(CreateError::Reqwest)?;
+		let resp=self.post_form(url,form).await.map_err(CreateError::Reqwest)?
+		.error_for_status().map_err(CreateError::Reqwest)?;
 
-		Ok(resp.json::<AssetResponse>().await.map_err(CreateError::Reqwest)?)
+		Ok(resp.json::<RobloxOperation>().await.map_err(CreateError::Reqwest)?)
 	}
-	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<RobloxOperation,UpdateError>{
 		let raw_url=format!("https://apis.roblox.com/assets/v1/assets/{}",config.assetId);
 		let url=reqwest::Url::parse(raw_url.as_str()).map_err(UpdateError::ParseError)?;
 
@@ -263,9 +271,12 @@ impl RobloxContext{
 		.text("request",request_config)
 		.part("fileContent",reqwest::multipart::Part::bytes(body));
 
-		let resp=self.patch_form(url,form).await.map_err(UpdateError::Reqwest)?;
+		let resp=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)?;
 
-		Ok(resp.json::<AssetResponse>().await.map_err(UpdateError::Reqwest)?)
+		Ok(resp.json::<RobloxOperation>().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)?;
@@ -309,9 +320,15 @@ impl RobloxContext{
 	}
 	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)?;
+		let resp=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)?)
 	}

rbx_asset/src/cookie.rs

@@ -0,0 +1,321 @@
+#[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 description:String,
+	pub ispublic:bool,
+	pub allowComments:bool,
+	pub groupId:Option<u64>,
+}
+#[derive(Debug)]
+pub enum CreateError{
+	ParseError(url::ParseError),
+	PostError(PostError),
+	Reqwest(reqwest::Error),
+}
+impl std::fmt::Display for CreateError{
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for CreateError{}
+
+#[allow(nonstandard_style,dead_code)]
+pub struct UploadRequest{
+	pub assetid:u64,
+	pub name:Option<String>,
+	pub description:Option<String>,
+	pub ispublic:Option<bool>,
+	pub allowComments:Option<bool>,
+	pub groupId:Option<u64>,
+}
+#[derive(Debug)]
+pub enum UploadError{
+	ParseError(url::ParseError),
+	PostError(PostError),
+	Reqwest(reqwest::Error),
+	AssetIdIsZero,
+}
+impl std::fmt::Display for UploadError{
+	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,
+}
+
+#[allow(nonstandard_style,dead_code)]
+pub struct GetAssetRequest{
+	pub asset_id:u64,
+	pub version:Option<u64>,
+}
+#[derive(Debug)]
+pub enum GetError{
+	ParseError(url::ParseError),
+	Reqwest(reqwest::Error),
+	IO(std::io::Error)
+}
+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 GetError{}
+
+pub struct AssetVersionsPageRequest{
+	pub asset_id:u64,
+	pub cursor:Option<String>,
+}
+#[derive(serde::Deserialize,serde::Serialize)]
+#[allow(nonstandard_style,dead_code)]
+pub struct AssetVersion{
+	pub Id:u64,
+	pub assetId:u64,
+	pub assetVersionNumber:u64,
+	pub creatorType:String,
+	pub creatorTargetId:u64,
+	pub creatingUniverseId:Option<u64>,
+	pub created:chrono::DateTime<chrono::Utc>,
+	pub isPublished:bool,
+}
+#[derive(serde::Deserialize)]
+#[allow(nonstandard_style,dead_code)]
+pub struct AssetVersionsPageResponse{
+	pub previousPageCursor:Option<String>,
+	pub nextPageCursor:Option<String>,
+	pub data:Vec<AssetVersion>,
+}
+#[derive(Debug)]
+pub enum AssetVersionsPageError{
+	ParseError(url::ParseError),
+	Reqwest(reqwest::Error),
+}
+impl std::fmt::Display for AssetVersionsPageError{
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for AssetVersionsPageError{}
+
+pub struct InventoryPageRequest{
+	pub group:u64,
+	pub cursor:Option<String>,
+}
+#[derive(serde::Deserialize,serde::Serialize)]
+#[allow(nonstandard_style,dead_code)]
+pub struct InventoryItem{
+	pub id:u64,
+	pub name:String,
+}
+#[derive(serde::Deserialize,serde::Serialize)]
+#[allow(nonstandard_style,dead_code)]
+pub struct InventoryPageResponse{
+	pub totalResults:u64,//up to 50
+	pub filteredKeyword:Option<String>,//""
+	pub searchDebugInfo:Option<String>,//null
+	pub spellCheckerResult:Option<String>,//null
+	pub queryFacets:Option<String>,//null
+	pub imageSearchStatus:Option<String>,//null
+	pub previousPageCursor:Option<String>,
+	pub nextPageCursor:Option<String>,
+	pub data:Vec<InventoryItem>,
+}
+#[derive(Debug)]
+pub enum InventoryPageError{
+	ParseError(url::ParseError),
+	Reqwest(reqwest::Error),
+}
+impl std::fmt::Display for InventoryPageError{
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for InventoryPageError{}
+
+//idk how to do this better
+enum ReaderType<R:std::io::Read>{
+	GZip(flate2::read::GzDecoder<std::io::BufReader<R>>),
+	Raw(std::io::BufReader<R>),
+}
+fn maybe_gzip_decode<R:std::io::Read>(input:R)->std::io::Result<ReaderType<R>>{
+	let mut buf=std::io::BufReader::new(input);
+	let peek=std::io::BufRead::fill_buf(&mut buf)?;
+	match &peek[0..2]{
+		b"\x1f\x8b"=>Ok(ReaderType::GZip(flate2::read::GzDecoder::new(buf))),
+		_=>Ok(ReaderType::Raw(buf)),
+	}
+}
+fn read_readable(mut readable:impl std::io::Read)->std::io::Result<Vec<u8>>{
+	let mut contents=Vec::new();
+	readable.read_to_end(&mut contents)?;
+	Ok(contents)
+}
+
+#[derive(Clone)]
+pub struct Cookie(String);
+impl Cookie{
+	pub fn new(cookie:String)->Self{
+		Self(cookie)
+	}
+	pub fn get(self)->String{
+		self.0
+	}
+}
+#[derive(Clone)]
+pub struct CookieContext{
+	pub cookie:String,
+	pub client:reqwest::Client,
+}
+
+impl CookieContext{
+	pub fn new(cookie:Cookie)->Self{
+		Self{
+			cookie:cookie.get(),
+			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())
+		.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)
+	}
+	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)?)
+	}
+	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)?)
+	}
+	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
+			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)?;
+
+		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(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)?;
+		//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);
+			}
+		}
+
+		Ok(self.get(url).await.map_err(AssetVersionsPageError::Reqwest)?
+		.json::<AssetVersionsPageResponse>().await.map_err(AssetVersionsPageError::Reqwest)?)
+	}
+	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
+		{
+			let mut query=url.query_pairs_mut();//borrow here
+			if let Some(cursor)=config.cursor.as_deref(){
+				query.append_pair("cursor",cursor);
+			}
+		}
+
+		Ok(self.get(url).await.map_err(InventoryPageError::Reqwest)?
+		.json::<InventoryPageResponse>().await.map_err(InventoryPageError::Reqwest)?)
+	}
+}

rbx_asset/src/lib.rs

@@ -1 +1,2 @@
-pub mod context;
+pub mod cloud;
+pub mod cookie;

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>{
-	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

@@ -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{
@@ -343,7 +343,7 @@ impl CompileNode{
 			_=>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 +355,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 +371,7 @@ impl CompileNode{
 					_=>panic!("Regex failed"),
 				})
 			}else{
-				return Err(CompileNodeError::NoExtension);
+				return Err(CompileNodeError::UnknownExtension);
 			}
 		};
 		file_name.truncate(file_name.len()-ext_len);
@@ -500,10 +506,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={
-									true=>CompileNode::from_folder(&entry,style).await,
+									let result=match met.is_dir(){
-									false=>CompileNode::from_file(&entry,style).await,
+										true=>CompileNode::from_folder(&entry,style).await,
-								}.map_err(CompileError::CompileNode)?;
+										false=>CompileNode::from_file(&entry,style).await,
+									};
+									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())),
@@ -525,20 +540,17 @@ pub async fn compile(config:CompileConfig,mut dom:&mut rbx_dom_weak::WeakDom)->R
 					//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{
+						if let Some((blacklist,data))=bog{
-							Some((blacklist,data))=>{
+							let referent=match data{
-								let referent=match data{
+								PreparedData::Model(mut model_dom)=>{
-									PreparedData::Model(mut model_dom)=>{
+									let referent=model_dom.root().children()[0];
-										let referent=model_dom.root().children()[0];
+									model_dom.transfer(referent,dom,item_ref);
-										model_dom.transfer(referent,dom,item_ref);
+									referent
-										referent
+								},
-									},
+								PreparedData::Builder(script)=>dom.insert(item_ref,script),
-									PreparedData::Builder(script)=>dom.insert(item_ref,script),
+							};
-								};
+							//new children need to be traversed
-								//new children need to be traversed
+							stack.push(CompileStackInstruction::TraverseReferent(referent,blacklist));
-								stack.push(CompileStackInstruction::TraverseReferent(referent,blacklist));
-							},
-							None=>(),
 						}
 						Ok((stack,dom))
 					}).await?;
@@ -547,5 +559,5 @@ pub async fn compile(config:CompileConfig,mut dom:&mut rbx_dom_weak::WeakDom)->R
 			CompileStackInstruction::PopFolder=>assert!(folder.pop(),"pop folder bad"),
 		}
 	}
-	unreachable!();
+	Ok(())
 }

src/main.rs

@@ -2,7 +2,8 @@ use std::{io::Read,path::PathBuf};
 use clap::{Args,Parser,Subcommand};
 use anyhow::Result as AResult;
 use futures::StreamExt;
-use rbx_asset::context::{AssetVersion,InventoryItem,RobloxContext};
+use rbx_asset::cloud::{ApiKey,CloudContext};
+use rbx_asset::cookie::{Cookie,CookieContext,AssetVersion,InventoryItem};
 
 type AssetID=u64;
 type AssetIDFileMap=Vec<(AssetID,PathBuf)>;
@@ -19,6 +20,7 @@ struct Cli{
 
 #[derive(Subcommand)]
 enum Commands{
+	Info(InfoSubcommand),
 	DownloadHistory(DownloadHistorySubcommand),
 	Download(DownloadSubcommand),
 	DownloadDecompile(DownloadDecompileSubcommand),
@@ -33,17 +35,22 @@ enum Commands{
 	DecompileHistoryIntoGit(DecompileHistoryIntoGitSubcommand),
 	DownloadAndDecompileHistoryIntoGit(DownloadAndDecompileHistoryIntoGitSubcommand),
 }
+#[derive(Args)]
+struct InfoSubcommand{
+	#[arg(long)]
+	path:PathBuf,
+}
 
 #[derive(Args)]
 struct DownloadHistorySubcommand{
 	#[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)]
 	output_folder:Option<PathBuf>,
 	#[arg(long)]
@@ -68,12 +75,12 @@ struct DownloadSubcommand{
 }
 #[derive(Args)]
 struct DownloadGroupInventoryJsonSubcommand{
-	#[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)]
@@ -94,7 +101,9 @@ struct CreateAssetSubcommand{
 	#[arg(long)]
 	input_file:PathBuf,
 	#[arg(long)]
-	group:Option<u64>,
+	creator_user_id:u64,
+	#[arg(long)]
+	creator_group_id:Option<u64>,
 }
 #[derive(Args)]
 struct UpdateAssetSubcommand{
@@ -146,8 +155,6 @@ struct CompileUploadAssetSubcommand{
 	#[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>,
@@ -167,8 +174,6 @@ 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>,
@@ -192,12 +197,12 @@ struct DecompileSubcommand{
 }
 #[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)]
@@ -234,12 +239,12 @@ struct DecompileHistoryIntoGitSubcommand{
 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
 	//output_folder:cli.output.unwrap(),
 	#[arg(long)]
@@ -272,30 +277,42 @@ impl Style{
 	}
 }
 
+async fn info(path:PathBuf)->AResult<()>{
+	let dir=std::env::current_dir().unwrap();
+	println!("pwd={:?}",dir);
+	println!("path={path:?}");
+	let mut read_dir=tokio::fs::read_dir(path).await?;
+	while let Some(entry)=read_dir.next_entry().await?{
+		println!("{:?}",entry);
+	}
+	Ok(())
+}
+
 #[tokio::main]
 async fn main()->AResult<()>{
 	let cli=Cli::parse();
 	match cli.command{
+		Commands::Info(subcommand)=>info(subcommand.path).await,
 		Commands::DownloadHistory(subcommand)=>download_history(DownloadHistoryConfig{
 			continue_from_versions:subcommand.continue_from_versions.unwrap_or(false),
 			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()),
-			api_key:ApiKey::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?.get(),
+			).await?,
 			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(
-				ApiKey::from_args(
+				api_key_from_args(
 					subcommand.api_key_literal,
 					subcommand.api_key_envvar,
 					subcommand.api_key_file,
-				).await?.get(),
+				).await?,
 				subcommand.asset_ids.into_iter().map(|asset_id|{
 					let mut path=output_folder.clone();
 					path.push(asset_id.to_string());
@@ -305,11 +322,11 @@ async fn main()->AResult<()>{
 		},
 		Commands::DownloadDecompile(subcommand)=>{
 			download_decompile(DownloadDecompileConfig{
-				api_key:ApiKey::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?.get(),
+				).await?,
 				asset_id:subcommand.asset_id,
 				output_folder:subcommand.output_folder.unwrap_or_else(||std::env::current_dir().unwrap()),
 				style:subcommand.style.rox(),
@@ -319,40 +336,41 @@ async fn main()->AResult<()>{
 			}).await
 		},
 		Commands::DownloadGroupInventoryJson(subcommand)=>download_group_inventory_json(
-			ApiKey::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?.get(),
+			).await?,
 			subcommand.group,
 			subcommand.output_folder.unwrap_or_else(||std::env::current_dir().unwrap()),
 		).await,
 		Commands::CreateAsset(subcommand)=>create(CreateConfig{
-			api_key:ApiKey::from_args(
+			api_key:api_key_from_args(
 				subcommand.api_key_literal,
 				subcommand.api_key_envvar,
 				subcommand.api_key_file,
-			).await?.get(),
+			).await?,
-			group:subcommand.group,
+			creator_user_id:subcommand.creator_user_id,
+			creator_group_id:subcommand.creator_group_id,
 			input_file:subcommand.input_file,
 			model_name:subcommand.model_name,
 			description:subcommand.description.unwrap_or_else(||String::with_capacity(0)),
 		}).await,
 		Commands::UploadAsset(subcommand)=>upload_asset(UploadAssetConfig{
-			api_key:ApiKey::from_args(
+			api_key:api_key_from_args(
 				subcommand.api_key_literal,
 				subcommand.api_key_envvar,
 				subcommand.api_key_file,
-			).await?.get(),
+			).await?,
 			asset_id:subcommand.asset_id,
 			input_file:subcommand.input_file,
 		}).await,
 		Commands::UploadPlace(subcommand)=>upload_place(UploadPlaceConfig{
-			api_key:ApiKey::from_args(
+			api_key:api_key_from_args(
 				subcommand.api_key_literal,
 				subcommand.api_key_envvar,
 				subcommand.api_key_file,
-			).await?.get(),
+			).await?,
 			place_id:subcommand.place_id,
 			universe_id:subcommand.universe_id,
 			input_file:subcommand.input_file,
@@ -367,22 +385,22 @@ 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:ApiKey::from_args(
+			api_key:api_key_from_args(
 				subcommand.api_key_literal,
 				subcommand.api_key_envvar,
 				subcommand.api_key_file,
-			).await?.get(),
+			).await?,
 			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(
+			api_key:api_key_from_args(
 				subcommand.api_key_literal,
 				subcommand.api_key_envvar,
 				subcommand.api_key_file,
-			).await?.get(),
+			).await?,
 			place_id:subcommand.place_id,
 			universe_id:subcommand.universe_id,
 		}).await,
@@ -407,11 +425,11 @@ 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:ApiKey::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?.get(),
+			).await?,
 			asset_id:subcommand.asset_id,
 			output_folder:std::env::current_dir()?,
 			style:subcommand.style.rox(),
@@ -422,86 +440,91 @@ async fn main()->AResult<()>{
 	}
 }
 
-struct ApiKey(String);
+async fn cookie_from_args(literal:Option<String>,environment:Option<String>,file:Option<PathBuf>)->AResult<Cookie>{
-impl ApiKey{
+	let cookie=match (literal,environment,file){
-	fn get(self)->String{
+		(Some(cookie_literal),None,None)=>cookie_literal,
-		self.0
+		(None,Some(cookie_environment),None)=>std::env::var(cookie_environment)?,
-	}
+		(None,None,Some(cookie_file))=>tokio::fs::read_to_string(cookie_file).await?,
-	async fn from_args(literal:Option<String>,environment:Option<String>,file:Option<PathBuf>)->AResult<Self>{
+		_=>Err(anyhow::Error::msg("Illegal api key argument triple"))?,
-		let api_key=match (literal,environment,file){
+	};
-			(Some(api_key_literal),None,None)=>api_key_literal,
+	Ok(Cookie::new(format!(".ROBLOSECURITY={cookie}")))
-			(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?,
+async fn api_key_from_args(literal:Option<String>,environment:Option<String>,file:Option<PathBuf>)->AResult<ApiKey>{
-			_=>Err(anyhow::Error::msg("Illegal api key argument triple"))?,
+	let api_key=match (literal,environment,file){
-		};
+		(Some(api_key_literal),None,None)=>api_key_literal,
-		Ok(Self(api_key))
+		(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(ApiKey::new(api_key))
 }
 
 struct CreateConfig{
-	api_key:String,
+	api_key:ApiKey,
 	model_name:String,
 	description:String,
 	input_file:PathBuf,
-	group:Option<u64>,
+	creator_user_id:u64,
+	creator_group_id:Option<u64>,
 }
 
 ///This is hardcoded to create models atm
 async fn create(config:CreateConfig)->AResult<()>{
-	let resp=RobloxContext::new(config.api_key)
+	let resp=CloudContext::new(config.api_key)
-	.create_asset(rbx_asset::context::CreateAssetRequest{
+	.create_asset(rbx_asset::cloud::CreateAssetRequest{
-		assetType:rbx_asset::context::AssetType::Model,
+		assetType:rbx_asset::cloud::AssetType::Model,
 		displayName:config.model_name,
 		description:config.description,
-		creationContext:rbx_asset::context::CreationContext{
+		creationContext:rbx_asset::cloud::CreationContext{
-			creator:rbx_asset::context::Creator{
+			creator:rbx_asset::cloud::Creator{
-				userId:0,//ever needed? roblox should implicitly know this
+				userId:config.creator_user_id,
-				groupId:config.group.unwrap_or(0),
+				groupId:config.creator_group_id.unwrap_or(0),
 			},
 			expectedPrice:0,
 		}
 	},tokio::fs::read(config.input_file).await?).await?;
+	println!("CreateResponse={:?}",resp);
+	Ok(())
+}
+
+struct UploadAssetConfig{
+	api_key:ApiKey,
+	asset_id:u64,
+	input_file:PathBuf,
+}
+async fn upload_asset(config:UploadAssetConfig)->AResult<()>{
+	let context=CloudContext::new(config.api_key);
+	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(())
 }
 
-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(())
-}
-
 struct UploadPlaceConfig{
-	api_key:String,
+	api_key:ApiKey,
 	place_id:u64,
 	universe_id:u64,
 	input_file:PathBuf,
 }
 async fn upload_place(config:UploadPlaceConfig)->AResult<()>{
-	let context=RobloxContext::new(config.api_key);
+	let context=CloudContext::new(config.api_key);
-	context.update_place(rbx_asset::context::UpdatePlaceRequest{
+	context.update_place(rbx_asset::cloud::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<()>{
+async fn download_list(api_key:ApiKey,asset_id_file_map:AssetIDFileMap)->AResult<()>{
-	let context=RobloxContext::new(api_key);
+	let context=CloudContext::new(api_key);
 	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::context::GetAssetRequest{asset_id,version:None}).await?))
+			Ok((file,context.get_asset(rbx_asset::cloud::GetAssetRequest{asset_id,version:None}).await?))
 		}
 	}))
 	.buffer_unordered(CONCURRENT_REQUESTS)
@@ -519,11 +542,11 @@ async fn download_list(api_key:String,asset_id_file_map:AssetIDFileMap)->AResult
 	Ok(())
 }
 
-async fn get_inventory_pages(context:&RobloxContext,group:u64)->AResult<Vec<InventoryItem>>{
+async fn get_inventory_pages(context:&CookieContext,group:u64)->AResult<Vec<InventoryItem>>{
 	let mut cursor:Option<String>=None;
 	let mut asset_list=Vec::new();
 	loop{
-		let mut page=context.inventory_page(rbx_asset::context::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;
@@ -533,8 +556,8 @@ async fn get_inventory_pages(context:&RobloxContext,group:u64)->AResult<Vec<Inve
 	Ok(asset_list)
 }
 
-async fn download_group_inventory_json(api_key:String,group:u64,output_folder:PathBuf)->AResult<()>{
+async fn download_group_inventory_json(cookie:Cookie,group:u64,output_folder:PathBuf)->AResult<()>{
-	let context=RobloxContext::new(api_key);
+	let context=CookieContext::new(cookie);
 	let item_list=get_inventory_pages(&context,group).await?;
 
 	let mut path=output_folder.clone();
@@ -544,11 +567,11 @@ async fn download_group_inventory_json(api_key:String,group:u64,output_folder:Pa
 	Ok(())
 }
 
-async fn get_version_history(context:&RobloxContext,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::context::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;
@@ -564,7 +587,7 @@ struct DownloadHistoryConfig{
 	end_version:Option<u64>,
 	start_version:u64,
 	output_folder:PathBuf,
-	api_key:String,
+	cookie:Cookie,
 	asset_id:AssetID,
 }
 
@@ -605,7 +628,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.api_key);
+	let context=CookieContext::new(config.cookie);
 
 	//limit concurrent downloads
 	let mut join_set=tokio::task::JoinSet::new();
@@ -613,7 +636,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.get_asset_versions(rbx_asset::context::AssetVersionsRequest{asset_id:config.asset_id,cursor}).await?;
+		let mut page=context.get_asset_versions_page(rbx_asset::cookie::AssetVersionsPageRequest{asset_id:config.asset_id,cursor}).await?;
 		let context=&context;
 		let output_folder=config.output_folder.clone();
 		let data=&page.data;
@@ -643,7 +666,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::context::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?;
 
@@ -738,7 +761,7 @@ async fn decompile(config:DecompileConfig)->AResult<()>{
 }
 
 struct DownloadDecompileConfig{
-	api_key:String,
+	cookie:Cookie,
 	asset_id:AssetID,
 	style:rox_compiler::Style,
 	output_folder:PathBuf,
@@ -748,8 +771,8 @@ struct DownloadDecompileConfig{
 }
 
 async fn download_decompile(config:DownloadDecompileConfig)->AResult<()>{
-	let context=RobloxContext::new(config.api_key);
+	let context=CookieContext::new(config.cookie);
-	let file=context.get_asset(rbx_asset::context::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);
@@ -906,7 +929,7 @@ async fn decompile_history_into_git(config:DecompileHistoryConfig)->AResult<()>{
 }
 
 struct DownloadAndDecompileHistoryConfig{
-	api_key:String,
+	cookie:Cookie,
 	asset_id:AssetID,
 	git_committer_name:String,
 	git_committer_email:String,
@@ -918,7 +941,7 @@ struct DownloadAndDecompileHistoryConfig{
 }
 
 async fn download_and_decompile_history_into_git(config:DownloadAndDecompileHistoryConfig)->AResult<()>{
-	let context=RobloxContext::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?;
@@ -931,7 +954,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::context::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)))
 		})
@@ -989,7 +1012,7 @@ struct CompileUploadAssetConfig{
 	input_folder:PathBuf,
 	template:Option<PathBuf>,
 	style:Option<rox_compiler::Style>,
-	api_key:String,
+	api_key:ApiKey,
 	asset_id:AssetID,
 }
 async fn compile_upload_asset(config:CompileUploadAssetConfig)->AResult<()>{
@@ -1009,12 +1032,13 @@ 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=RobloxContext::new(config.api_key);
+	let context=CloudContext::new(config.api_key);
-	context.update_asset(rbx_asset::context::UpdateAssetRequest{
+	let resp=context.update_asset(rbx_asset::cloud::UpdateAssetRequest{
 		assetId:config.asset_id,
 		displayName:None,
 		description:None,
 	},data).await?;
+	println!("UploadResponse={:?}",resp);
 	Ok(())
 }
 
@@ -1022,7 +1046,7 @@ struct CompileUploadPlaceConfig{
 	input_folder:PathBuf,
 	template:Option<PathBuf>,
 	style:Option<rox_compiler::Style>,
-	api_key:String,
+	api_key:ApiKey,
 	place_id:u64,
 	universe_id:u64,
 }
@@ -1043,8 +1067,8 @@ async fn compile_upload_place(config:CompileUploadPlaceConfig)->AResult<()>{
 	rbx_binary::to_writer(std::io::Cursor::new(&mut data),&dom,dom.root().children())?;
 
 	//upload it
-	let context=RobloxContext::new(config.api_key);
+	let context=CloudContext::new(config.api_key);
-	context.update_place(rbx_asset::context::UpdatePlaceRequest{
+	context.update_place(rbx_asset::cloud::UpdatePlaceRequest{
 		universeId:config.universe_id,
 		placeId:config.place_id,
 	},data).await?;