feat: Complete queue pause/resume system for operational control v1.11.0

Implement comprehensive queue pause and resume functionality across all Hammerwork interfaces:

**🔧 Core Library (hammerwork)**
- Add pause_queue(), resume_queue(), is_queue_paused(), get_queue_pause_info(), get_paused_queues() to DatabaseQueue trait
- Full PostgreSQL and MySQL backend implementation with optimized queries
- Database migration 014 adding hammerwork_queue_pause table with audit fields
- Worker integration: automatically skip job dequeuing for paused queues
- Graceful operation: jobs in progress continue, new jobs blocked
- QueuePauseInfo struct for comprehensive pause state tracking

**🌐 Web Interface (hammerwork-web)**
- Interactive pause/resume buttons with dynamic UI updates
- Visual status badges: 🟢 Active / 🟡 Paused with color-coded styling
- Enhanced queue API responses including pause state information
- Real-time user feedback with success/error notifications
- Updated queue table layout with Status column for operational visibility

**🖥️ CLI Tools (cargo-hammerwork)**
- queue pause/resume commands with comprehensive feedback
- queue paused command to list all paused queues with details
- Enhanced queue list command showing pause status with emoji indicators
- Full audit trail support recording CLI operations for compliance

**🏗️ Database Schema**
- New hammerwork_queue_pause table with queue_name, timestamps, audit fields
- Automatic timestamp management for PostgreSQL (triggers) and MySQL
- Proper indexing on paused_at for efficient query performance
- Cross-database compatibility with database-specific SQL optimizations

**✨ Key Features**
- Persistent pause state across worker restarts and database reconnections
- Audit trail tracking who paused/resumed queues and when
- Immediate operational control for maintenance windows and emergencies
- Consistent interface across library, web UI, and CLI
- Zero downtime: pausing doesn't interrupt running jobs

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: CodingAnarchy

CHANGELOG.md

@@ -5,6 +5,44 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.11.0] - 2025-07-14
+
+### Added
+- **⏸️ Queue Pause/Resume Functionality**
+  - Complete queue pause and resume system for operational control and maintenance windows
+  - New `pause_queue()`, `resume_queue()`, `is_queue_paused()`, `get_queue_pause_info()`, and `get_paused_queues()` methods in DatabaseQueue trait
+  - Database migration 014 adding `hammerwork_queue_pause` table for persistent pause state storage
+  - Full PostgreSQL and MySQL backend implementation with optimized queries and proper indexing
+  - Worker integration automatically respecting paused queues - workers skip job dequeuing when queues are paused
+  - Graceful operation: jobs already in progress continue to completion while new jobs are blocked
+  - Audit trail support tracking who paused/resumed queues and when for operational transparency
+
+- **🌐 Web UI Queue Management**
+  - Enhanced web dashboard with visual queue status indicators showing active/paused state
+  - Interactive pause/resume buttons with dynamic UI updates based on current queue state
+  - Real-time status badges with color-coded indicators: 🟢 Active, 🟡 Paused
+  - Immediate user feedback with success/error notifications for all queue operations
+  - Updated queue API endpoints supporting pause/resume actions via `/api/queues/{name}/actions`
+  - Extended queue information API responses including `is_paused`, `paused_at`, and `paused_by` fields
+
+- **🏗️ Database Schema and Migration**
+  - New `hammerwork_queue_pause` table with queue_name (primary key), timestamps, and audit fields
+  - Automatic timestamp management for PostgreSQL (triggers) and MySQL (ON UPDATE CURRENT_TIMESTAMP)
+  - Proper indexing on `paused_at` for efficient query performance
+  - Cross-database compatibility with database-specific SQL optimizations
+
+### Enhanced
+- **📊 API Responses**
+  - Queue information now includes pause status, pause timestamp, and who initiated the pause
+  - Enhanced queue statistics with operational state visibility
+  - Improved error handling and user feedback for all queue management operations
+
+- **🎨 Web Interface**
+  - Updated queue table layout with new Status column for better visibility
+  - Added success/warning button styles for pause/resume actions
+  - Enhanced CSS styling with consistent color scheme and visual feedback
+  - Improved user experience with contextual action buttons
+
 ## [1.10.0] - 2025-07-14
 
 ### Added

Cargo.toml

