🐛 fix: consolidate publish-github into single shell block

Multiple command blocks caused $RELEASE_ID to be lost between shells.
Using ${ARCH} with braces triggered Drone variable substitution before
the shell ran, resulting in an empty arch name. Fix: single | block
with all logic, iterate over full filenames (same pattern as publish),
and use ENVIRON["DRONE_TAG"] in awk to bypass Drone substitution.

.drone.yml

@@ -109,3 +109,45 @@ steps:
     depends_on:
       - build-x86_64
       - build-aarch64
+
+  - name: publish-github
+    image: alpine
+    environment:
+      GITHUB_TOKEN:
+        from_secret: GITHUB_TOKEN
+      GITHUB_REPO: cinco/tmuxido
+    commands:
+      - apk add --no-cache curl jq
+      - |
+        EXISTING=$(curl -fsSL \
+          -H "Authorization: token $GITHUB_TOKEN" \
+          -H "Accept: application/vnd.github.v3+json" \
+          "https://api.github.com/repos/$GITHUB_REPO/releases/tags/$DRONE_TAG" | jq -r '.id // empty')
+        if [ -n "$EXISTING" ]; then
+          curl -s -X DELETE \
+            -H "Authorization: token $GITHUB_TOKEN" \
+            "https://api.github.com/repos/$GITHUB_REPO/releases/$EXISTING"
+        fi
+        BODY=$(awk '
+          BEGIN { tag = ENVIRON["DRONE_TAG"] }
+          /^## \[/ { in_section = (index($0, "[" tag "]") > 0); next }
+          in_section && /^## \[/ { exit }
+          in_section { print }
+        ' CHANGELOG.md)
+        RELEASE_ID=$(curl -fsSL -X POST \
+          -H "Authorization: token $GITHUB_TOKEN" \
+          -H "Accept: application/vnd.github.v3+json" \
+          -H "Content-Type: application/json" \
+          "https://api.github.com/repos/$GITHUB_REPO/releases" \
+          -d "{\"tag_name\":\"$DRONE_TAG\",\"name\":\"$DRONE_TAG\",\"body\":$(echo "$BODY" | jq -Rs .)}" \
+          | jq -r '.id')
+        for FILE in tmuxido-x86_64-linux tmuxido-aarch64-linux; do
+          curl -fsSL -X POST \
+            -H "Authorization: token $GITHUB_TOKEN" \
+            -H "Content-Type: application/octet-stream" \
+            "https://uploads.github.com/repos/$GITHUB_REPO/releases/$RELEASE_ID/assets?name=$FILE" \
+            --data-binary @"$FILE"
+        done
+    depends_on:
+      - build-x86_64
+      - build-aarch64

CHANGELOG.md

@@ -4,6 +4,24 @@ 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/).
 
+## [0.7.0] - 2026-03-01
+
+### Changed
+- `install.sh` now downloads from GitHub Releases
+- Self-update now queries the GitHub Releases API for new versions
+- Releases are published to both Gitea and GitHub
+
+## [0.6.0] - 2026-03-01
+
+### Added
+- Periodic update check: on startup, if `update_check_interval_hours` have elapsed since
+  the last check, tmuxido fetches the latest release tag from the Gitea API and prints a
+  notice when a newer version is available (silent on network failure or no update found)
+- New `update_check` module (`src/update_check.rs`) with injected fetcher for testability
+- `update_check_interval_hours` config field (default 24, set to 0 to disable)
+- Cache file `~/.cache/tmuxido/update_check.json` tracks last-checked timestamp and
+  latest known version across runs
+
 ## [0.5.2] - 2026-03-01
 
 ### Added

Cargo.lock

