feat: add control actions for Docker containers and qBittorrent torrents

Kebab menus on container/torrent cards with context-aware actions,
glassmorphic confirmation modals for destructive operations, and
backend POST endpoints for start/stop/restart and resume/pause/delete.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: EstrellaXD

CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/).
+
+## [Unreleased]
+
+### Added
+- Docker container controls: start, stop, restart via kebab menu on each container card
+- qBittorrent torrent controls: resume, pause, delete via kebab menu on each torrent card
+- Glassmorphic confirmation modals for destructive actions (stop, restart, delete)
+- Delete torrent modal includes "also delete downloaded files" checkbox
+- Context-aware menus: only shows applicable actions based on container/torrent state
+- Backend POST endpoints for Docker actions (`/api/systems/{id}/actions/docker`)
+- Backend POST endpoints for qBittorrent actions (`/api/systems/{id}/actions/qbittorrent`)
+- `KebabMenu.vue` and `ConfirmModal.vue` reusable components
+- `useActions.ts` composable for action API calls with per-item loading states
+- `hash` field on `TorrentInfo` for torrent identification

backend/src/api/routes.rs

@@ -1,11 +1,18 @@
+use std::collections::HashMap;
 use std::path::Path;
 use std::sync::Arc;
 
 use axum::extract::{Path as AxumPath, State};
-use axum::response::Json;
+use axum::http::StatusCode;
+use axum::response::{IntoResponse, Json, Response};
+use bollard::Docker;
+use reqwest::Client;
+use serde::Deserialize;
 use tokio::sync::broadcast;
 
-use crate::config::{load_config, Settings};
+use crate::config::{
+    load_config, DockerSystemConfig, QBittorrentSystemConfig, Settings, SystemConfigType,
+};
 use crate::services::collector_manager::CollectorManager;
 use crate::services::metrics_store::MetricsStore;
 
@@ -14,6 +21,7 @@ pub struct AppState {
     pub manager: tokio::sync::Mutex<CollectorManager>,
     pub settings: Settings,
     pub broadcast_tx: broadcast::Sender<String>,
+    pub system_configs: HashMap<String, SystemConfigType>,
 }
 
 pub async fn root() -> Json<serde_json::Value> {
@@ -67,3 +75,233 @@ pub async fn reload_config(
         "systems": ids,
     }))
 }
