feat: add non-interactive mode and route management options to CLI

Author: NathanFlurry

packages/toolchain/cli/src/commands/actor/create.rs

@@ -200,6 +200,9 @@ impl Opts {
 				filter_tags: None,
 				build_tags: Some(build_tags),
 				version: self.version.clone(),
+				skip_route_creation: None,
+				keep_existing_routes: None,
+				non_interactive: false,
 			})
 			.await?;
 

packages/toolchain/cli/src/commands/deploy.rs

@@ -17,8 +17,19 @@ pub struct Opts {
 	#[clap(long)]
 	extra_tags: Option<String>,
 
-	#[clap(long, help = "Override the automatically generated version name")]
+	/// Override the automatically generated version name
+	#[clap(long)]
 	version: Option<String>,
+
+	#[clap(long)]
+	skip_route_creation: Option<bool>,
+
+	#[clap(long)]
+	keep_existing_routes: Option<bool>,
+
+	/// Run in non-interactive mode (no prompts)
+	#[clap(long)]
+	non_interactive: bool,
 }
 
 impl Opts {
@@ -47,6 +58,9 @@ impl Opts {
 			filter_tags: filter_tags,
 			build_tags: build_tags,
 			version: self.version.clone(),
+			skip_route_creation: self.skip_route_creation,
+			keep_existing_routes: self.keep_existing_routes,
+			non_interactive: self.non_interactive,
 		})
 		.await?;
 

packages/toolchain/cli/src/commands/function/endpoint.rs

@@ -0,0 +1,64 @@
+use anyhow::*;
+use clap::Parser;
+use toolchain::{
+	rivet_api::{apis, models},
+	ToolchainCtx,
+};
+
+/// Get information about a route endpoint
+#[derive(Parser, Clone)]
+pub struct Opts {
+	/// Name of the route to retrieve information about
+	function_name: String,
+
+	/// Specify the environment to get the route from (will prompt if not specified)
+	#[clap(long, alias = "env", short = 'e')]
+	environment: Option<String>,
+}
+
+impl Opts {
+	pub async fn execute(&self) -> Result<()> {
+		let ctx = crate::util::login::load_or_login().await?;
+		let env = crate::util::env::get_or_select(&ctx, self.environment.as_ref()).await?;
+
+		// Get route information
+		let route = get_route(&ctx, &env, &self.function_name).await?;
+
+		match route {
+			Some(route) => {
+				println!("https://{}{}", route.hostname, route.path);
+
+				Ok(())
+			}
+			None => Err(anyhow!(
+				"Route '{}' not found in environment '{}'",
+				self.function_name,
+				env
+			)),
+		}
+	}
+}
+
+// Helper function to get route if it exists
+async fn get_route(
+	ctx: &ToolchainCtx,
+	env: &str,
+	route_id: &str,
+) -> Result<Option<models::RoutesRoute>> {
+	let routes_response = apis::routes_api::routes_list(
+		&ctx.openapi_config_cloud,
+		Some(&ctx.project.name_id.to_string()),
+		Some(env),
+	)
+	.await?;
+
+	// Find route that matches the ID
+	let matching_route = routes_response
+		.routes
+		.iter()
+		.find(|route| route.id == *route_id)
+		.cloned();
+
+	Ok(matching_route)
+}
+

packages/toolchain/cli/src/commands/function/list.rs

@@ -0,0 +1,38 @@
+use anyhow::*;
+use clap::Parser;
+use toolchain::rivet_api::apis;
+
+/// List all functions for an environment
+#[derive(Parser)]
+pub struct Opts {
+	/// Specify the environment to list function for (will prompt if not specified)
+	#[clap(long, alias = "env", short = 'e')]
+	environment: Option<String>,
+}
+
+impl Opts {
+	pub async fn execute(&self) -> Result<()> {
+		let ctx = crate::util::login::load_or_login().await?;
+		let env = crate::util::env::get_or_select(&ctx, self.environment.as_ref()).await?;
+
+		// Get routes
+		let routes_response = apis::routes_api::routes_list(
+			&ctx.openapi_config_cloud,
+			Some(&ctx.project.name_id.to_string()),
+			Some(&env),
+		)
+		.await?;
+
+		if routes_response.routes.is_empty() {
+			println!("No routes found for environment '{}'", env);
+			return Ok(());
+		}
+
+		for route in routes_response.routes {
+			println!("- {}: {}{}", route.id, route.hostname, route.path);
+		}
+
+		Ok(())
+	}
+}
+

