Added README and production release workflow

.forgejo/workflows/release.yaml

@@ -0,0 +1,179 @@
+name: Multi-Platform Release Build
+on:
+  push:
+    tags:
+      - "v*.*.*"
+jobs:
+  build:
+    runs-on: docker
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - target: native
+            cross: false
+            platform: linux/arm64
+
+          - target: x86_64-unknown-linux-gnu
+            cross: true
+            platform: linux/amd64
+            deps: "build-essential gcc-x86-64-linux-gnu libc6-dev-amd64-cross pkg-config binutils-x86-64-linux-gnu"
+            env:
+              CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER: x86_64-linux-gnu-gcc
+
+          - target: x86_64-pc-windows-gnu
+            cross: true
+            platform: linux/amd64
+            deps: "gcc-mingw-w64-x86-64 g++-mingw-w64-x86-64 cmake nasm"
+            env:
+              CC_x86_64_pc_windows_gnu: x86_64-w64-mingw32-gcc
+              CARGO_TARGET_X86_64_PC_WINDOWS_GNU_LINKER: x86_64-w64-mingw32-gcc
+
+    steps:
+      - name: Checkout code
+        uses: https://code.forgejo.org/actions/checkout@v4
+
+      - name: Setup Rust
+        uses: https://github.com/dtolnay/rust-toolchain@stable
+        with:
+          toolchain: stable
+
+      - name: Cache Rust dependencies
+        uses: https://code.forgejo.org/actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: ${{ runner.os }}-cargo-${{ matrix.target }}-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-${{ matrix.target }}-
+            ${{ runner.os }}-cargo-
+
+      - name: Native Build Release
+        if: matrix.target == 'native'
+        run: |
+          NATIVE_TARGET=$(rustc -vV | grep 'host:' | cut -d' ' -f2)
+          echo "Building for native target: $NATIVE_TARGET"
+          cargo build --release
+          TARGET_BINARY="target/release/uptime-kuma-dashboard"
+          OUTPUT_NAME="uptime-kuma-dashboard-$NATIVE_TARGET"
+          mkdir -p release-artifacts
+          cp "$TARGET_BINARY" "release-artifacts/$OUTPUT_NAME"
+          strip "release-artifacts/$OUTPUT_NAME" 2>/dev/null || true
+          chmod +x "release-artifacts/$OUTPUT_NAME"
+          ls -lh "release-artifacts/$OUTPUT_NAME"
+
+      - name: Get Rust version
+        id: rust-version
+        run: echo "version=$(rustc --version | cut -d' ' -f2)" >> $GITHUB_OUTPUT
+
+      - name: Cross-Build Linux x86_64 Release
+        if: matrix.target == 'x86_64-unknown-linux-gnu'
+        uses: docker://rust:slim
+        with:
+          args: >
+            sh -c "
+            rustup target add ${{ matrix.target }} &&
+            apt-get update && apt-get install -y ${{ matrix.deps }} &&
+            mkdir -p ~/.cargo &&
+            echo '[target.${{ matrix.target }}]\nlinker = \"x86_64-linux-gnu-gcc\"' > ~/.cargo/config.toml &&
+            cargo build --release --target ${{ matrix.target }} &&
+            mkdir -p release-artifacts &&
+            cp target/${{ matrix.target }}/release/uptime-kuma-dashboard release-artifacts/uptime-kuma-dashboard-${{ matrix.target }} &&
+            x86_64-linux-gnu-strip release-artifacts/uptime-kuma-dashboard-${{ matrix.target }} &&
+            chmod +x release-artifacts/uptime-kuma-dashboard-${{ matrix.target }}"
+        env: ${{ matrix.env }}
+        options: --platform ${{ matrix.platform }}
+
+      - name: Cross-Build Windows x86_64 Release
+        if: matrix.target == 'x86_64-pc-windows-gnu'
+        uses: docker://rust:slim
+        with:
+          args: >
+            sh -c "
+            rustup target add ${{ matrix.target }} &&
+            apt-get update && apt-get install -y ${{ matrix.deps }} &&
+            cargo build --release --target ${{ matrix.target }} &&
+            mkdir -p release-artifacts &&
+            cp target/${{ matrix.target }}/release/uptime-kuma-dashboard.exe release-artifacts/uptime-kuma-dashboard-${{ matrix.target }}.exe &&
+            ls -lh release-artifacts/"
+        env: ${{ matrix.env }}
+        options: --platform ${{ matrix.platform }}
+
+      - name: Upload artifacts
+        uses: https://data.forgejo.org/forgejo/upload-artifact@v4
+        with:
+          name: binary-${{ matrix.target }}
+          path: release-artifacts/
+          retention-days: 1
+
+  create-release:
+    runs-on: docker
+    needs: build
+    permissions:
+      contents: write
+    steps:
+      - name: Checkout code
+        uses: https://code.forgejo.org/actions/checkout@v4
+
+      - name: Download all artifacts
+        uses: https://data.forgejo.org/forgejo/download-artifact@v4
+        with:
+          path: all-artifacts/
+
+      - name: Prepare release artifacts
+        run: |
+          mkdir -p release-artifacts
+          find all-artifacts -type f -name "uptime-kuma-dashboard-*" -exec cp {} release-artifacts/ \;
+          ls -lh release-artifacts/
+
+      - name: Generate checksums
+        run: |
+          cd release-artifacts
+          sha256sum uptime-kuma-dashboard-* > SHA256SUMS.txt
+          cat SHA256SUMS.txt
+
+      - name: Create Release
+        uses: https://code.forgejo.org/actions/forgejo-release@v2
+        with:
+          direction: upload
+          url: https://git.marcodearaujo.com
+          repo: marcodearaujo/uptime-kuma-dashboard
+          token: ${{ secrets.FORGEJO_TOKEN }}
+          release-dir: release-artifacts
+          title: "Release ${{ forgejo.ref_name }}"
+          tag: ${{ forgejo.ref_name }}
+          release-notes: |
+            ## 🚀 Multi-Platform Release
+            Compiled on Forgejo Runner **${{ runner.arch }}**
+
+            ### 📦 Available Binaries
+            This release includes binaries for the following platforms:
+            - **Linux x86_64** (Intel/AMD 64-bit)
+            - **Linux ARM64** (aarch64) - Raspberry Pi 4, ARM servers
+            - **Windows x86_64** (64-bit)
+
+            ### 🚀 How to use
+            #### Linux/ARM:
+                # Download the appropriate binary
+                wget https://your-forgejo.com/releases/download/${{ forgejo.ref_name }}/uptime-kuma-dashboard-<your-target>
+                # Make executable
+                chmod +x uptime-kuma-dashboard-*
+                # Run
+                ./uptime-kuma-dashboard-* --base-url https://your-kuma --slug your-slug
+
+            #### Windows:
+                # Download uptime-kuma-dashboard-x86_64-pc-windows-gnu.exe
+                # Run in PowerShell or CMD
+                .\uptime-kuma-dashboard-x86_64-pc-windows-gnu.exe --base-url https://your-kuma --slug your-slug
+
+            ### ✅ Verify Checksums
+                sha256sum -c SHA256SUMS.txt
+
+            ### 🏗️ Build Information
+            - Rust Version: ${{ steps.rust-version.outputs.version }}
+            - Build Date: $(date +'%Y-%m-%d')
+            - Build Type: Release (optimized with LTO)