+
+// --- Action request types ---
+
+#[derive(Deserialize)]
+pub struct DockerActionRequest {
+    pub container_name: String,
+    pub action: String,
+}
+
+#[derive(Deserialize)]
+pub struct QbitActionRequest {
+    pub hash: String,
+    pub action: String,
+    #[serde(default)]
+    pub delete_files: bool,
+}
+
+// --- Action error response helper ---
+
+fn action_error(status: StatusCode, msg: &str) -> Response {
+    (status, Json(serde_json::json!({"error": msg}))).into_response()
+}
+
+// --- Docker action handler ---
+
+fn connect_docker(config: &DockerSystemConfig) -> Result<Docker, String> {
+    if let Some(ref host) = config.host {
+        Docker::connect_with_http(host, 10, bollard::API_DEFAULT_VERSION)
+            .map_err(|e| format!("Docker connect failed: {e}"))
+    } else {
+        Docker::connect_with_socket(&config.socket, 10, bollard::API_DEFAULT_VERSION)
+            .map_err(|e| format!("Docker socket connect failed: {e}"))
+    }
+}
+
+pub async fn docker_action(
+    State(state): State<Arc<AppState>>,
+    AxumPath(system_id): AxumPath<String>,
+    Json(body): Json<DockerActionRequest>,
+) -> Response {
+    // Look up Docker config
+    let config = match state.system_configs.get(&system_id) {
+        Some(SystemConfigType::Docker(c)) => c.clone(),
+        _ => return action_error(StatusCode::NOT_FOUND, "Docker system not found"),
+    };
+
+    // Validate action
+    if !matches!(body.action.as_str(), "start" | "stop" | "restart") {
+        return action_error(
+            StatusCode::BAD_REQUEST,
+            &format!("Invalid action: {}", body.action),
+        );
+    }
+
+    // Connect
+    let client = match connect_docker(&config) {
+        Ok(c) => c,
+        Err(e) => return action_error(StatusCode::INTERNAL_SERVER_ERROR, &e),
+    };
+
+    // Execute action
+    let result = match body.action.as_str() {
+        "start" => client
+            .start_container::<String>(&body.container_name, None)
+            .await
+            .map(|_| ()),
+        "stop" => client
+            .stop_container(&body.container_name, None)
+            .await
+            .map(|_| ()),
+        "restart" => client
+            .restart_container(&body.container_name, None)
+            .await
+            .map(|_| ()),
+        _ => unreachable!(),
+    };
+
+    match result {
+        Ok(()) => {
+            tracing::info!(
+                "[{}] Docker action '{}' on container '{}'",
+                system_id,
+                body.action,
+                body.container_name
+            );
+            (
+                StatusCode::OK,
+                Json(serde_json::json!({
+                    "status": "success",
+                    "action": body.action,
+                    "container": body.container_name,
+                })),
+            )
+                .into_response()
+        }
+        Err(e) => {
+            tracing::error!(
+                "[{}] Docker action '{}' failed on '{}': {}",
+                system_id,
+                body.action,
+                body.container_name,
+                e
+            );
+            action_error(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string())
+        }
+    }
+}
+
+// --- qBittorrent action handler ---
+
+async fn qbit_authenticate(client: &Client, config: &QBittorrentSystemConfig) -> Result<(), String> {
+    let resp = client
+        .post(format!("{}/api/v2/auth/login", config.url))
+        .form(&[
+            ("username", config.username.as_str()),
+            ("password", config.password.as_str()),
+        ])
+        .send()
+        .await
+        .map_err(|e| format!("qBittorrent login request failed: {e}"))?;
+
+    let text = resp.text().await.map_err(|e| e.to_string())?;
+    if text != "Ok." {
+        return Err("qBittorrent authentication failed".to_string());
+    }
+    Ok(())
+}
+
+pub async fn qbit_action(
+    State(state): State<Arc<AppState>>,
+    AxumPath(system_id): AxumPath<String>,
+    Json(body): Json<QbitActionRequest>,
+) -> Response {
+    // Look up qBit config
+    let config = match state.system_configs.get(&system_id) {
+        Some(SystemConfigType::QBittorrent(c)) => c.clone(),
+        _ => return action_error(StatusCode::NOT_FOUND, "qBittorrent system not found"),
+    };
+
+    // Validate action
+    if !matches!(body.action.as_str(), "resume" | "pause" | "delete") {
+        return action_error(
+            StatusCode::BAD_REQUEST,
+            &format!("Invalid action: {}", body.action),
+        );
+    }
+
+    // Create client with cookie store for session
+    let client = match Client::builder()
+        .danger_accept_invalid_certs(true)
+        .cookie_store(true)
+        .timeout(std::time::Duration::from_secs(10))
+        .build()
+    {
+        Ok(c) => c,
+        Err(e) => return action_error(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
+    };
+
+    // Authenticate
+    if let Err(e) = qbit_authenticate(&client, &config).await {
+        return action_error(StatusCode::INTERNAL_SERVER_ERROR, &e);
+    }
+
+    // Build the qBittorrent API request
+    let (endpoint, form_data) = match body.action.as_str() {
+        "resume" => (
+            format!("{}/api/v2/torrents/resume", config.url),
+            vec![("hashes".to_string(), body.hash.clone())],
+        ),
+        "pause" => (
+            format!("{}/api/v2/torrents/pause", config.url),
+            vec![("hashes".to_string(), body.hash.clone())],
+        ),
+        "delete" => (
+            format!("{}/api/v2/torrents/delete", config.url),
+            vec![
+                ("hashes".to_string(), body.hash.clone()),
+                ("deleteFiles".to_string(), body.delete_files.to_string()),
+            ],
+        ),
+        _ => unreachable!(),
+    };
+
+    // Execute
+    let result = client.post(&endpoint).form(&form_data).send().await;
+
+    match result {
+        Ok(resp) if resp.status().is_success() => {
+            tracing::info!(
+                "[{}] qBit action '{}' on torrent '{}'",
+                system_id,
+                body.action,
+                body.hash
+            );
+            (
+                StatusCode::OK,
+                Json(serde_json::json!({
+                    "status": "success",
+                    "action": body.action,
+                    "hash": body.hash,
+                })),
+            )
+                .into_response()
+        }
+        Ok(resp) => {
+            let status = resp.status();
+            let text = resp.text().await.unwrap_or_default();
+            tracing::error!(
+                "[{}] qBit action '{}' failed: {} {}",
+                system_id,
+                body.action,
+                status,
+                text
+            );
+            action_error(
+                StatusCode::INTERNAL_SERVER_ERROR,
+                &format!("qBittorrent API returned {status}"),
+            )
+        }
+        Err(e) => {
+            tracing::error!(
+                "[{}] qBit action '{}' request failed: {}",
+                system_id,
+                body.action,
+                e
+            );
+            action_error(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string())
+        }
+    }
+}

backend/src/collectors/mock.rs

@@ -281,7 +281,7 @@ impl Collector for MockQBittorrentCollector {
         let mut total_download_speed: i64 = 0;
         let mut total_upload_speed: i64 = 0;
 
-        for t in &mut self.torrents {
+        for (idx, t) in self.torrents.iter_mut().enumerate() {
             if t.progress < 100.0 && t.state == "downloading" {
                 t.progress = (t.progress + rng.gen_range(0.1..0.5)).min(100.0);
                 if t.progress >= 100.0 {
@@ -319,6 +319,7 @@ impl Collector for MockQBittorrentCollector {
             };
 
             torrent_infos.push(TorrentInfo {
+                hash: format!("{:032x}", t.name.len() as u128 * 0xdeadbeef + idx as u128),
                 name: t.name.to_string(),
                 size: t.size,
                 progress: t.progress,

backend/src/collectors/qbittorrent.rs

@@ -99,6 +99,7 @@ impl QBittorrentCollector {
             };
 
             torrents.push(TorrentInfo {
+                hash: torrent["hash"].as_str().unwrap_or("").to_string(),
                 name: torrent["name"].as_str().unwrap_or("Unknown").to_string(),
                 size: torrent["size"].as_i64().unwrap_or(0),
                 progress: torrent["progress"].as_f64().unwrap_or(0.0) * 100.0,

backend/src/main.rs

@@ -6,6 +6,8 @@ use axum::Router;
 use tokio::sync::broadcast;
 use tower_http::cors::{Any, CorsLayer};
 
+use std::collections::HashMap;
+
 use server_monitor::api::{routes, websocket};
 use server_monitor::config::{load_config, Settings};
 use server_monitor::services::collector_manager::CollectorManager;
@@ -44,11 +46,20 @@ async fn main() {
 
     let collector_count = manager.collector_count();
 
+    // Build system config map for action handlers
+    let system_configs: HashMap<String, _> = config
+        .systems
+        .iter()
+        .filter(|s| s.enabled)
+        .map(|s| (s.id.clone(), s.config.clone()))
+        .collect();
+
     let state = Arc::new(routes::AppState {
         store,
         manager: tokio::sync::Mutex::new(manager),
         settings: settings.clone(),
         broadcast_tx: tx,
+        system_configs,
     });
 
     // Start collection loop
@@ -70,6 +81,14 @@ async fn main() {
         .route("/api/systems/{system_id}", get(routes::get_system))
         .route("/api/health", get(routes::health_check))
         .route("/api/reload", post(routes::reload_config))
+        .route(
+            "/api/systems/{system_id}/actions/docker",
+            post(routes::docker_action),
+        )
+        .route(
+            "/api/systems/{system_id}/actions/qbittorrent",
+            post(routes::qbit_action),
+        )
         .route("/ws", get(websocket::ws_handler))
         .layer(cors)
         .with_state(state.clone());

backend/src/models/metrics.rs

@@ -98,6 +98,7 @@ pub struct DockerMetrics {
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct TorrentInfo {
+    pub hash: String,
     pub name: String,
     pub size: i64,
     pub progress: f64,