Merge pull request #219 from tower/develop

v0.3.52 release

Author: bradhe

Cargo.lock

@@ -4,7 +4,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-version = "0.3.51"
+version = "0.3.52"
 description = "Tower is the best way to host Python data apps in production"
 rust-version = "1.81"
 authors = ["Brad Heller <brad@tower.dev>"]

Cargo.toml

@@ -980,3 +980,35 @@ impl ResponseEntity for tower_api::apis::default_api::DeleteScheduleSuccess {
         }
     }
 }
+
+pub async fn cancel_run(
+    config: &Config,
+    name: &str,
+    seq: i64,
+) -> Result<
+    tower_api::models::CancelRunResponse,
+    Error<tower_api::apis::default_api::CancelRunError>,
+> {
+    let api_config = &config.into();
+
+    let params = tower_api::apis::default_api::CancelRunParams {
+        name: name.to_string(),
+        seq,
+    };
+
+    unwrap_api_response(tower_api::apis::default_api::cancel_run(
+        api_config, params,
+    ))
+    .await
+}
+
+impl ResponseEntity for tower_api::apis::default_api::CancelRunSuccess {
+    type Data = tower_api::models::CancelRunResponse;
+
+    fn extract_data(self) -> Option<Self::Data> {
+        match self {
+            Self::Status200(data) => Some(data),
+            Self::UnknownValue(_) => None,
+        }
+    }
+}

crates/tower-cmd/src/api.rs

@@ -76,6 +76,24 @@ pub fn apps_cmd() -> Command {
                 )
                 .about("Delete an app in Tower"),
         )