@@ -864,7 +864,7 @@ dependencies = [
 
 [[package]]
 name = "tmuxido"
-version = "0.5.2"
+version = "0.7.0"
 dependencies = [
  "anyhow",
  "clap",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tmuxido"
-version = "0.5.2"
+version = "0.7.0"
 edition = "2024"
 
 [dev-dependencies]

install.sh

@@ -1,8 +1,9 @@
 #!/bin/sh
 set -e
 
-REPO="cinco/Tmuxido"
+REPO="cinco/tmuxido"
-BASE_URL="https://git.cincoeuzebio.com"
+BASE_URL="https://github.com"
+API_URL="https://api.github.com"
 INSTALL_DIR="$HOME/.local/bin"
 
 arch=$(uname -m)
@@ -12,8 +13,10 @@ case "$arch" in
     *) echo "Unsupported architecture: $arch" >&2; exit 1 ;;
 esac
 
-tag=$(curl -fsSL "$BASE_URL/api/v1/repos/$REPO/releases?limit=1&page=1" \
+tag=$(curl -fsSL \
-  | grep -o '"tag_name":"[^"]*"' | head -1 | cut -d'"' -f4)
+  -H "Accept: application/vnd.github.v3+json" \
+  "$API_URL/repos/$REPO/releases/latest" \
+  | grep -o '"tag_name":"[^"]*"' | cut -d'"' -f4)
 
 [ -z "$tag" ] && { echo "Could not fetch latest release" >&2; exit 1; }
 

src/config.rs

@@ -15,6 +15,8 @@ pub struct Config {
     pub cache_enabled: bool,
     #[serde(default = "default_cache_ttl_hours")]
     pub cache_ttl_hours: u64,
+    #[serde(default = "default_update_check_interval_hours")]
+    pub update_check_interval_hours: u64,
     #[serde(default = "default_session_config")]
     pub default_session: SessionConfig,
 }
@@ -31,6 +33,10 @@ fn default_cache_ttl_hours() -> u64 {
     24
 }
 
+fn default_update_check_interval_hours() -> u64 {
+    24
+}
+
 fn default_session_config() -> SessionConfig {
     use crate::session::Window;
 
@@ -109,6 +115,7 @@ impl Config {
                 max_depth,
                 cache_enabled,
                 cache_ttl_hours,
+                update_check_interval_hours: default_update_check_interval_hours(),
                 default_session: SessionConfig { windows },
             };
 
@@ -229,6 +236,7 @@ impl Config {
             max_depth: 5,
             cache_enabled: true,
             cache_ttl_hours: 24,
+            update_check_interval_hours: default_update_check_interval_hours(),
             default_session: default_session_config(),
         }
     }
@@ -245,6 +253,7 @@ mod tests {
         assert_eq!(config.max_depth, 5);
         assert!(config.cache_enabled);
         assert_eq!(config.cache_ttl_hours, 24);
+        assert_eq!(config.update_check_interval_hours, 24);
     }
 
     #[test]

src/lib.rs

@@ -4,6 +4,7 @@ pub mod deps;
 pub mod self_update;
 pub mod session;
 pub mod ui;
+pub mod update_check;
 
 use anyhow::Result;
 use cache::ProjectCache;
@@ -192,6 +193,7 @@ mod tests {
             max_depth: 3,
             cache_enabled,
             cache_ttl_hours: 24,
+            update_check_interval_hours: 24,
             default_session: session::SessionConfig { windows: vec![] },
         }
     }

src/main.rs

@@ -6,6 +6,7 @@ use std::process::{Command, Stdio};
 use tmuxido::config::Config;
 use tmuxido::deps::ensure_dependencies;
 use tmuxido::self_update;
+use tmuxido::update_check;
 use tmuxido::{get_projects, launch_tmux_session, show_cache_status};
 
 #[derive(Parser, Debug)]
@@ -48,6 +49,9 @@ fn main() -> Result<()> {
     // Load config
     let config = Config::load()?;
 
+    // Periodic update check (silent on failure or no update)
+    update_check::check_and_notify(&config);
+
     // Handle cache status command
     if args.cache_status {
         show_cache_status(&config)?;

src/self_update.rs

@@ -3,8 +3,9 @@ use std::os::unix::fs::PermissionsExt;
 use std::path::PathBuf;
 use std::process::Command;
 
-const REPO: &str = "cinco/Tmuxido";
+const REPO: &str = "cinco/tmuxido";
-const BASE_URL: &str = "https://git.cincoeuzebio.com";
+const BASE_URL: &str = "https://github.com";
+const API_BASE: &str = "https://api.github.com";
 
 /// Check if running from cargo (development mode)
 fn is_dev_build() -> bool {
@@ -26,12 +27,27 @@ fn detect_arch() -> Result<&'static str> {
     }
 }
 
-/// Fetch latest release tag from Gitea API
+/// Parse tag_name from a GitHub releases/latest JSON response
-fn fetch_latest_tag() -> Result<String> {
+fn parse_latest_tag(response: &str) -> Result<String> {
-    let url = format!("{}/api/v1/repos/{}/releases?limit=1&page=1", BASE_URL, REPO);
+    let tag: serde_json::Value =
+        serde_json::from_str(response).context("Failed to parse release API response")?;
+    tag.get("tag_name")
+        .and_then(|t| t.as_str())
+        .map(|t| t.to_string())
+        .ok_or_else(|| anyhow::anyhow!("Could not extract tag_name from release"))
+}
+
+/// Fetch latest release tag from GitHub API
+pub(crate) fn fetch_latest_tag() -> Result<String> {
+    let url = format!("{}/repos/{}/releases/latest", API_BASE, REPO);
 
     let output = Command::new("curl")
-        .args(["-fsSL", &url])
+        .args([
+            "-fsSL",
+            "-H",
+            "Accept: application/vnd.github.v3+json",
+            &url,
+        ])
         .output()
         .context("Failed to execute curl. Make sure curl is installed.")?;
 
@@ -42,17 +58,7 @@ fn fetch_latest_tag() -> Result<String> {
         ));
     }
 
-    let response = String::from_utf8_lossy(&output.stdout);
+    parse_latest_tag(&String::from_utf8_lossy(&output.stdout))
-
-    // Parse JSON response to extract tag_name
-    let tag: serde_json::Value =
-        serde_json::from_str(&response).context("Failed to parse release API response")?;
-
-    tag.get(0)
-        .and_then(|r| r.get("tag_name"))
-        .and_then(|t| t.as_str())
-        .map(|t| t.to_string())
-        .ok_or_else(|| anyhow::anyhow!("Could not extract tag_name from release"))
 }
 
 /// Get path to current executable