@@ -9,7 +9,7 @@ members = [
 resolver = "2"
 
 [workspace.package]
-version = "1.10.0"
+version = "1.11.0"
 edition = "2024"
 license = "MIT"
 repository = "https://github.com/CodingAnarchy/hammerwork"
@@ -19,7 +19,7 @@ documentation = "https://docs.rs/hammerwork"
 rust-version = "1.86"
 
 [workspace.dependencies]
-hammerwork = { version = "1.10.0", path = "." }
+hammerwork = { version = "1.11.0", path = "." }
 tokio = { version = "1.0", features = ["full"] }
 sqlx = { version = "0.8", features = ["runtime-tokio-rustls", "chrono", "uuid", "json"] }
 chrono = { version = "0.4", features = ["serde"] }

cargo-hammerwork/CHANGELOG.md

@@ -5,6 +5,35 @@ All notable changes to the cargo-hammerwork CLI tool will be documented in this
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.11.0] - 2025-07-14
+
+### Added
+- **⏸️ Queue Pause/Resume Commands**
+  - `queue pause` - Pause job processing for specific queues with audit tracking
+  - `queue resume` - Resume job processing for previously paused queues
+  - `queue paused` - List all currently paused queues with detailed information
+  - Enhanced `queue list` command to show pause status for all queues
+  - Complete PostgreSQL and MySQL support with proper error handling and user feedback
+  - CLI operations automatically record who performed the action for audit trails
+
+- **📊 Enhanced Queue Management**
+  - Visual status indicators in queue listings: ⏸️ Paused / ▶️ Active
+  - Detailed pause information including timestamp, user, and reason
+  - Improved queue overview with operational state visibility
+  - Better error messages and confirmation feedback for queue operations
+
+### Enhanced
+- **🗄️ Database Migration System**
+  - Updated migration registry to include queue pause functionality (migration 014)
+  - Enhanced migration tracking and execution for comprehensive schema management
+  - Cross-database compatibility improvements for PostgreSQL and MySQL migrations
+
+- **🚀 CLI User Experience**
+  - Enhanced queue listing with status column for better operational visibility
+  - Improved command feedback with emoji indicators and clear messaging
+  - Comprehensive error handling for queue operations
+  - Consistent command-line interface across all queue management functions
+
 ## [1.5.0] - 2025-07-02
 
 ### Added

cargo-hammerwork/src/commands/queue.rs

@@ -48,6 +48,11 @@ pub enum QueueCommand {
         #[arg(short = 'n', long, help = "Queue name")]
         queue: String,
     },
