quetty 0.1.9

Terminal-based Azure Service Bus queue manager with intuitive TUI interface
Documentation

Quetty

Version Status Rust Azure Terminal TUI License: MIT

A powerful terminal-based Azure Service Bus queue manager that provides an intuitive interface for viewing, managing, and interacting with message queues efficiently.

Table of Contents

Overview

Quetty combines the power of Azure Service Bus with a sleek terminal interface, making queue management accessible and efficient. Whether you're debugging message flows, managing dead letter queues, or performing bulk operations, Quetty provides the tools you need in a fast, keyboard-driven environment.

🚧 Development Phase

Quetty is currently in Beta

We are actively developing and testing Quetty to ensure it meets production standards. During this phase, we're focusing on:

  • ✅ Performance & UI Testing: Verifying optimal performance across different environments and platforms. | Tested on most common terminal emulators (Ghostty recomended, WezTerm, ITerm2, Warp, macOS defaul Terminal not recomended).
  • ✅ Nightly Builds: Automated nightly builds available for all major platforms (Linux, Windows, macOS)
  • ✅ Installation Methods: Multiple installation options including nightly builds and source compilation
  • ⏳ Configuration System: Implementing a fully working configuration system with easy setup for binary installations
  • ⏳ Action Verification: Adding deep verification for destructive operations (like delete actions) to prevent accidental data loss

While Quetty is functional and actively used in development environments, please exercise caution when using it in production scenarios. We recommend thorough testing in your specific environment before deploying to production systems.

🧪 Beta Testing

Want to participate in beta testing? We'd love your feedback! Contact us via:

Your testing and feedback help us build a better tool for the entire Azure Service Bus community.

Interface Preview

🎥 Live Demo

See Quetty in action with this interactive demo showcasing core features:

https://github.com/user-attachments/assets/f52fb894-47a5-4287-b936-9e2b437a308a

Key Features

🔍 Message Management

  • Smart Preview: Automatically previews messages with syntax highlighting
  • Efficient Pagination: Browse large queues with intelligent caching
  • Bulk Operations: Delete, send, or manage multiple messages at once
  • Message Editing: Edit and resend messages directly from the interface

🔄 Dead Letter Queue Support

  • Seamless DLQ Navigation: Switch between main and dead letter queues
  • Message Recovery: Resend messages from DLQ back to main queue
  • Bulk DLQ Operations: Handle multiple messages efficiently

🎯 Azure Integration

  • Multiple Auth Methods: Device code, client credentials, connection strings
  • Azure Discovery: Automatically discover subscriptions, resource groups, and namespaces
  • Queue Statistics: Real-time queue metrics and health monitoring

📁 Profile Management

  • Multi-Environment Support: Separate profiles for dev, staging, production
  • Profile Switching: Quick environment switching with --profile flag
  • Secure Isolation: Each profile has isolated configuration and credentials
  • Easy Setup: Interactive setup wizard for each environment

🎨 User Experience

  • Intuitive Interface: Keyboard-driven navigation with vim-like shortcuts
  • Customizable Themes: Built-in themes (Catppuccin, Nightfox, Quetty) with custom theme support
  • Real-time Updates: Instant feedback with smart state management
  • Comprehensive Help: Context-aware help system

Quick Start

Prerequisites

  • Rust (latest stable version)
  • Azure Service Bus namespace with appropriate permissions

Installation

Option 1: One-Line Installation 🚀 (Recommended)

The fastest way to get Quetty running on any platform:

Unix/Linux/macOS:

curl -fsSL https://raw.githubusercontent.com/dawidpereira/quetty/main/install.sh | sh

Windows PowerShell:

Invoke-RestMethod -Uri "https://raw.githubusercontent.com/dawidpereira/quetty/main/install.ps1" | Invoke-Expression

What the installer does:

  • ✅ Auto-detects your platform and architecture
  • ✅ Downloads the correct pre-built binary
  • ✅ Verifies SHA256 checksum for security
  • ✅ Installs to your PATH (~/.local/bin or system directory)
  • ✅ Ready to use immediately

Advanced options:

# Install specific version
curl -fsSL https://raw.githubusercontent.com/dawidpereira/quetty/main/install.sh | sh -s -- --version v0.1.0

# Install to custom directory
curl -fsSL https://raw.githubusercontent.com/dawidpereira/quetty/main/install.sh | sh -s -- --install-dir /opt/bin

# System-wide installation (requires sudo)
curl -fsSL https://raw.githubusercontent.com/dawidpereira/quetty/main/install.sh | sh -s -- --system

