saorsa-gossip 0.1.14

CLI tool for Saorsa Gossip network - demonstration and testing
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

//! Self-update functionality for Saorsa Gossip CLI
//!
//! Provides automatic update checking and installation from GitHub releases.

use anyhow::{Context, Result};
use std::time::Duration;

const REPO_OWNER: &str = "dirvine";
const REPO_NAME: &str = "saorsa-gossip";
const BIN_NAME: &str = "saorsa-gossip";

/// Check for updates and return the latest version if newer than current
pub async fn check_for_update() -> Result<Option<String>> {
    let current_version = env!("CARGO_PKG_VERSION");

    tracing::debug!("Current version: {}", current_version);
    tracing::debug!("Checking for updates from GitHub releases...");

    match self_update::backends::github::Update::configure()
        .repo_owner(REPO_OWNER)
        .repo_name(REPO_NAME)
        .bin_name(BIN_NAME)
        .current_version(current_version)
        .build()
    {
        Ok(updater) => match updater.get_latest_release() {
            Ok(release) => {
                if release.version.as_str() > current_version {
                    tracing::info!(
                        "New version available: {} (current: {})",
                        release.version,
                        current_version
                    );
                    Ok(Some(release.version))
                } else {
                    tracing::debug!("Already on latest version: {}", current_version);
                    Ok(None)
                }
            }
            Err(e) => {
                tracing::warn!("Failed to check for updates: {}", e);
                Ok(None)
            }
        },
        Err(e) => {
            tracing::warn!("Failed to build updater: {}", e);
            Ok(None)
        }
    }
}

/// Perform the update to the latest version
pub async fn perform_update() -> Result<()> {
    let current_version = env!("CARGO_PKG_VERSION");

    println!("🔍 Checking for updates...");
    println!("   Current version: {}", current_version);

    let status = self_update::backends::github::Update::configure()
        .repo_owner(REPO_OWNER)
        .repo_name(REPO_NAME)
        .bin_name(BIN_NAME)
        .current_version(current_version)
        .build()
        .context("Failed to build updater")?
        .update()
        .context("Failed to perform update")?;

    match status {
        self_update::Status::UpToDate(version) => {
            println!("✓ Already up to date (version: {})", version);
        }
        self_update::Status::Updated(version) => {
            println!("✓ Successfully updated to version: {}", version);
            println!("  Please restart the application to use the new version.");
        }
    }

    Ok(())
}

/// Background update checker that checks every 6 hours
#[allow(dead_code)]
pub async fn start_background_checker() {
    tokio::spawn(async {
        let check_interval = Duration::from_secs(6 * 60 * 60); // 6 hours

        loop {
            tokio::time::sleep(check_interval).await;

            if let Ok(Some(new_version)) = check_for_update().await {
                tracing::info!(
                    "Update available: {} - run 'saorsa-gossip update' to upgrade",
                    new_version
                );
                println!(
                    "\n🔔 Update available: {} - run 'saorsa-gossip update' to upgrade\n",
                    new_version
                );
            }
        }
    });
}

/// Check if we should show update notification (rate-limited)
pub async fn should_check_update(config_dir: &std::path::Path) -> bool {
    let last_check_file = config_dir.join(".last_update_check");

    if let Ok(metadata) = tokio::fs::metadata(&last_check_file).await {
        if let Ok(modified) = metadata.modified() {
            if let Ok(elapsed) = modified.elapsed() {
                // Only check every 6 hours
                if elapsed < Duration::from_secs(6 * 60 * 60) {
                    return false;
                }
            }
        }
    }

    // Update last check time
    tokio::fs::write(&last_check_file, b"").await.is_ok()
}

/// Perform a silent update check and notify if available (non-blocking)
pub async fn silent_update_check(config_dir: &std::path::Path) {
    if !should_check_update(config_dir).await {
        return;
    }

    if let Ok(Some(new_version)) = check_for_update().await {
        println!(
            "\n🔔 Update available: {} - run 'saorsa-gossip update' to upgrade\n",
            new_version
        );
    }
}