Method execute

src/commands/cancel.rs:17–99

(&self, ctx: &AppContext)

#[async_trait]
impl Command for CancelCommand {
    async fn execute(&self, ctx: &AppContext) -> Result<(), Box<dyn Error>> {
        if self.task_ids.is_empty() {
            return Err("No task IDs provided".into());
        }

        let storage = ctx.task_storage();
        let docker_client: Arc<dyn DockerClient> = match &self.docker_client_override {
            Some(client) => Arc::clone(client),
            None => Arc::new(
                DefaultDockerClient::new(&ctx.tsk_config().container_engine)
                    .map_err(|e| -> Box<dyn Error> { e.into() })?,
            ),
        };

        let mut successful_cancels = 0;
        let mut failed_cancels = 0;

        for task_id in &self.task_ids {
            let task = match storage.get_task(task_id).await {
                Ok(Some(task)) => task,
                Ok(None) => {
                    eprintln!("Task {task_id} not found");
                    failed_cancels += 1;
                    continue;
                }
                Err(e) => {
                    eprintln!("Failed to look up {task_id}: {e}");
                    failed_cancels += 1;
                    continue;
                }
            };

            match task.status {
                TaskStatus::Queued | TaskStatus::Running => {
                    let was_running = task.status == TaskStatus::Running;
                    let is_interactive = task.is_interactive;

                    match storage.mark_cancelled(task_id).await {
                        Ok(_) => {
                            println!("Cancelled {task_id}");
                            successful_cancels += 1;

                            if was_running {
                                let container_name = if is_interactive {
                                    format!("tsk-interactive-{task_id}")
                                } else {
                                    format!("tsk-{task_id}")
                                };
                                if let Err(e) = docker_client.kill_container(&container_name).await
                                {
                                    eprintln!(
                                        "Note: Could not kill container {container_name}: {e}"
                                    );
                                }
                            }
                        }
                        Err(e) => {
                            eprintln!("Failed to cancel {task_id}: {e}");