+    #[command(about = "List all paused queues")]
+    Paused {
+        #[arg(short, long, help = "Database connection URL")]
+        database_url: Option<String>,
+    },
     #[command(about = "Get queue health status")]
     Health {
         #[arg(short, long, help = "Database connection URL")]
@@ -85,6 +90,9 @@ impl QueueCommand {
             QueueCommand::Resume { queue, .. } => {
                 resume_queue(pool, queue).await?;
             }
+            QueueCommand::Paused { .. } => {
+                list_paused_queues(pool).await?;
+            }
             QueueCommand::Health { queue, .. } => {
                 show_queue_health(pool, queue.clone()).await?;
             }
@@ -99,6 +107,7 @@ impl QueueCommand {
             QueueCommand::Clear { database_url, .. } => database_url,
             QueueCommand::Pause { database_url, .. } => database_url,
             QueueCommand::Resume { database_url, .. } => database_url,
+            QueueCommand::Paused { database_url, .. } => database_url,
             QueueCommand::Health { database_url, .. } => database_url,
         };
 
@@ -114,21 +123,24 @@ impl QueueCommand {
 async fn list_queues(pool: DatabasePool) -> Result<()> {
     let query = r#"
         SELECT 
-            queue_name,
-            COUNT(*) as total_jobs,
-            COUNT(CASE WHEN status = 'pending' THEN 1 END) as pending,
-            COUNT(CASE WHEN status = 'running' THEN 1 END) as running,
-            COUNT(CASE WHEN status = 'completed' THEN 1 END) as completed,
-            COUNT(CASE WHEN status = 'failed' THEN 1 END) as failed,
-            COUNT(CASE WHEN status = 'dead' THEN 1 END) as dead
-        FROM hammerwork_jobs 
-        GROUP BY queue_name 
-        ORDER BY queue_name
+            j.queue_name,
+            COUNT(j.id) as total_jobs,
+            COUNT(CASE WHEN j.status = 'pending' THEN 1 END) as pending,
+            COUNT(CASE WHEN j.status = 'running' THEN 1 END) as running,
+            COUNT(CASE WHEN j.status = 'completed' THEN 1 END) as completed,
+            COUNT(CASE WHEN j.status = 'failed' THEN 1 END) as failed,
+            COUNT(CASE WHEN j.status = 'dead' THEN 1 END) as dead,
+            CASE WHEN p.queue_name IS NOT NULL THEN true ELSE false END as is_paused
+        FROM hammerwork_jobs j
+        LEFT JOIN hammerwork_queue_pause p ON j.queue_name = p.queue_name
+        GROUP BY j.queue_name, p.queue_name
+        ORDER BY j.queue_name
     "#;
 
     let mut table = comfy_table::Table::new();
     table.set_header(vec![
         "Queue",
+        "Status",
         "Total",
         "Pending",
         "Running",
@@ -148,9 +160,17 @@ async fn list_queues(pool: DatabasePool) -> Result<()> {
                 let completed: i64 = row.try_get("completed")?;
                 let failed: i64 = row.try_get("failed")?;
                 let dead: i64 = row.try_get("dead")?;
+                let is_paused: bool = row.try_get("is_paused")?;
+
+                let status = if is_paused {
+                    "⏸️ Paused"
+                } else {
+                    "▶️ Active"
+                };
 
                 table.add_row(vec![
                     queue_name,
+                    status.to_string(),
                     total.to_string(),
                     pending.to_string(),
                     running.to_string(),
@@ -170,9 +190,17 @@ async fn list_queues(pool: DatabasePool) -> Result<()> {
                 let completed: i64 = row.try_get("completed")?;
                 let failed: i64 = row.try_get("failed")?;
                 let dead: i64 = row.try_get("dead")?;
+                let is_paused: bool = row.try_get("is_paused")?;
+
+                let status = if is_paused {
+                    "⏸️ Paused"
+                } else {
+                    "▶️ Active"
+                };
 
                 table.add_row(vec![
                     queue_name,
+                    status.to_string(),
                     total.to_string(),
                     pending.to_string(),
                     running.to_string(),
@@ -379,30 +407,90 @@ async fn clear_queue(
     Ok(())
 }
 
-async fn pause_queue(_pool: DatabasePool, queue: &str) -> Result<()> {
-    // Note: This is a placeholder. In a real implementation, you might:
-    // 1. Add a queue_paused table or column
-    // 2. Update worker logic to respect paused queues
-    // 3. Store pause state in Redis or similar
+async fn pause_queue(pool: DatabasePool, queue: &str) -> Result<()> {
+    match pool {
+        DatabasePool::Postgres(pg_pool) => {
+            let result = sqlx::query(
+                r#"
+                INSERT INTO hammerwork_queue_pause (queue_name, paused_by, paused_at, created_at, updated_at)
+                VALUES ($1, $2, NOW(), NOW(), NOW())
+                ON CONFLICT (queue_name) 
+                DO UPDATE SET 
+                    paused_by = EXCLUDED.paused_by,
+                    paused_at = NOW(),
+                    updated_at = NOW()
+                "#,
+            )
+            .bind(queue)
+            .bind("cli")
+            .execute(&pg_pool)
+            .await?;
+
+            if result.rows_affected() > 0 {
+                println!("⏸️  Queue '{}' has been paused", queue);
+                info!("Queue '{}' has been paused via CLI", queue);
+            } else {
+                println!("⚠️  Failed to pause queue '{}'", queue);
+            }
+        }
+        DatabasePool::MySQL(mysql_pool) => {
+            let result = sqlx::query(
+                r#"
+                INSERT INTO hammerwork_queue_pause (queue_name, paused_by, paused_at, created_at, updated_at)
+                VALUES (?, ?, NOW(), NOW(), NOW())
+                ON DUPLICATE KEY UPDATE 
+                    paused_by = VALUES(paused_by),
+                    paused_at = NOW(),
+                    updated_at = NOW()
+                "#,
+            )
+            .bind(queue)
+            .bind("cli")
+            .execute(&mysql_pool)
+            .await?;
+
+            if result.rows_affected() > 0 {
+                println!("⏸️  Queue '{}' has been paused", queue);
+                info!("Queue '{}' has been paused via CLI", queue);
+            } else {
+                println!("⚠️  Failed to pause queue '{}'", queue);
+            }
+        }
+    }
 
-    println!(
-        "⏸️  Queue '{}' paused (placeholder - implement pause logic)",
-        queue
-    );
-    info!("Queue '{}' has been paused", queue);
     Ok(())
 }
 
-async fn resume_queue(_pool: DatabasePool, queue: &str) -> Result<()> {
-    // Note: This is a placeholder. In a real implementation, you would:
-    // 1. Remove from paused queues table/column
-    // 2. Resume worker processing for this queue
+async fn resume_queue(pool: DatabasePool, queue: &str) -> Result<()> {
+    match pool {
+        DatabasePool::Postgres(pg_pool) => {
+            let result = sqlx::query("DELETE FROM hammerwork_queue_pause WHERE queue_name = $1")
+                .bind(queue)
+                .execute(&pg_pool)
+                .await?;
+
+            if result.rows_affected() > 0 {
+                println!("▶️  Queue '{}' has been resumed", queue);
+                info!("Queue '{}' has been resumed via CLI", queue);
+            } else {
+                println!("ℹ️  Queue '{}' was not paused", queue);
+            }
+        }
+        DatabasePool::MySQL(mysql_pool) => {
+            let result = sqlx::query("DELETE FROM hammerwork_queue_pause WHERE queue_name = ?")
+                .bind(queue)
+                .execute(&mysql_pool)
+                .await?;
+
+            if result.rows_affected() > 0 {
+                println!("▶️  Queue '{}' has been resumed", queue);
+                info!("Queue '{}' has been resumed via CLI", queue);
+            } else {
+                println!("ℹ️  Queue '{}' was not paused", queue);
+            }
+        }
+    }
 
-    println!(
-        "▶️  Queue '{}' resumed (placeholder - implement resume logic)",
-        queue
-    );
-    info!("Queue '{}' has been resumed", queue);
     Ok(())
 }
 
@@ -573,3 +661,74 @@ async fn show_queue_health(pool: DatabasePool, queue: Option<String>) -> Result<
 
     Ok(())
 }
+
+async fn list_paused_queues(pool: DatabasePool) -> Result<()> {
+    let query = r#"
+        SELECT 
+            queue_name,
+            paused_at,
+            paused_by,
+            reason
+        FROM hammerwork_queue_pause 
+        ORDER BY paused_at DESC
+    "#;
+
+    let mut table = comfy_table::Table::new();
+    table.set_header(vec![
+        "Queue Name",
+        "Paused At",
+        "Paused By", 
+        "Reason",
+    ]);
+
+    match pool {
+        DatabasePool::Postgres(pg_pool) => {
+            let rows = sqlx::query(query).fetch_all(&pg_pool).await?;
+            
+            if rows.is_empty() {
+                println!("✅ No paused queues found - all queues are active");
+                return Ok(());
+            }
+
+            for row in rows {
+                let queue_name: String = row.try_get("queue_name")?;
+                let paused_at: chrono::DateTime<chrono::Utc> = row.try_get("paused_at")?;
+                let paused_by: Option<String> = row.try_get("paused_by")?;
+                let reason: Option<String> = row.try_get("reason")?;
+
+                table.add_row(vec![
+                    queue_name,
+                    paused_at.format("%Y-%m-%d %H:%M:%S UTC").to_string(),
+                    paused_by.unwrap_or_else(|| "Unknown".to_string()),
+                    reason.unwrap_or_else(|| "-".to_string()),
+                ]);
+            }
+        }
+        DatabasePool::MySQL(mysql_pool) => {
+            let rows = sqlx::query(query).fetch_all(&mysql_pool).await?;
+            
+            if rows.is_empty() {
+                println!("✅ No paused queues found - all queues are active");
+                return Ok(());
+            }
+
+            for row in rows {
+                let queue_name: String = row.try_get("queue_name")?;
+                let paused_at: chrono::DateTime<chrono::Utc> = row.try_get("paused_at")?;
+                let paused_by: Option<String> = row.try_get("paused_by")?;
+                let reason: Option<String> = row.try_get("reason")?;
+
+                table.add_row(vec![
+                    queue_name,
+                    paused_at.format("%Y-%m-%d %H:%M:%S UTC").to_string(),
+                    paused_by.unwrap_or_else(|| "Unknown".to_string()),
+                    reason.unwrap_or_else(|| "-".to_string()),
+                ]);
+            }
+        }
+    }
+
+    println!("⏸️  Paused Queues");
+    println!("{}", table);
+    Ok(())
+}