# Install nightly build
curl -fsSL https://raw.githubusercontent.com/dawidpereira/quetty/main/install.sh | sh -s -- --channel nightly

# Preview what will be installed (dry run)
curl -fsSL https://raw.githubusercontent.com/dawidpereira/quetty/main/install.sh | sh -s -- --dry-run

Supported platforms:

  • Linux x64, macOS Intel/Apple Silicon, Windows x64/ARM64

Option 2: Homebrew 🍺 (macOS/Linux)

The recommended way for macOS and Linux users:

⚠️ Beta Release: This installs the current beta version. Expect potential changes and updates before the stable release.

# Add the tap
brew tap dawidpereira/quetty

# Install quetty
brew install quetty

# Verify installation
quetty --version

What you get:

  • ✅ Automatic dependency management
  • ✅ Easy updates with brew upgrade quetty
  • ✅ Clean uninstall with brew uninstall quetty
  • ✅ Integration with system PATH

Option 3: Manual Download 📦

Download pre-built binaries from GitHub Releases:

Stable Releases 🎯 (Production):

Nightly Builds 🌙 (Latest features):

Manual installation:

# Linux/macOS
tar -xzf quetty-*-*.tar.gz
chmod +x quetty-*
mv quetty-* ~/.local/bin/quetty

# Windows
# Extract ZIP and move to PATH directory

# Verify checksums
sha256sum -c checksums.txt

Option 4: Build from Source 🔧

For development or latest unreleased features:

git clone https://github.com/dawidpereira/quetty.git
cd quetty
cargo build --release
cp target/release/quetty ~/.local/bin/

First Run

Interactive Setup (Recommended)

# Run the setup wizard
quetty --setup

# For specific environments, use profiles
quetty --profile dev --setup      # Development environment
quetty --profile prod --setup     # Production environment

Quick Start

# Default profile
quetty

# Specific profile
quetty --profile dev
quetty --profile staging
quetty --profile prod

On first launch, Quetty will guide you through the configuration process. For detailed setup instructions, see INSTALLATION.md.

Basic Usage

  1. Configure Authentication: Set up Azure AD or connection string authentication
  2. Select Namespace: Choose your Service Bus namespace
  3. Pick a Queue: Select the queue you want to manage
  4. Start Managing: Use keyboard shortcuts to navigate and manage messages

💡 Tip: Press h at any time to see available keyboard shortcuts and help.

Profile Management

Quetty supports multiple profiles for different environments:

# Create profiles for different environments
quetty --profile dev --setup       # Development environment
quetty --profile staging --setup   # Staging environment
quetty --profile prod --setup      # Production environment

# Switch between environments
quetty --profile dev              # Use development profile
quetty --profile prod             # Use production profile
quetty                           # Use default profile

# Show configuration directory
quetty --config-dir              # Shows ~/.config/quetty

# Use custom config file
quetty --config ./my-config.toml # Custom configuration

Development

For development setup and contribution guidelines, see CONTRIBUTING.md.

Project Structure

  • ui/ - Terminal user interface (main application)
  • server/ - Core library for Azure Service Bus integration
  • themes/ - Built-in themes and theme definitions

Documentation

Getting Started

Reference

Additional Resources

Roadmap

Upcoming Features

  • Binary Releases: Pre-built binaries for major platforms
  • Enhanced Bulk Operations: Improved performance for large-scale operations
  • Message Templates: Save and reuse common message patterns
  • Topic Support: Full Azure Service Bus Topics and Subscriptions support
  • Advanced Filtering: Search and filter messages by content, properties, and metadata

Recent Additions

  • ✅ Profile-Based Configuration: Multi-environment support with isolated settings
  • ✅ Enhanced Security: Path traversal protection and input validation
  • ✅ Performance Optimization: Intelligent caching and reduced filesystem operations
  • ✅ Complete Authentication Suite: Device code, client credentials, connection strings
  • ✅ Bulk Operations: Multi-message delete, DLQ, and resend operations
  • ✅ Theme System: Customizable themes with built-in theme packs
  • ✅ Message Editing: Edit and resend messages with validation
  • ✅ Azure Discovery: Automatic resource discovery and selection

Acknowledgments

Quetty is built on the shoulders of amazing open-source projects:

  • Ratatui - A powerful Rust library for building rich terminal user interfaces
  • tui-realm - An excellent framework for building stateful TUI applications
  • Tokio - The asynchronous runtime for Rust
  • Azure SDK for Rust - Azure service integrations

Special thanks to the maintainers and contributors of these projects for making terminal-based applications in Rust both powerful and enjoyable to develop.

License

This project is licensed under the MIT License - see the LICENSE file for details.