Fix typo

.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)

Cargo.lock

@@ -78,9 +78,9 @@ dependencies = [
 
 [[package]]
 name = "anyhow"
-version = "1.0.100"
+version = "1.0.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61"
+checksum = "5f0e0fee31ef5ed1ba1316088939cea399010ed7731dba877ed44aeb407a75ea"
 
 [[package]]
 name = "atomic"
@@ -249,9 +249,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.54"
+version = "4.5.57"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6e6ff9dcd79cff5cd969a17a545d79e84ab086e444102a591e288a8aa3ce394"
+checksum = "6899ea499e3fb9305a65d5ebf6e3d2248c5fab291f300ad0a704fbe142eae31a"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -259,9 +259,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.54"
+version = "4.5.57"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa42cf4d2b7a41bc8f663a7cab4031ebafa1bf3875705bfaf8466dc60ab52c00"
+checksum = "7b12c8b680195a62a8364d16b8447b01b6c2c8f9aaf68bee653be34d4245e238"
 dependencies = [
  "anstream",
  "anstyle",
@@ -271,9 +271,9 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.5.49"
+version = "4.5.55"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a0b5487afeab2deb2ff4e03a807ad1a03ac532ff5a2cee5d86884440c7f7671"
+checksum = "a92793da1a46a5f2a02a6f4c46c6496b28c43638adea8306fcb0caa1634f24e5"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -2668,7 +2668,7 @@ checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
 [[package]]
 name = "uptime-kuma-dashboard"
-version = "0.1.0"
+version = "0.38.2"
 dependencies = [
  "anyhow",
  "chrono",

Cargo.toml

@@ -1,16 +1,16 @@
 [package]
 name = "uptime-kuma-dashboard"
-version = "0.1.0"
+version = "0.38.2"
 edition = "2024"
 
 [dependencies]
-clap = { version = "4.5.54", features = ["derive", "env"] }
+clap = { version = "4.5.57", features = ["derive", "env"] }
 reqwest = { version = "0.13.1", default-features = false, features = [
     "blocking",
     "json",
     "rustls",
 ] }
-anyhow = "1.0"
+anyhow = "1.0.101"
 fluent-templates = "0.13.2"
 unic-langid = "0.9.6"
 sys-locale = "0.3.2"

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Marco De Araujo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,145 @@
+# 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.
+
+## Demo
+
+<video width="800" controls>
+  <source src="assets/demo.webm" type="video/webm">
+  Your browser does not support the video tag.
+</video>
+
+## 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:
+   - **Linux (x86_64)**: `uptime-kuma-dashboard-x86_64-unknown-linux-gnu`
+   - **Linux (ARM64)**: `uptime-kuma-dashboard-aarch64-unknown-linux-gnu` (Raspberry Pi, ARM servers)
+   - **Windows**: `uptime-kuma-dashboard-x86_64-pc-windows-gnu.exe`
+3. Verify the checksum (recommended for security):
+   ```bash
+   sha256sum -c SHA256SUMS.txt
+   ```
+4. Make it executable (Linux/ARM only):
+   ```bash
+   chmod +x uptime-kuma-dashboard-*
+   ```
+5. Run with your parameters:
+   ```bash
+   ./uptime-kuma-dashboard-* --base-url="http://your-kuma:3001/" --slug="your-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
+
+## 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!_

src/api/client.rs

@@ -1,9 +1,11 @@
+use std::time::Duration;
+
 use anyhow::Result;
 use reqwest::blocking::Client;
 
 use crate::{
     api::endpoints::UptimeKumaEndpoints,
-    data::{self, heartbeat::HeartbeatResponse, status_page::model::StatusPageResponse},
+    data::{self, heartbeat::HeartbeatResponse, status_page::model::StatusPageResponse}, i18n::t,
 };
 
 #[derive(Debug, Clone)]
@@ -13,8 +15,9 @@ pub struct UptimeKumaClient {
 
 impl UptimeKumaClient {
     pub fn new() -> Self {
+        let client = Client::builder().connect_timeout(Duration::from_secs(10)).timeout(Duration::from_secs(30)).build().unwrap_or_else(|_| panic!("{}", t("http-build-error")));
         Self {
-            client: Client::new(),
+            client,
         }
     }
 

src/ui/app.rs

@@ -1,12 +1,10 @@
 use crate::api::{UptimeKumaClient, UptimeKumaEndpoints};
 use crate::core;
-use crate::data::{heartbeat::HeartbeatResponse, status_page::model::StatusPageResponse};
 use crate::i18n::{t, t_with_args};
 use crate::ui::{
     components::{render_footer, render_header, render_monitor_list},
     dashboard::model::DashboardViewState,
 };
-use anyhow::Result;
 use crossterm::{
     event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyEventKind},
     execute,
@@ -24,8 +22,6 @@ use ratatui::{
 use std::{
     collections::HashMap,
     io,
-    sync::mpsc,
-    thread,
     time::{Duration, Instant},
 };
 
@@ -33,11 +29,6 @@ const INITIAL_INTERVAL: u32 = 300;
 const MAIN_LAYOUT_WITH_SCROLLBAR: [Constraint; 2] = [Constraint::Min(1), Constraint::Length(1)];
 const MAIN_LAYOUT_WITHOUT_SCROLLBAR: [Constraint; 1] = [Constraint::Min(1)];
 
-enum FetchResult {
-    Heartbeat(Result<HeartbeatResponse>),
-    StatusPage(Result<StatusPageResponse>),
-}
-
 pub struct App {
     state: DashboardViewState,
     terminal: Terminal<CrosstermBackend<io::Stdout>>,
@@ -49,6 +40,26 @@ pub struct App {
 }
 
 impl App {
+    pub fn new(endpoints: UptimeKumaEndpoints) -> io::Result<Self> {
+        let backend = CrosstermBackend::new(io::stdout());
+        let mut terminal = Terminal::new(backend)?;
+        terminal.hide_cursor()?;
+
+        let state = DashboardViewState::new();
+
+        let initial_interval = Duration::from_secs(INITIAL_INTERVAL as u64);
+
+        Ok(Self {
+            state,
+            terminal,
+            should_quit: false,
+            last_update: Instant::now(),
+            update_interval: initial_interval,
+            endpoints,
+            client: UptimeKumaClient::new(),
+        })
+    }
+
     fn setup_terminal(&mut self) -> io::Result<()> {
         enable_raw_mode()?;
         execute!(io::stdout(), EnterAlternateScreen, EnableMouseCapture)?;
@@ -180,7 +191,7 @@ impl App {
         }
 
         let max_scroll = state
-            .get_total_lenght()
+            .get_total_length()
             .saturating_sub(area[0].height as usize)
             .saturating_add(1);
 
@@ -248,57 +259,11 @@ impl App {
         Ok(())
     }
 
-    pub fn new(endpoints: UptimeKumaEndpoints) -> io::Result<Self> {
-        let backend = CrosstermBackend::new(io::stdout());
-        let mut terminal = Terminal::new(backend)?;
-        terminal.hide_cursor()?;
-
-        let state = DashboardViewState::new();
-
-        let initial_interval = Duration::from_secs(INITIAL_INTERVAL as u64);
-
-        Ok(Self {
-            state,
-            terminal,
-            should_quit: false,
-            last_update: Instant::now(),
-            update_interval: initial_interval,
-            endpoints,
-            client: UptimeKumaClient::new(),
-        })
-    }
-
     fn fetch_and_update_data(&mut self) -> anyhow::Result<()> {
-        let (tx, rx) = mpsc::channel();
+        let heartbeat_result = self.client.fetch_heartbeat(&self.endpoints)?;
+        let status_page_result = self.client.fetch_status_page(&self.endpoints)?;
 
-        let heartbeat_client = self.client.clone();
-        let heartbeat_endpoints = self.endpoints.clone();
-        let tx_clone = tx.clone();
-        thread::spawn(move || {
-            let result = heartbeat_client.fetch_heartbeat(&heartbeat_endpoints);
-            tx.send(FetchResult::Heartbeat(result)).unwrap();
-        });
-
-        let status_page_client = self.client.clone();
-        let status_page_endpoints = self.endpoints.clone();
-
-        thread::spawn(move || {
-            let result = status_page_client.fetch_status_page(&status_page_endpoints);
-            tx_clone.send(FetchResult::StatusPage(result)).unwrap();
-        });
-
-        let mut heartbeat_result = None;
-        let mut status_page_result = None;
-
-        for _ in 0..2 {
-            match rx.recv()? {
-                FetchResult::Heartbeat(result) => heartbeat_result = Some(result?),
-                FetchResult::StatusPage(result) => status_page_result = Some(result?),
-            }
-        }
-        let heartbeat_data = heartbeat_result.unwrap();
-        let status_page_data = status_page_result.unwrap();
-        let unified_data = core::unify_data(&status_page_data, &heartbeat_data);
+        let unified_data = core::unify_data(&status_page_result, &heartbeat_result);
         self.state = DashboardViewState::from_unified_data(unified_data);
         Ok(())
     }

src/ui/components/monitor_list.rs

@@ -38,7 +38,7 @@ static STATUS_LINE_CACHE: OnceLock<RwLock<HashMap<u64, Line<'static>>>> = OnceLo
 
 pub fn render_monitor_list(main_frame: &mut Frame, area: Rect, state: &mut DashboardViewState) {
     let available_height = area.height as usize;
-    let max_scroll = state.get_total_lenght().saturating_sub(available_height);
+    let max_scroll = state.get_total_length().saturating_sub(available_height);
 
     if state.scroll_state.get_position() > max_scroll {
         state.scroll_state = state.scroll_state.position(max_scroll);
@@ -48,7 +48,7 @@ pub fn render_monitor_list(main_frame: &mut Frame, area: Rect, state: &mut Dashb
     let mut current_y = area.y as usize;
     let mut rendered_height = 0;
     let mut lines_skipped = 0;
-    let half = state.get_total_lenght().saturating_div(2);
+    let half = state.get_total_length().saturating_div(2);
 
     for group in state.groups.iter() {
         let group_height = group.monitors.len() + BORDER_LINES_VIEW;
@@ -259,7 +259,6 @@ fn get_cached_status_line(status_history: &[MonitorStatus]) -> Line<'static> {
     spans.extend(
         status_history
             .iter()
-            .rev()
             .take(STATUS_LINE_LENGTH)
             .map(|status| get_status_span(status).clone()),
     );

src/ui/dashboard/model.rs

@@ -81,7 +81,7 @@ impl DashboardViewState {
         }
     }
 
-    pub fn get_total_lenght(&self) -> usize {
+    pub fn get_total_length(&self) -> usize {
         self.total_length
     }