@@ -166,7 +172,7 @@ pub fn self_update() -> Result<()> {
 }
 
 /// Compare two semver versions
-fn version_compare(a: &str, b: &str) -> std::cmp::Ordering {
+pub(crate) fn version_compare(a: &str, b: &str) -> std::cmp::Ordering {
     let parse = |s: &str| {
         s.split('.')
             .filter_map(|n| n.parse::<u32>().ok())
@@ -211,6 +217,23 @@ mod tests {
         );
     }
 
+    #[test]
+    fn should_parse_tag_from_github_latest_release_response() {
+        let json = r#"{"tag_name":"0.7.0","name":"0.7.0","body":"release notes"}"#;
+        assert_eq!(parse_latest_tag(json).unwrap(), "0.7.0");
+    }
+
+    #[test]
+    fn should_return_error_when_tag_name_missing() {
+        let json = r#"{"name":"0.7.0","body":"no tag_name field"}"#;
+        assert!(parse_latest_tag(json).is_err());
+    }
+
+    #[test]
+    fn should_return_error_when_response_is_invalid_json() {
+        assert!(parse_latest_tag("not valid json").is_err());
+    }
+
     #[test]
     fn should_compare_versions_correctly() {
         assert_eq!(

src/update_check.rs

@@ -0,0 +1,219 @@
+use anyhow::Result;
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use crate::config::Config;
+use crate::self_update;
+
+#[derive(Debug, Default, Serialize, Deserialize)]
+struct UpdateCheckCache {
+    last_checked: u64,
+    latest_version: String,
+}
+
+pub fn check_and_notify(config: &Config) {
+    let cache = load_cache();
+    check_and_notify_internal(
+        config.update_check_interval_hours,
+        cache,
+        &|| self_update::fetch_latest_tag(),
+        &save_cache,
+    );
+}
+
+fn check_and_notify_internal(
+    interval_hours: u64,
+    mut cache: UpdateCheckCache,
+    fetcher: &dyn Fn() -> Result<String>,
+    saver: &dyn Fn(&UpdateCheckCache),
+) -> bool {
+    if interval_hours == 0 {
+        return false;
+    }
+
+    let elapsed = elapsed_hours(cache.last_checked);
+
+    if elapsed >= interval_hours
+        && let Ok(latest) = fetcher()
+    {
+        let latest_clean = latest.trim_start_matches('v').to_string();
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_secs();
+        cache.last_checked = now;
+        cache.latest_version = latest_clean;
+        saver(&cache);
+    }
+
+    let current = self_update::current_version();
+    let latest_clean = cache.latest_version.trim_start_matches('v');
+    if !latest_clean.is_empty()
+        && self_update::version_compare(latest_clean, current) == std::cmp::Ordering::Greater
+    {
+        print_update_notice(current, latest_clean);
+        return true;
+    }
+
+    false
+}
+
+fn print_update_notice(current: &str, latest: &str) {
+    let msg1 = format!("  Update available: {} \u{2192} {}  ", current, latest);
+    let msg2 = "  Run tmuxido --update to install.  ";
+    let w1 = msg1.chars().count();
+    let w2 = msg2.chars().count();
+    let width = w1.max(w2);
+    let border = "\u{2500}".repeat(width);
+    println!("\u{250c}{}\u{2510}", border);
+    println!("\u{2502}{}\u{2502}", pad_to_chars(&msg1, width));
+    println!("\u{2502}{}\u{2502}", pad_to_chars(msg2, width));
+    println!("\u{2514}{}\u{2518}", border);
+}
+
+fn pad_to_chars(s: &str, width: usize) -> String {
+    let char_count = s.chars().count();
+    if char_count >= width {
+        s.to_string()
+    } else {
+        format!("{}{}", s, " ".repeat(width - char_count))
+    }
+}
+
+fn cache_path() -> Result<PathBuf> {
+    let cache_dir = dirs::cache_dir()
+        .ok_or_else(|| anyhow::anyhow!("Could not determine cache directory"))?
+        .join("tmuxido");
+    Ok(cache_dir.join("update_check.json"))
+}
+
+fn load_cache() -> UpdateCheckCache {
+    cache_path()
+        .ok()
+        .and_then(|p| std::fs::read_to_string(p).ok())
+        .and_then(|s| serde_json::from_str(&s).ok())
+        .unwrap_or_default()
+}
+
+fn save_cache(cache: &UpdateCheckCache) {
+    if let Ok(path) = cache_path() {
+        if let Some(parent) = path.parent() {
+            let _ = std::fs::create_dir_all(parent);
+        }
+        if let Ok(json) = serde_json::to_string(cache) {
+            let _ = std::fs::write(path, json);
+        }
+    }
+}
+
+fn elapsed_hours(ts: u64) -> u64 {
+    let now = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_secs();
+    now.saturating_sub(ts) / 3600
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::cell::RefCell;
+
+    fn make_cache(last_checked: u64, latest_version: &str) -> UpdateCheckCache {
+        UpdateCheckCache {
+            last_checked,
+            latest_version: latest_version.to_string(),
+        }
+    }
+
+    fn now_ts() -> u64 {
+        SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_secs()
+    }
+
+    #[test]
+    fn should_not_notify_when_interval_is_zero() {
+        let cache = make_cache(0, "99.0.0");
+        let fetcher_called = RefCell::new(false);
+
+        let result = check_and_notify_internal(
+            0,
+            cache,
+            &|| {
+                *fetcher_called.borrow_mut() = true;
+                Ok("99.0.0".to_string())
+            },
+            &|_| {},
+        );
+
+        assert!(!result);
+        assert!(!fetcher_called.into_inner());
+    }
+
+    #[test]
+    fn should_not_check_when_interval_not_elapsed() {
+        let cache = make_cache(now_ts(), "");
+        let fetcher_called = RefCell::new(false);
+
+        check_and_notify_internal(
+            24,
+            cache,
+            &|| {
+                *fetcher_called.borrow_mut() = true;
+                Ok("99.0.0".to_string())
+            },
+            &|_| {},
+        );
+
+        assert!(!fetcher_called.into_inner());
+    }
+
+    #[test]
+    fn should_check_when_interval_elapsed() {
+        let cache = make_cache(0, "");
+        let fetcher_called = RefCell::new(false);
+
+        check_and_notify_internal(
+            1,
+            cache,
+            &|| {
+                *fetcher_called.borrow_mut() = true;
+                Ok(self_update::current_version().to_string())
+            },
+            &|_| {},
+        );
+
+        assert!(fetcher_called.into_inner());
+    }
+
+    #[test]
+    fn should_not_notify_when_versions_equal() {
+        let current = self_update::current_version();
+        let cache = make_cache(now_ts(), current);
+
+        let result = check_and_notify_internal(24, cache, &|| unreachable!(), &|_| {});
+
+        assert!(!result);
+    }
+
+    #[test]
+    fn should_detect_update_available() {
+        let cache = make_cache(now_ts(), "99.0.0");
+
+        let result = check_and_notify_internal(24, cache, &|| unreachable!(), &|_| {});
+
+        assert!(result);
+    }
+
+    #[test]
+    fn should_not_detect_update_when_current_is_newer() {
+        let cache = make_cache(now_ts(), "0.0.1");
+
+        let result = check_and_notify_internal(24, cache, &|| unreachable!(), &|_| {});
+
+        assert!(!result);
+    }
+}

tests/scan.rs

@@ -10,6 +10,7 @@ fn make_config(max_depth: usize) -> Config {
         max_depth,
         cache_enabled: true,
         cache_ttl_hours: 24,
+        update_check_interval_hours: 24,
         default_session: SessionConfig { windows: vec![] },
     }
 }