+        .subcommand(
+            Command::new("cancel")
+                .arg(
+                    Arg::new("app_name")
+                        .value_parser(value_parser!(String))
+                        .index(1)
+                        .required(true)
+                        .help("Name of the app"),
+                )
+                .arg(
+                    Arg::new("run_number")
+                        .value_parser(value_parser!(i64))
+                        .index(2)
+                        .required(true)
+                        .help("Run number to cancel"),
+                )
+                .about("Cancel a running app run"),
+        )
 }
 
 pub async fn do_logs(config: Config, cmd: &ArgMatches) {
@@ -223,6 +241,26 @@ pub async fn do_delete(config: Config, cmd: &ArgMatches) {
     output::with_spinner("Deleting app", api::delete_app(&config, name)).await;
 }
 
+pub async fn do_cancel(config: Config, cmd: &ArgMatches) {
+    let name = cmd
+        .get_one::<String>("app_name")
+        .expect("app_name should be required");
+    let seq = cmd
+        .get_one::<i64>("run_number")
+        .copied()
+        .expect("run_number should be required");
+
+    let response =
+        output::with_spinner("Cancelling run", api::cancel_run(&config, name, seq)).await;
+
+    let run = &response.run;
+    let status = format!("{:?}", run.status);
+    output::success_with_data(
+        &format!("Run #{} for '{}' cancelled (status: {})", seq, name, status),
+        Some(response),
+    );
+}
+
 async fn latest_run_number(config: &Config, name: &str) -> i64 {
     match api::describe_app(config, name).await {
         Ok(resp) => resp.runs
@@ -715,4 +753,30 @@ mod tests {
         assert!(should_emit_line(&mut last_line_num, 4));
         assert_eq!(last_line_num, Some(4));
     }
+
+    #[test]
+    fn test_cancel_args_parsing() {
+        let matches = apps_cmd()
+            .try_get_matches_from(["apps", "cancel", "my-app", "42"])
+            .unwrap();
+        let (cmd, sub_matches) = matches.subcommand().unwrap();
+
+        assert_eq!(cmd, "cancel");
+        assert_eq!(
+            sub_matches
+                .get_one::<String>("app_name")
+                .map(|s| s.as_str()),
+            Some("my-app")
+        );
+        assert_eq!(sub_matches.get_one::<i64>("run_number"), Some(&42));
+    }
+
+    #[test]
+    fn test_cancel_requires_both_args() {
+        let result = apps_cmd().try_get_matches_from(["apps", "cancel", "my-app"]);
+        assert!(result.is_err());
+
+        let result = apps_cmd().try_get_matches_from(["apps", "cancel"]);
+        assert!(result.is_err());
+    }
 }

crates/tower-cmd/src/apps.rs

@@ -124,6 +124,7 @@ impl App {
                     Some(("show", args)) => apps::do_show(sessionized_config, args).await,
                     Some(("logs", args)) => apps::do_logs(sessionized_config, args).await,
                     Some(("delete", args)) => apps::do_delete(sessionized_config, args).await,
+                    Some(("cancel", args)) => apps::do_cancel(sessionized_config, args).await,
                     _ => {
                         apps::apps_cmd().print_help().unwrap();
                         std::process::exit(2);

crates/tower-cmd/src/lib.rs

@@ -98,6 +98,12 @@ struct GenerateTowerfileRequest {
     script_path: Option<String>,
 }
 
+#[derive(Debug, Deserialize, JsonSchema)]
+struct CancelRunRequest {
+    name: String,
+    run_number: String,
+}
+
 #[derive(Debug, Deserialize, JsonSchema)]
 struct ScheduleRequest {
     app_name: String,
@@ -481,6 +487,28 @@ impl TowerService {
         }
     }
 
+    #[tool(description = "Cancel a running Tower app run")]
+    async fn tower_apps_cancel(
+        &self,
+        Parameters(request): Parameters<CancelRunRequest>,
+    ) -> Result<CallToolResult, McpError> {
+        let seq: i64 = request
+            .run_number
+            .parse()
+            .map_err(|_| McpError::invalid_params("run_number must be a number", None))?;
+
+        match api::cancel_run(&self.config, &request.name, seq).await {
+            Ok(response) => {
+                let status = format!("{:?}", response.run.status);
+                Self::text_success(format!(
+                    "Cancelled run #{} for '{}' (status: {})",
+                    seq, request.name, status
+                ))
+            }
+            Err(e) => Self::error_result("Failed to cancel run", e),
+        }
+    }
+
     #[tool(description = "List secrets in your Tower account (shows only previews for security)")]
     async fn tower_secrets_list(
         &self,

crates/tower-cmd/src/mcp.rs

@@ -298,7 +298,6 @@ fn output_response_content_error<T>(err: ResponseContent<T>) {
 
     match err.status {
         StatusCode::CONFLICT => {
-            error("There was a conflict while trying to do that!");
             output_full_error_details(&error_model);
         }
         StatusCode::UNPROCESSABLE_ENTITY => {
@@ -316,7 +315,10 @@ fn output_response_content_error<T>(err: ResponseContent<T>) {
             );
         }
         _ => {
-            error("The Tower API returned an error that the Tower CLI doesn't know what to do with! Maybe try again in a bit.");
+            if error_model.detail.is_none() && error_model.errors.is_none() {
+                error("The Tower API returned an error that the Tower CLI doesn't know what to do with! Maybe try again in a bit.");
+            }
+            output_full_error_details(&error_model);
         }
     }
 }

crates/tower-cmd/src/output.rs

@@ -184,6 +184,7 @@ where
     let session = config.session.as_ref().ok_or(Error::NoSession)?;
 
     env_vars.insert("TOWER_JWT".to_string(), session.token.jwt.to_string());
+    env_vars.insert("TOWER__RUNTIME__IS_LOCAL".to_string(), "true".to_string());
 
     // Load the Towerfile
     let towerfile_path = path.join("Towerfile");

crates/tower-cmd/src/run.rs

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "tower"
-version = "0.3.51"
+version = "0.3.52"
 description = "Tower CLI and runtime environment for Tower."
 authors = [{ name = "Tower Computing Inc.", email = "brad@tower.dev" }]
 readme = "README.md"

pyproject.toml

@@ -83,7 +83,18 @@ def is_cloud_run() -> bool:
     Returns:
         bool: True if running in Tower cloud, otherwise False.
     """
-    val = _get_runtime_env_variable("IS_TOWER_MANAGED", "")
+    val = _get_runtime_env_variable("IS_TOWER_MANAGED", "false")
+    return _strtobool(val)
+
+
+def is_local() -> bool:
+    """
+    Check if the current run is executing locally via the Tower CLI.
+
+    Returns:
+        bool: True if running locally, otherwise False.
+    """
+    val = _get_runtime_env_variable("IS_LOCAL", "false")
     return _strtobool(val)