handle file variations correctly

Tested to some extent

Reviewed-on: #18
Co-authored-by: Rhys Lloyd <krakow20@gmail.com>
Co-committed-by: Rhys Lloyd <krakow20@gmail.com>

Cargo.toml

@@ -10,7 +10,7 @@ edition = "2021"
 anyhow = "1.0.75"
 clap = { version = "4.4.2", features = ["derive"] }
 futures = "0.3.30"
-gix = "0.72.1"
+git2 = "0.20.0"
 lazy-regex = "3.1.0"
 rbx_asset = { path = "rbx_asset" }
 rbx_binary = "1.0.0"

rbx_asset/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rbx_asset"
-version = "0.4.8"
+version = "0.4.10"
 edition = "2021"
 publish = ["strafesnet"]
 repository = "https://git.itzana.me/StrafesNET/asset-tool"
@@ -11,14 +11,21 @@ authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [features]
-default = ["gzip"]
+default = ["gzip", "default-tls"]
 gzip = ["dep:flate2"]
 
+default-tls = ["reqwest/default-tls"]
+rustls-tls = ["reqwest/rustls-tls"]
+
 [dependencies]
 bytes = "1.10.1"
 chrono = { version = "0.4.38", features = ["serde"] }
 flate2 = { version = "1.0.29", optional = true }
-reqwest = { version = "0.12.4", features = ["json","multipart"] }
+reqwest = { version = "0.12.4", features = [
+	"json", "multipart",
+	# default features
+	"charset", "http2", "system-proxy"
+], default-features = false }
 serde = { version = "1.0.199", features = ["derive"] }
 serde_json = "1.0.111"
 url = "2.5.0"

rbx_asset/src/cloud.rs

@@ -1,3 +1,4 @@
+use crate::body::{Binary,ContentType,Json};
 use crate::util::{serialize_u64,deserialize_u64,response_ok};
 use crate::types::{ResponseError,MaybeGzippedBytes};
 
@@ -117,8 +118,8 @@ impl std::fmt::Display for UpdateError{
 }
 impl std::error::Error for UpdateError{}
 