packages/toolchain/cli/src/commands/function/mod.rs

@@ -0,0 +1,23 @@
+use anyhow::*;
+use clap::Parser;
+
+pub mod endpoint;
+pub mod list;
+
+/// Commands for managing routes
+#[derive(Parser)]
+pub enum SubCommand {
+	/// List all routes
+	List(list::Opts),
+	/// Get information about a specific route endpoint
+	Endpoint(endpoint::Opts),
+}
+
+impl SubCommand {
+	pub async fn execute(&self) -> Result<()> {
+		match self {
+			SubCommand::List(opts) => opts.execute().await,
+			SubCommand::Endpoint(opts) => opts.execute().await,
+		}
+	}
+}

packages/toolchain/cli/src/commands/mod.rs

@@ -4,6 +4,7 @@ pub mod config;
 pub mod deno;
 pub mod deploy;
 pub mod environment;
+pub mod function;
 pub mod login;
 pub mod logout;
 pub mod metadata;
@@ -58,6 +59,14 @@ pub enum SubCommand {
 		#[clap(subcommand)]
 		subcommand: region::SubCommand,
 	},
+	/// Commands for managing routes
+	#[clap(alias = "f", alias = "func", alias = "route")]
+	Function {
+		#[clap(subcommand)]
+		subcommand: function::SubCommand,
+	},
+	/// Get information about a specific route endpoint
+	Endpoint(function::endpoint::Opts),
 	/// Commands for managing Rivet configuration
 	Config {
 		#[clap(subcommand)]
@@ -95,6 +104,8 @@ impl SubCommand {
 			SubCommand::Actor { subcommand } => subcommand.execute().await,
 			SubCommand::Build { subcommand } => subcommand.execute().await,
 			SubCommand::Region { subcommand } => subcommand.execute().await,
+			SubCommand::Function { subcommand } => subcommand.execute().await,
+			SubCommand::Endpoint(opts) => opts.execute().await,
 			SubCommand::Config { subcommand } => subcommand.execute().await,
 			SubCommand::Metadata { subcommand } => subcommand.execute().await,
 			SubCommand::Deno(opts) => opts.execute().await,

packages/toolchain/cli/src/util/deploy.rs

@@ -19,6 +19,9 @@ pub struct DeployOpts<'a> {
 	pub filter_tags: Option<HashMap<String, String>>,
 	pub build_tags: Option<HashMap<String, String>>,
 	pub version: Option<String>,
+	pub skip_route_creation: Option<bool>,
+	pub keep_existing_routes: Option<bool>,
+	pub non_interactive: bool,
 }
 
 pub async fn deploy(opts: DeployOpts<'_>) -> Result<Vec<Uuid>> {
@@ -65,7 +68,16 @@ pub async fn deploy(opts: DeployOpts<'_>) -> Result<Vec<Uuid>> {
 	.await?;
 
 	// Setup function routes
-	setup_function_routes(opts.ctx, environment, &config, &opts.filter_tags).await?;
+	setup_function_routes(
+		opts.ctx,
+		environment,
+		&config,
+		&opts.filter_tags,
+		opts.skip_route_creation,
+		opts.keep_existing_routes,
+		opts.non_interactive,
+	)
+	.await?;
 
 	// Print summary
 	print_summary(opts.ctx, environment);
@@ -78,20 +90,23 @@ async fn setup_function_routes(
 	environment: &toolchain::project::environment::TEMPEnvironment,
 	config: &config::Config,
 	filter_tags: &Option<HashMap<String, String>>,
+	skip_route_creation: Option<bool>,
+	keep_existing_routes: Option<bool>,
+	non_interactive: bool,
 ) -> Result<()> {
-	// Determine default hostname based on project & env
-	let default_hostname = format!(
-		"{}-{}.{}",
-		ctx.project.name_id,
-		environment.slug,
-		ctx.bootstrap
-			.domains
-			.job
-			.as_ref()
-			.context("bootstrap.domains.job")?
-	);
-
 	for (fn_name, function) in &config.functions {
+		// Determine default hostname based on project & env
+		let default_hostname = format!(
+			"{}-{}-{fn_name}.{}",
+			ctx.project.name_id,
+			environment.slug,
+			ctx.bootstrap
+				.domains
+				.job
+				.as_ref()
+				.context("bootstrap.domains.job")?
+		);
+
 		// TODO: Convert this in to a shared fn
 		// Filter out builds that match the tags
 		if let Some(filter) = &filter_tags {
@@ -190,19 +205,40 @@ async fn setup_function_routes(
 			];
 
 			println!();
-			let choice = block_in_place(|| {
-				Select::new(
-					&format!(
-						"Route configuration for '{fn_name}' has changed{}",
-						changes_text
-					),
-					options.to_vec(),
-				)
-				.with_starting_cursor(0)
-				.prompt()
-			})?;
 
-			match choice.index {
+			let choice_index = if non_interactive {
+				// In non-interactive mode, use auto_sync_routes if provided, otherwise sync by default
+				match keep_existing_routes {
+					Some(true) => {
+						println!("Skipping route sync for '{fn_name}' (non-interactive mode)");
+						1 // Keep existing route
+					}
+					Some(false) => {
+						println!("Auto-syncing route configuration for '{fn_name}' (non-interactive mode)");
+						0 // Sync route with config
+					}
+					None => {
+						println!("Auto-syncing route configuration for '{fn_name}' (non-interactive mode)");
+						0 // Default to sync in non-interactive mode
+					}
+				}
+			} else {
+				// Interactive mode - prompt the user
+				let choice = block_in_place(|| {
+					Select::new(
+						&format!(
+							"Route configuration for '{fn_name}' has changed{}",
+							changes_text
+						),
+						options.to_vec(),
+					)
+					.with_starting_cursor(0)
+					.prompt()
+				})?;
+				choice.index
+			};
+
+			match choice_index {
 				0 => {
 					// Update first matching route to match config
 					let mut update_route_body = models::RoutesUpdateRouteBody {
@@ -268,17 +304,42 @@ async fn setup_function_routes(
 			];
 
 			println!();
-			let choice = block_in_place(|| {
-				Select::new(
-					&format!("Set up routing for function '{}':", fn_name),
-					options.to_vec(),
-				)
-				.with_help_message("Routes can be manually created in the Rivet dashboard")
-				.with_starting_cursor(0)
-				.prompt()
-			})?;
-
-			match choice.index {
+
+			let choice_index = if non_interactive {
+				// In non-interactive mode, use auto_create_routes if provided, otherwise create by default
+				match skip_route_creation {
+					Some(true) => {
+						println!("Skipping route creation for '{fn_name}' (non-interactive mode)");
+						1 // Skip route creation
+					}
+					Some(false) => {
+						println!(
+							"Auto-creating route for function '{fn_name}' (non-interactive mode)"
+						);
+						0 // Create default route
+					}
+					None => {
+						println!(
+							"Auto-creating route for function '{fn_name}' (non-interactive mode)"
+						);
+						0 // Default to create in non-interactive mode
+					}
+				}
+			} else {
+				// Interactive mode - prompt the user
+				let choice = block_in_place(|| {
+					Select::new(
+						&format!("Set up routing for function '{}':", fn_name),
+						options.to_vec(),
+					)
+					.with_help_message("Routes can be manually created in the Rivet dashboard")
+					.with_starting_cursor(0)
+					.prompt()
+				})?;
+				choice.index
+			};
+
+			match choice_index {
 				0 => {
 					// Create route with default settings
 					create_function_route(

packages/toolchain/toolchain/src/toolchain_ctx.rs

@@ -50,7 +50,13 @@ pub fn cloud_config_from_env() -> Option<(String, String)> {
 
 /// If the credentials already exist or loading credentials from env.
 pub async fn has_cloud_config() -> Result<bool> {
-	if cloud_config_from_env().is_some() {
+	if let Some((api_endpoint, token)) = cloud_config_from_env() {
+		meta::mutate_project(&paths::data_dir()?, |meta| {
+			if meta.cloud.is_none() {
+				meta.cloud = Some(meta::Cloud::new(api_endpoint, token))
+			}
+		})
+		.await?;
 		Ok(true)
 	} else {
 		meta::read_project(&paths::data_dir()?, |x| x.cloud.is_some()).await