README.md

@@ -0,0 +1,132 @@
+# Uptime Kuma Terminal Dashboard
+
+![Terminal Dashboard Preview](https://img.shields.io/badge/Rust-1.76+-orange?style=flat-square&logo=rust)
+
+A terminal-based monitoring dashboard for Uptime Kuma that displays service status, uptime percentages, and historical performance data directly in your terminal. Built with Rust for performance and reliability.
+
+## Overview
+
+This personal project started as a way to monitor my home lab services without needing a web browser. It connects to your Uptime Kuma instance API and presents a clean, color-coded view of your services' status with real-time updates. The dashboard works great on servers, remote terminals, or anywhere you prefer a lightweight monitoring solution.
+
+Perfect for DevOps engineers, system administrators, or anyone who prefers terminal workflows over web interfaces for quick status checks.
+
+## Features
+
+- Real-time service monitoring with automatic refresh
+- Color-coded status indicators (green for up, red for down)
+- Historical uptime visualization with compact status history lines
+- Responsive terminal UI that adapts to window size
+- Internationalization support (English and Portuguese)
+- Configurable refresh intervals
+- Minimal resource usage (runs efficiently even on low-power devices)
+- Keyboard navigation support (arrow keys, home/end)
+- Mobile-friendly design for SSH connections
+
+## Tech Stack
+
+This project demonstrates proficiency with several modern technologies:
+
+- **Rust** (core language with async capabilities)
+- **ratatui** (terminal UI framework)
+- **reqwest** (HTTP client for API communication)
+- **serde** (JSON serialization/deserialization)
+- **clap** (command-line argument parsing)
+- **fluent-templates** (internationalization framework)
+- REST API integration patterns
+- Error handling and logging best practices
+- Cross-platform terminal development
+
+You can find the latest releases in the [Releases section](https://git.marcodearaujo.com/marcodearaujo/uptime-kuma-dashboard/releases).
+
+## Installation
+
+### Option 1: Download built Binary (Recommended)
+1. Go to the [Releases page](https://git.marcodearaujo.com/marcodearaujo/uptime-kuma-dashboard/releases)
+2. Download the binary for your operating system
+3. Make it executable: `chmod +x uptime-kuma-dashboard`
+4. Run it with your Uptime Kuma URL and slug
+
+### Option 2: Build From Source
+
+### Prerequisites
+
+- Rust 1.74+ toolchain (install via [rustup](https://rustup.rs/))
+- Uptime Kuma instance with API access
+
+### Build from Source
+
+```bash
+# Clone the repository
+git clone https://git.marcodearaujo.com/marcodearaujo/uptime-kuma-dashboard.git
+cd uptime-kuma-dashboard
+
+# Build the project
+cargo build --release
+
+# Run the dashboard (replace with your Uptime Kuma URL and status page slug)
+./target/release/uptime-kuma-dashboard \
+  --base-url="http://your-uptime-kuma-instance:3001/" \
+  --slug="your-status-page-slug"
+```
+
+## Usage
+
+The dashboard requires two parameters:
+
+- `--base-url`: Your Uptime Kuma instance URL (including port)
+- `--slug`: Your status page slug identifier
+
+Example:
+```bash
+./uptime-kuma-dashboard --base-url="http://192.168.1.100:3001/" --slug="home-services"
+```
+
+**Controls during runtime:**
+- `q` or `ESC`: Exit the dashboard
+- `↑`/`↓` or `k`/`j`: Navigate through monitors
+- `Home`/`End`: Jump to top/bottom of the list
+
+## Configuration
+
+You can set environment variables to avoid typing parameters each time:
+
+```bash
+export UPTIME_KUMA_URL="http://your-uptime-kuma-instance:3001/"
+export STATUS_PAGE_SLUG="your-status-page-slug"
+```
+
+## Development Notes
+
+This project follows Rust best practices including:
+- Comprehensive error handling with `anyhow`
+- Internationalization-ready architecture
+- Modular code organization
+- Performance optimization for terminal rendering
+- Cross-platform compatibility testing
+
+The architecture separates concerns into:
+- API client layer
+- Data processing core
+- UI rendering components
+- Configuration management
+- Internationalization system
+
+## Contribution
+
+While this is primarily a personal project, I welcome suggestions and improvements! If you have ideas for new features or bug fixes:
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a pull request
+
+Please note this is a side project, so response times may vary.
+
+## License
+
+This project is available under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+---
+
+*Developed as a personal learning project to improve Rust skills and create a useful tool for my home lab monitoring. Feedback welcome!*