-struct GetAssetOperationRequest{
-	operation_id:String,
+struct GetAssetOperationRequest<'a>{
+	operation_id:&'a str,
 }
 pub struct GetAssetLatestRequest{
 	pub asset_id:u64,
@@ -172,7 +173,7 @@ pub struct GetAssetVersionRequest{
 }
 #[derive(Debug)]
 pub enum GetError{
-	ParseError(url::ParseError),
+	Parse(url::ParseError),
 	Response(ResponseError),
 	Reqwest(reqwest::Error),
 }
@@ -320,13 +321,119 @@ impl RobloxOperation{
 	pub async fn try_get_reponse(&self,context:&Context)->Result<serde_json::Value,OperationError>{
 		context.get_asset_operation(GetAssetOperationRequest{
 			operation_id:self.operation_id()
-				.ok_or(OperationError::NoOperationId)?
-				.to_owned(),
+				.ok_or(OperationError::NoOperationId)?,
 		}).await.map_err(OperationError::Get)?
 		.response.ok_or(OperationError::NotDone)
 	}
 }
 
+#[derive(Debug)]
+pub enum LuauSessionError{
+	Get(GetError),
+	Unspecified,
+	NotDone,
+	NoOutput,
+	NoError,
+}
+impl std::fmt::Display for LuauSessionError{
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f,"{self:?}")
+	}
+}
+impl std::error::Error for LuauSessionError{}
+#[derive(Debug,serde::Serialize)]
+#[expect(nonstandard_style)]
+pub struct LuauSessionCreate<'a>{
+	pub script:&'a str,
+	#[serde(skip_serializing_if="Option::is_none")]
+	pub user:Option<&'a str>,
+	#[serde(skip_serializing_if="Option::is_none")]
+	pub timeout:Option<&'a str>,
+	#[serde(skip_serializing_if="Option::is_none")]
+	pub binaryInput:Option<&'a str>,
+	#[serde(skip_serializing_if="Option::is_none")]
+	pub enableBinaryOutput:Option<bool>,
+	#[serde(skip_serializing_if="Option::is_none")]
+	pub binaryOutputUri:Option<&'a str>,
+}
+#[derive(Debug,serde::Deserialize)]
+#[expect(nonstandard_style)]
+pub enum LuauSessionState{
+	STATE_UNSPECIFIED,
+	PROCESSING,
+	COMPLETE,
+	FAILED,
+}
+#[derive(Debug,serde::Deserialize)]
+pub struct LuauError{
+	pub code:String,
+	pub message:String,
+}
+#[derive(Debug,serde::Deserialize)]
+pub struct LuauResults{
+	pub results:Vec<serde_json::Value>,
+}
+#[derive(Debug,serde::Deserialize)]
+#[expect(nonstandard_style)]
+pub struct LuauSessionResponse{
+	path:String,
+	#[serde(deserialize_with="deserialize_u64")]
+	pub user:u64,
+	pub state:LuauSessionState,
+	pub script:String,
+	pub error:Option<LuauError>,
+	pub output:Option<LuauResults>,
+	pub binaryInput:String,
+	pub enableBinaryOutput:bool,
+	pub binaryOutputUri:String,
+}
+impl LuauSessionResponse{
+	pub fn path(&self)->&str{
+		&self.path
+	}
+	pub async fn try_get_result(&self,context:&Context)->Result<Result<LuauResults,LuauError>,LuauSessionError>{
+		let response=context.get_luau_session(self).await.map_err(LuauSessionError::Get)?;
+		match response.state{
+			LuauSessionState::STATE_UNSPECIFIED=>Err(LuauSessionError::Unspecified),
+			LuauSessionState::PROCESSING=>Err(LuauSessionError::NotDone),
+			LuauSessionState::COMPLETE=>Ok(Ok(response.output.ok_or(LuauSessionError::NoOutput)?)),
+			LuauSessionState::FAILED=>Ok(Err(response.error.ok_or(LuauSessionError::NoError)?)),
+		}
+	}
+}
+pub trait AsSessionPath{
+	fn into_session_path(&self)->impl AsRef<str>;
+}
+impl AsSessionPath for LuauSessionResponse{
+	fn into_session_path(&self)->impl AsRef<str>{
+		&self.path
+	}
+}
+pub struct LuauSessionLatestRequest{
+	pub universe_id:u64,
+	pub place_id:u64,
+}
+impl AsSessionPath for LuauSessionLatestRequest{
+	fn into_session_path(&self)->impl AsRef<str>{
+		let universe_id=self.universe_id;
+		let place_id=self.place_id;
+		format!("universes/{universe_id}/places/{place_id}/luau-execution-session-tasks")
+	}
+}
+pub struct LuauSessionVersionRequest{
+	pub universe_id:u64,
+	pub place_id:u64,
+	pub version_id:u64,
+}
+impl AsSessionPath for LuauSessionVersionRequest{
+	fn into_session_path(&self)->impl AsRef<str>{
+		let universe_id=self.universe_id;
+		let place_id=self.place_id;
+		let version_id=self.version_id;
+		format!("universes/{universe_id}/places/{place_id}/versions/{version_id}/luau-execution-session-tasks")
+	}
+}
+
 #[derive(Clone)]
 pub struct ApiKey(String);
 impl ApiKey{
@@ -356,9 +463,10 @@ impl Context{
 		.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,reqwest::Error>{
+	async fn post(&self,url:url::Url,body:impl ContentType)->Result<reqwest::Response,reqwest::Error>{
 		self.client.post(url)
 		.header("x-api-key",self.api_key.as_str())
+		.header("Content-Type",body.content_type())
 		.body(body)
 		.send().await
 	}
@@ -415,18 +523,38 @@ impl Context{
 			operation,
 		})
 	}
-	async fn get_asset_operation(&self,config:GetAssetOperationRequest)->Result<RobloxOperation,GetError>{
+	async fn get_asset_operation(&self,config:GetAssetOperationRequest<'_>)->Result<RobloxOperation,GetError>{
 		let raw_url=format!("https://apis.roblox.com/assets/v1/operations/{}",config.operation_id);
-		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::ParseError)?;
+		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::Parse)?;
 
 		response_ok(
 			self.get(url).await.map_err(GetError::Reqwest)?
 		).await.map_err(GetError::Response)?
 		.json::<RobloxOperation>().await.map_err(GetError::Reqwest)
 	}
+	pub async fn create_luau_session(&self,config:&impl AsSessionPath,session:LuauSessionCreate<'_>)->Result<LuauSessionResponse,CreateError>{
+		let raw_url=format!("https://apis.roblox.com/cloud/v2/{}",config.into_session_path().as_ref());
+		let url=reqwest::Url::parse(raw_url.as_str()).map_err(CreateError::Parse)?;
+
+		let body=serde_json::to_string(&session).map_err(CreateError::Serialize)?;
+
+		response_ok(
+			self.post(url,Json(body)).await.map_err(CreateError::Reqwest)?
+		).await.map_err(CreateError::Response)?
+		.json::<LuauSessionResponse>().await.map_err(CreateError::Reqwest)
+	}
+	pub async fn get_luau_session(&self,config:&impl AsSessionPath)->Result<LuauSessionResponse,GetError>{
+		let raw_url=format!("https://apis.roblox.com/cloud/v2/{}",config.into_session_path().as_ref());
+		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::Parse)?;
+
+		response_ok(
+			self.get(url).await.map_err(GetError::Reqwest)?
+		).await.map_err(GetError::Response)?
+		.json::<LuauSessionResponse>().await.map_err(GetError::Reqwest)
+	}
 	pub async fn get_asset_info(&self,config:GetAssetLatestRequest)->Result<AssetResponse,GetError>{
 		let raw_url=format!("https://apis.roblox.com/assets/v1/assets/{}",config.asset_id);
-		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::ParseError)?;
+		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::Parse)?;
 
 		response_ok(
 			self.get(url).await.map_err(GetError::Reqwest)?
@@ -435,7 +563,7 @@ impl Context{
 	}
 	pub async fn get_asset_version_info(&self,config:GetAssetVersionRequest)->Result<AssetResponse,GetError>{
 		let raw_url=format!("https://apis.roblox.com/assets/v1/assets/{}/versions/{}",config.asset_id,config.version);
-		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::ParseError)?;
+		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::Parse)?;
 
 		response_ok(
 			self.get(url).await.map_err(GetError::Reqwest)?
@@ -444,7 +572,7 @@ impl Context{
 	}
 	pub async fn get_asset_location(&self,config:GetAssetLatestRequest)->Result<AssetLocationInfo,GetError>{
 		let raw_url=format!("https://apis.roblox.com/asset-delivery-api/v1/assetId/{}",config.asset_id);
-		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::ParseError)?;
+		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::Parse)?;
 
 		response_ok(
 			self.get(url).await.map_err(GetError::Reqwest)?
@@ -453,7 +581,7 @@ impl Context{
 	}
 	pub async fn get_asset_version_location(&self,config:GetAssetVersionRequest)->Result<AssetLocationInfo,GetError>{
 		let raw_url=format!("https://apis.roblox.com/asset-delivery-api/v1/assetId/{}/version/{}",config.asset_id,config.version);
-		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::ParseError)?;
+		let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::Parse)?;
 
 		response_ok(
 			self.get(url).await.map_err(GetError::Reqwest)?
@@ -461,7 +589,7 @@ impl Context{
 		.json().await.map_err(GetError::Reqwest)
 	}
 	pub async fn get_asset(&self,config:&AssetLocation)->Result<MaybeGzippedBytes,GetError>{
-		let url=reqwest::Url::parse(config.location()).map_err(GetError::ParseError)?;
+		let url=reqwest::Url::parse(config.location()).map_err(GetError::Parse)?;
 
 		let bytes=response_ok(
 			self.get(url).await.map_err(GetError::Reqwest)?
@@ -504,7 +632,7 @@ impl Context{
 		}
 
 		response_ok(
-			self.post(url,body).await.map_err(UpdateError::Reqwest)?
+			self.post(url,Binary(body)).await.map_err(UpdateError::Reqwest)?
 		).await.map_err(UpdateError::Response)?
 		.json::<UpdatePlaceResponse>().await.map_err(UpdateError::Reqwest)
 	}

rbx_asset/src/cookie.rs

@@ -141,10 +141,11 @@ impl GetAssetV2Location{
 pub struct GetAssetV2Info{
 	pub locations:Vec<GetAssetV2Location>,
 	pub requestId:String,
-	pub IsHashDynamic:bool,
-	pub IsCopyrightProtected:bool,
 	pub isArchived:bool,
 	pub assetTypeId:u32,
+	pub isRecordable:Option<bool>,
+	pub IsHashDynamic:Option<bool>,
+	pub IsCopyrightProtected:Option<bool>,
 }
 
 pub struct GetAssetV2{
@@ -285,7 +286,7 @@ pub struct UserInventoryPageRequest{
 pub struct UserInventoryItemOwner{
 	pub userId:u64,
 	pub username:String,
-	pub buildersClubMembershipType:u64,
+	pub buildersClubMembershipType:String,
 }
 #[derive(serde::Deserialize,serde::Serialize)]
 #[allow(nonstandard_style,dead_code)]
@@ -590,7 +591,7 @@ impl Context{
 		).await.map_err(GetError::Response)?
 		.json().await.map_err(GetError::Reqwest)
 	}
-	pub async fn get_asset_versions_page(&self,config:AssetVersionsPageRequest)->Result<AssetVersionsPageResponse,PageError>{
+	pub async fn get_asset_versions_page(&self,config:&AssetVersionsPageRequest)->Result<AssetVersionsPageResponse,PageError>{
 		let mut url=reqwest::Url::parse(format!("https://develop.roblox.com/v1/assets/{}/saved-versions",config.asset_id).as_str()).map_err(PageError::ParseError)?;
 		//url borrow scope
 		{

rbx_asset/src/types.rs

@@ -1,4 +1,3 @@
-#[allow(dead_code)]
 #[derive(Debug)]
 pub struct UrlAndBody{
 	pub url:url::Url,

rox_compiler/src/compile.rs

@@ -16,7 +16,6 @@ use crate::common::{sanitize,Style,PropertiesOverride};
 //I could use a function!
 //eventually:
 #[derive(Debug)]
-#[allow(dead_code)]//idk why this thinks it's dead code, the errors are printed out in various places
 pub enum QueryResolveError{
 	NotFound,//0 results
 	Ambiguous,//>1 results

src/main.rs

@@ -1,7 +1,8 @@
-use std::{io::Read,path::PathBuf};
+use std::io::Read;
+use std::path::{Path,PathBuf};
 use clap::{Args,Parser,Subcommand};
 use anyhow::{anyhow,Result as AResult};
-use futures::StreamExt;
+use futures::{StreamExt,TryStreamExt};
 use rbx_asset::cloud::{ApiKey,Context as CloudContext};
 use rbx_asset::cookie::{Cookie,Context as CookieContext,AssetVersion,CreationsItem};
 
@@ -9,6 +10,7 @@ type AssetID=u64;
 type AssetIDFileMap=Vec<(AssetID,PathBuf)>;
 const CONCURRENT_DECODE:usize=8;
 const CONCURRENT_REQUESTS:usize=32;
+const CONCURRENT_FS:usize=64;
 
 #[derive(Parser)]
 #[command(author,version,about,long_about=None)]
@@ -29,6 +31,7 @@ enum Commands{
 	DownloadVersionV2(DownloadVersionSubcommand),
 	DownloadDecompile(DownloadDecompileSubcommand),
 	DownloadCreationsJson(DownloadCreationsJsonSubcommand),
+	DownloadCreationsHistory(DownloadCreationsHistorySubcommand),
 	DownloadUserInventoryJson(DownloadUserInventoryJsonSubcommand),
 	CreateAsset(CreateAssetSubcommand),
 	CreateAssetMedia(CreateAssetMediaSubcommand),
@@ -42,6 +45,7 @@ enum Commands{
 	Decompile(DecompileSubcommand),
 	DecompileHistoryIntoGit(DecompileHistoryIntoGitSubcommand),
 	DownloadAndDecompileHistoryIntoGit(DownloadAndDecompileHistoryIntoGitSubcommand),
+	RunLuau(RunLuauSubcommand),
 }
 
 /// Download a range of assets from the asset version history.  Download summary is saved to `output_folder/versions.json`, and can be optionally used to download only new versions the next time.
@@ -147,6 +151,8 @@ struct DownloadCreationsJsonSubcommand{
 	group_id:Option<u64>,
 	#[arg(long,group="owner",required=true)]
 	user_id:Option<u64>,
+	#[arg(long)]
+	continue_from_cursor:Option<bool>,
 }
 /// Download the list of asset ids (not the assets themselves) in a user's inventory.  The output is written to `output_folder/versions.json`
 #[derive(Args)]
@@ -427,6 +433,24 @@ struct DownloadAndDecompileHistoryIntoGitSubcommand{
 	#[arg(long)]
 	write_scripts:Option<bool>,
 }
+/// Run a Luau script.
+#[derive(Args)]
+struct RunLuauSubcommand{
+	#[arg(long,group="api_key",required=true)]
+	api_key_literal:Option<String>,
+	#[arg(long,group="api_key",required=true)]
+	api_key_envvar:Option<String>,
+	#[arg(long,group="api_key",required=true)]
+	api_key_file:Option<PathBuf>,
+	#[arg(long,group="script",required=true)]
+	script_literal:Option<String>,
+	#[arg(long,group="script",required=true)]
+	script_file:Option<PathBuf>,
+	#[arg(long)]
+	universe_id:u64,
+	#[arg(long)]
+	place_id:u64,
+}
 
 #[derive(Clone,Copy,Debug,clap::ValueEnum)]
 enum Style{
@@ -581,7 +605,9 @@ async fn main()->AResult<()>{
 				subcommand.group_id,
 			)?,
 			subcommand.output_folder.unwrap_or_else(||std::env::current_dir().unwrap()),
+			subcommand.continue_from_cursor.unwrap_or(false),
 		).await,
+		Commands::DownloadCreationsHistory(subcommand)=>subcommand.run().await,
 		Commands::DownloadUserInventoryJson(subcommand)=>download_user_inventory_json(
 			cookie_from_args(
 				subcommand.cookie_literal,
@@ -738,6 +764,21 @@ async fn main()->AResult<()>{
 			write_models:subcommand.write_models.unwrap_or(false),
 			write_scripts:subcommand.write_scripts.unwrap_or(true),
 		 }).await,
+		Commands::RunLuau(subcommand)=>run_luau(RunLuauConfig{
+			api_key:api_key_from_args(
+				subcommand.api_key_literal,
+				subcommand.api_key_envvar,
+				subcommand.api_key_file,
+			).await?,
+			script:match subcommand.script_literal{
+				Some(script)=>script,
+				None=>std::fs::read_to_string(subcommand.script_file.unwrap())?,
+			},
+			request:rbx_asset::cloud::LuauSessionLatestRequest{
+				place_id:subcommand.place_id,
+				universe_id:subcommand.universe_id,
+			},
+		}).await,
 	}
 }
 
@@ -851,7 +892,7 @@ struct CreateAssetMediasConfig{
 }
 
 #[derive(Debug)]
-#[allow(dead_code)]
+#[expect(dead_code)]
 enum CreateAssetMediasError{
 	NoFileStem(PathBuf),
 	IO(std::io::Error),
@@ -866,7 +907,7 @@ impl std::fmt::Display for CreateAssetMediasError{
 impl std::error::Error for CreateAssetMediasError{}
 
 #[derive(Debug)]
-#[allow(dead_code)]
+#[expect(dead_code)]
 enum PollOperationError{
 	CreateAssetMedias(CreateAssetMediasError),
 	AssetOperation(rbx_asset::cloud::AssetOperationError),
@@ -879,7 +920,7 @@ impl std::fmt::Display for PollOperationError{
 impl std::error::Error for PollOperationError{}
 
 #[derive(Debug)]
-#[allow(dead_code)]
+#[expect(dead_code)]
 enum DownloadDecalError{
 	PollOperation(PollOperationError),
 	ParseInt(std::num::ParseIntError),
@@ -1120,30 +1161,100 @@ async fn download_location(api_key:ApiKey,asset_id:AssetID,version:Option<u64>)-
 	Ok(())
 }
 
-async fn get_creations_pages(context:&CookieContext,owner:rbx_asset::cookie::Owner)->AResult<Vec<CreationsItem>>{
-	let mut config=rbx_asset::cookie::CreationsPageRequest{
-		owner,
-		cursor:None,
-	};
-	let mut asset_list=Vec::new();
+async fn get_creations_pages(
+	context:&CookieContext,
+	asset_list:&mut Vec<rbx_asset::cookie::CreationsItem>,
+	config:&mut rbx_asset::cookie::CreationsPageRequest,
+)->AResult<()>{
 	loop{
 		let mut page=context.get_creations_page(&config).await?;
 		asset_list.append(&mut page.data);
-		if page.nextPageCursor.is_none(){
+		config.cursor=page.nextPageCursor;
+		if config.cursor.is_none(){
 			break;
 		}
-		config.cursor=page.nextPageCursor;
 	}
+	Ok(())
+}
+
+async fn download_creations_pages_from_checkpoint(context:&CookieContext,owner:rbx_asset::cookie::Owner,output_folder:&Path,continue_from_cursor:bool)->AResult<Vec<CreationsItem>>{
+	let mut versions_path=output_folder.to_owned();
+	versions_path.set_file_name("versions.json");
+	let mut cursor_path=output_folder.to_owned();
+	cursor_path.set_file_name("cursor");
+
+	let (mut asset_list,mut config)=if continue_from_cursor{
+		// load state from files
+		let (versions,cursor)=tokio::join!(
+			tokio::fs::read(versions_path.as_path()),
+			tokio::fs::read_to_string(cursor_path.as_path()),
+		);
+		// allow versions to not exist
+		let (versions,cursor)=match (versions,cursor){
+			// continue downloading
+			(Ok(versions),Ok(cursor))=>(serde_json::from_slice(&versions)?,Some(cursor)),
+			// already downloaded
+			(Ok(versions),Err(e)) if matches!(e.kind(),std::io::ErrorKind::NotFound)=>return Ok(serde_json::from_slice(&versions)?),
+			// not downloaded
+			(Err(e),result) if matches!(e.kind(),std::io::ErrorKind::NotFound)=>{
+				match result{
+					Ok(_)=>{},
+					Err(e) if matches!(e.kind(),std::io::ErrorKind::NotFound)=>{},
+					Err(e)=>Err(e)?,
+				}
+				(Vec::new(),None)
+			},
+			// other errors
+			(Ok(_),Err(e))=>Err(e)?,
+			(Err(e),_)=>Err(e)?,
+		};
+		(
+			versions,
+			rbx_asset::cookie::CreationsPageRequest{
+				owner,
+				cursor,
+			}
+		)
+	}else{
+		// create new state
+		(
+			Vec::new(),
+			rbx_asset::cookie::CreationsPageRequest{
+				owner,
+				cursor:None,
+			}
+		)
+	};
+
+	get_creations_pages(&context,&mut asset_list,&mut config).await?;
+
+	let cursor_fut=async{
+		if let Some(cursor)=config.cursor{
+			println!("writing cursor state...");
+			// there was a problem, write out cursor
+			tokio::fs::write(cursor_path,cursor).await?;
+		}else{
+			// no cursor
+			if let Err(e)=tokio::fs::remove_file(cursor_path).await{
+				match e.kind(){
+					std::io::ErrorKind::NotFound=>println!("Cannot delete cursor: file not found"),
+					_=>Err(e)?,
+				}
+			}
+		}
+		Ok(())
+	};
+	let versions_fut=tokio::fs::write(versions_path,serde_json::to_string(&asset_list)?);
+
+	tokio::try_join!(versions_fut,cursor_fut)?;
+
 	Ok(asset_list)
 }
 
-async fn download_creations_json(cookie:Cookie,owner:rbx_asset::cookie::Owner,output_folder:PathBuf)->AResult<()>{
+async fn download_creations_json(cookie:Cookie,owner:rbx_asset::cookie::Owner,output_folder:PathBuf,continue_from_cursor:bool)->AResult<()>{
 	let context=CookieContext::new(cookie);
-	let item_list=get_creations_pages(&context,owner).await?;
 
-	let mut path=output_folder.clone();
-	path.set_file_name("versions.json");
-	tokio::fs::write(path,serde_json::to_string(&item_list)?).await?;
+	download_creations_pages_from_checkpoint(&context,owner,output_folder.as_path(),continue_from_cursor).await?;
 
 	Ok(())
 }
@@ -1168,7 +1279,7 @@ async fn download_user_inventory_json(cookie:Cookie,user_id:u64,output_folder:Pa
 	let mut versions_path=output_folder.clone();
 	versions_path.set_file_name("versions.json");
 	let mut cursor_path=output_folder.clone();
-	cursor_path.set_file_name("cursor.json");
+	cursor_path.set_file_name("cursor");
 
 	let context=CookieContext::new(cookie);
 
@@ -1216,18 +1327,163 @@ async fn download_user_inventory_json(cookie:Cookie,user_id:u64,output_folder:Pa
 	Ok(())
 }
 
+/// Download all versions of all assets created by a group or user.  The output is written to a folder structure in the output directory.
+#[derive(Args)]
+struct DownloadCreationsHistorySubcommand{
+	#[arg(long,group="cookie",required=true)]
+	cookie_literal:Option<String>,
+	#[arg(long,group="cookie",required=true)]
+	cookie_envvar:Option<String>,
+	#[arg(long,group="cookie",required=true)]
+	cookie_file:Option<PathBuf>,
+	#[arg(long,group="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="owner",required=true)]
+	group_id:Option<u64>,
+	#[arg(long,group="owner",required=true)]
+	user_id:Option<u64>,
+	#[arg(long)]
+	r#continue:Option<bool>,
+}
+impl DownloadCreationsHistorySubcommand{
+	async fn run(self)->AResult<()>{
+		download_creations_history(
+			cookie_from_args(
+				self.cookie_literal,
+				self.cookie_envvar,
+				self.cookie_file,
+			).await?,
+			api_key_from_args(
+				self.api_key_literal,
+				self.api_key_envvar,
+				self.api_key_file,
+			).await?,
+			owner_from_args(
+				self.user_id,
+				self.group_id,
+			)?,
+			self.output_folder.unwrap_or_else(||std::env::current_dir().unwrap()),
+			self.r#continue.unwrap_or(false),
+		).await
+	}
+}
+async fn download_creations_history(cookie:Cookie,api_key:ApiKey,owner:rbx_asset::cookie::Owner,output_folder:PathBuf,r#continue:bool)->AResult<()>{
+
+	let cookie_context=CookieContext::new(cookie);
+	let cloud_context=CloudContext::new(api_key);
+
+	// get list of all assets in inventory
+	let asset_list=download_creations_pages_from_checkpoint(&cookie_context,owner,output_folder.as_path(),r#continue).await?;
+
+	// create folder directories
+	let asset_folders:Vec<PathBuf> ={
+		futures::stream::iter(asset_list.iter().map(|asset|async{
+			// create asset folder
+			let mut asset_folder=output_folder.clone();
+			asset_folder.push(asset.id.to_string());
+			tokio::fs::create_dir_all(asset_folder.as_path()).await?;
+			Ok::<_,anyhow::Error>(asset_folder)
+		}))
+		.buffered(CONCURRENT_FS)
+		.try_collect().await?
+	};
+
+	#[expect(dead_code)]
+	#[derive(Debug)]
+	enum Error<'a>{
+		NoLocations(Job<'a>),
+		GetVersionLocationError(rbx_asset::cloud::GetError),
+		GetError(rbx_asset::cloud::GetError),
+		Io(std::io::Error),
+	}
+	#[derive(Clone,Copy,Debug)]
+	struct Job<'a>{
+		path:&'a PathBuf,
+		asset_id:u64,
+		asset_version:u64,
+	}
+	let mut job_list=Vec::new();
+
+	// create flattened futures stream to parallel download all asset versions
+	for (path,asset) in asset_folders.iter().zip(asset_list){
+
+		// save versions file
+		let mut versions_path=path.to_owned();
+		versions_path.push("versions.json");
+
+		let version_history=if r#continue{
+			let file=tokio::fs::read(versions_path.as_path()).await?;
+			serde_json::from_slice(&file)?
+		}else{
+			println!("Downloading history for {} - {}",asset.id,asset.name);
+			let version_history=get_version_history(&cookie_context,asset.id).await?;
+			println!("Found {} versions",version_history.len());
+			tokio::fs::write(versions_path,serde_json::to_string(&version_history)?).await?;
+			version_history
+		};
+
+		job_list.extend(version_history.into_iter().map(|asset_version|
+			Job{
+				path,
+				asset_id:asset.id,
+				asset_version:asset_version.assetVersionNumber,
+			}
+		));
+	}
+
+	println!("Completed jobs list. Number of jobs: {}",job_list.len());
+
+	futures::stream::iter(job_list).map(async|job|{
+		let mut dest=job.path.to_owned();
+		dest.push(format!("{}_v{}.rbxl",job.asset_id,job.asset_version));
+		//if the file already exists, don't try downloading it again
+		if tokio::fs::try_exists(dest.as_path()).await.map_err(Error::Io)?{
+			return Ok(());
+		}
+		let location=cloud_context.get_asset_version_location(rbx_asset::cloud::GetAssetVersionRequest{
+			asset_id:job.asset_id,
+			version:job.asset_version,
+		}).await.map_err(Error::GetVersionLocationError)?;
+		let location=location.location.ok_or(Error::NoLocations(job))?;
+		let downloaded=cloud_context.get_asset(&location).await.map_err(Error::GetError)?;
+		tokio::fs::write(dest,downloaded.to_vec().map_err(Error::Io)?).await.map_err(Error::Io)?;
+		Ok(())
+	})
+	.buffer_unordered(CONCURRENT_REQUESTS)
+	.for_each(async|result|{
+		match result{
+			Ok(())=>{},
+			Err(Error::NoLocations(job))=>println!("Job failed due to no locations: asset_id={} version={}",job.asset_id,job.asset_version),
+			Err(e)=>println!("Error: {e:?}"),
+		}
+	}).await;
+
+	println!("All jobs complete.");
+
+	Ok(())
+}
+
 async fn get_version_history(context:&CookieContext,asset_id:AssetID)->AResult<Vec<AssetVersion>>{
-	let mut cursor:Option<String>=None;
+	let mut page_request=rbx_asset::cookie::AssetVersionsPageRequest{
+		asset_id,
+		cursor:None,
+	};
 	let mut asset_list=Vec::new();
 	loop{
-		let mut page=context.get_asset_versions_page(rbx_asset::cookie::AssetVersionsPageRequest{asset_id,cursor}).await?;
+		let mut page=context.get_asset_versions_page(&page_request).await?;
 		asset_list.append(&mut page.data);
 		if page.nextPageCursor.is_none(){
 			break;
 		}
-		cursor=page.nextPageCursor;
+		page_request.cursor=page.nextPageCursor;
 	}
-	asset_list.sort_by(|a,b|a.assetVersionNumber.cmp(&b.assetVersionNumber));
+	asset_list.sort_by_key(|a|a.assetVersionNumber);
 	Ok(asset_list)
 }
 
@@ -1283,9 +1539,12 @@ async fn download_history(mut config:DownloadHistoryConfig)->AResult<()>{
 	let mut join_set=tokio::task::JoinSet::new();
 
 	//poll paged list of all asset versions
-	let mut cursor:Option<String>=None;
+	let mut page_request=rbx_asset::cookie::AssetVersionsPageRequest{
+		asset_id:config.asset_id,
+		cursor:None,
+	};
 	loop{
-		let mut page=context.get_asset_versions_page(rbx_asset::cookie::AssetVersionsPageRequest{asset_id:config.asset_id,cursor}).await?;
+		let mut page=context.get_asset_versions_page(&page_request).await?;
 		let context=&context;
 		let output_folder=config.output_folder.clone();
 		let data=&page.data;
@@ -1344,10 +1603,10 @@ async fn download_history(mut config:DownloadHistoryConfig)->AResult<()>{
 		}else{
 			asset_list.append(&mut page.data);
 		}
-		cursor=page.nextPageCursor;
+		page_request.cursor=page.nextPageCursor;
 	}
 
-	asset_list.sort_by(|a,b|a.assetVersionNumber.cmp(&b.assetVersionNumber));
+	asset_list.sort_by_key(|a|a.assetVersionNumber);
 
 	let mut path=config.output_folder.clone();
 	path.set_file_name("versions.json");
@@ -1361,7 +1620,7 @@ async fn download_history(mut config:DownloadHistoryConfig)->AResult<()>{
 }
 
 #[derive(Debug)]
-#[allow(dead_code)]
+#[expect(dead_code)]
 enum LoadDomError{
 	IO(std::io::Error),
 	RbxBinary(rbx_binary::DecodeError),
@@ -1463,7 +1722,7 @@ struct WriteCommitConfig{
 	write_scripts:bool,
 }
 
-async fn write_commit(config:WriteCommitConfig,b:Result<AResult<(AssetVersion,rox_compiler::DecompiledContext)>,tokio::task::JoinError>,repo:&gix::Repository)->AResult<()>{
+async fn write_commit(config:WriteCommitConfig,b:Result<AResult<(AssetVersion,rox_compiler::DecompiledContext)>,tokio::task::JoinError>,repo:&git2::Repository)->AResult<()>{
 	let (asset_version,context)=b??;
 	println!("writing files for version {}",asset_version.assetVersionNumber);
 
@@ -1494,17 +1753,12 @@ async fn write_commit(config:WriteCommitConfig,b:Result<AResult<(AssetVersion,ro
 		write_scripts:config.write_scripts,
 	}).await?;
 
-	let time=gix::date::Time::new(asset_version.created.timestamp(),0);
-	let sig=gix::actor::Signature{
-		name:config.git_committer_name.into(),
-		email:config.git_committer_email.into(),
-		time,
-	};
+	let date=asset_version.created;
+	//let sig=repo.signature()?; //this pulls default name and email
+	let sig=git2::Signature::new(config.git_committer_name.as_str(),config.git_committer_email.as_str(),&git2::Time::new(date.timestamp(),0)).unwrap();
 	let tree_id={
 		let mut tree_index = repo.index()?;
-		tree.index()?.
-		tree.peel_to_entry(path);
-		match tree_index.add_all(std::iter::once("*"),gix::IndexAddOption::DEFAULT,None){
+		match tree_index.add_all(std::iter::once("*"),git2::IndexAddOption::DEFAULT,None){
 			Ok(_)=>(),
 			Err(e)=>println!("tree_index.add_all error: {}",e),
 		}
@@ -1515,38 +1769,34 @@ async fn write_commit(config:WriteCommitConfig,b:Result<AResult<(AssetVersion,ro
 		tree_index.write()?;
 		tree_index.write_tree()?
 	};
-	let tree=repo.tree(tree_id)?;
+	let tree=repo.find_tree(tree_id)?;
 
 	let mut parents=Vec::new();
 
-	match repo.head_commit(){
-		Ok(commit)=>{
+	match repo.head(){
+		Ok(reference)=>{
+			let commit=reference.peel_to_commit()?;
+
 			//test tree against commit tree to see if there is any changes
 			let commit_tree=commit.tree()?;
 			let diff=repo.diff_tree_to_tree(Some(&commit_tree),Some(&tree),None)?;
-			if diff.is_empty(){
+			if diff.get_delta(0).is_none(){
 				println!("no changes");
 				return Ok(());
 			}
 
-			parents.push(commit.id());
+			parents.push(commit);
 		},
-		//If the repo head is not found, great, continue and make the first commit
-		Err(gix::reference::head_commit::Error::Head(gix::reference::find::existing::Error::NotFound{..}))=>(),
-		//for other errors
-		Err(e)=>Err(e)?,
+		Err(e)=>println!("repo head error {:?}",e),
 	};
 
-	let mut timebuf=gix::date::parse::TimeBuf::default();
-	let sig_ref=sig.to_ref(&mut timebuf);
-
-	repo.commit_as(
-		sig_ref,//commiter
-		sig_ref,//author
-		"HEAD",
-		&format!("v{}",asset_version.assetVersionNumber),//message
+	repo.commit(
+		Some("HEAD"),//update_ref
+		&sig,//author
+		&sig,//commiter
+		&format!("v{}", asset_version.assetVersionNumber),//message
 		&tree,//tree (basically files)
-		parents,//parents
+		parents.iter().collect::<Vec<&git2::Commit<'_>>>().as_slice(),//parents
 	)?;
 
 	//commit
@@ -1570,14 +1820,7 @@ async fn decompile_history_into_git(config:DecompileHistoryConfig)->AResult<()>{
 	versions_path.push("versions.json");
 	let asset_list:Vec<AssetVersion>=serde_json::from_reader(std::fs::File::open(versions_path)?)?;
 
-	let repo=gix::discover(gix::create::into(
-		config.output_folder.as_path(),
-		gix::create::Kind::Bare,
-		gix::create::Options{
-			destination_must_be_empty:true,
-			fs_capabilities:None
-		}
-	)?)?;
+	let repo=git2::Repository::init(config.output_folder.as_path())?;
 
 	//decompile all versions
 	futures::stream::iter(asset_list.into_iter()
@@ -1627,14 +1870,7 @@ async fn download_and_decompile_history_into_git(config:DownloadAndDecompileHist
 	//poll paged list of all asset versions
 	let asset_list=get_version_history(&context,config.asset_id).await?;
 
-	let repo=gix::discover(gix::create::into(
-		config.output_folder.as_path(),
-		gix::create::Kind::Bare,
-		gix::create::Options{
-			destination_must_be_empty:true,
-			fs_capabilities:None
-		}
-	)?)?;
+	let repo=git2::Repository::init(config.output_folder.clone())?;
 
 	//download all versions
 	let asset_id=config.asset_id;
@@ -1767,3 +2003,43 @@ async fn compile_upload_place(config:CompileUploadPlaceConfig)->AResult<()>{
 	println!("UploadResponse={:?}",resp);
 	Ok(())
 }
+
+async fn get_luau_result_exp_backoff(
+	context:&CloudContext,
+	luau_session:&rbx_asset::cloud::LuauSessionResponse
+)->Result<Result<rbx_asset::cloud::LuauResults,rbx_asset::cloud::LuauError>,rbx_asset::cloud::LuauSessionError>{
+	const BACKOFF_MUL:f32=1.395_612_5;//exp(1/3)
+	let mut backoff=1000f32;
+	loop{
+		match luau_session.try_get_result(context).await{
+			//try again when the operation is not done
+			Err(rbx_asset::cloud::LuauSessionError::NotDone)=>(),
+			//return all other results
+			other_result=>return other_result,
+		}
+		println!("Operation not complete; waiting {:.0}ms...",backoff);
+		tokio::time::sleep(std::time::Duration::from_millis(backoff as u64)).await;
+		backoff*=BACKOFF_MUL;
+	}
+}
+struct RunLuauConfig{
+	api_key:ApiKey,
+	script:String,
+	request:rbx_asset::cloud::LuauSessionLatestRequest,
+}
+async fn run_luau(config:RunLuauConfig)->AResult<()>{
+	let context=CloudContext::new(config.api_key);
+	let session=rbx_asset::cloud::LuauSessionCreate{
+		script:&config.script,
+		user:None,
+		timeout:None,
+		binaryInput:None,
+		enableBinaryOutput:None,
+		binaryOutputUri:None,
+	};
+	let response=context.create_luau_session(&config.request,session).await?;
+	dbg!(&response);
+	let result=get_luau_result_exp_backoff(&context,&response).await?;
+	dbg!(&result);
+	Ok(())
+}