mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
Move version-check.json from ~/.skillshare/ to ~/.cache/skillshare/ to align with XDG Base Directory Specification. Add support for XDG_CACHE_HOME environment variable. Auto-cleanup legacy cache location on first run.
238 lines
5.2 KiB
Go
238 lines
5.2 KiB
Go
package version
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
const (
|
|
githubRepo = "runkids/skillshare"
|
|
checkInterval = 24 * time.Hour
|
|
cacheFileName = "version-check.json"
|
|
)
|
|
|
|
// Cache holds version check cache data
|
|
type Cache struct {
|
|
LastChecked time.Time `json:"last_checked"`
|
|
LatestVersion string `json:"latest_version"`
|
|
}
|
|
|
|
// CheckResult holds the result of a version check
|
|
type CheckResult struct {
|
|
CurrentVersion string
|
|
LatestVersion string
|
|
UpdateAvailable bool
|
|
}
|
|
|
|
// getCacheDir returns the cache directory, respecting XDG_CACHE_HOME
|
|
func getCacheDir() (string, error) {
|
|
// XDG Base Directory Specification: use XDG_CACHE_HOME if set
|
|
if cacheHome := os.Getenv("XDG_CACHE_HOME"); cacheHome != "" {
|
|
return filepath.Join(cacheHome, "skillshare"), nil
|
|
}
|
|
// Default: ~/.cache/skillshare
|
|
homeDir, err := os.UserHomeDir()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return filepath.Join(homeDir, ".cache", "skillshare"), nil
|
|
}
|
|
|
|
// getCachePath returns the path to the cache file
|
|
func getCachePath() (string, error) {
|
|
cacheDir, err := getCacheDir()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return filepath.Join(cacheDir, cacheFileName), nil
|
|
}
|
|
|
|
// legacyCachePath returns the old cache path for migration cleanup
|
|
func legacyCachePath() string {
|
|
homeDir, _ := os.UserHomeDir()
|
|
return filepath.Join(homeDir, ".skillshare", cacheFileName)
|
|
}
|
|
|
|
// cleanupLegacyCache removes cache from old location
|
|
func cleanupLegacyCache() {
|
|
legacyPath := legacyCachePath()
|
|
if _, err := os.Stat(legacyPath); err == nil {
|
|
os.Remove(legacyPath)
|
|
// Try to remove parent dir if empty
|
|
parentDir := filepath.Dir(legacyPath)
|
|
os.Remove(parentDir) // Fails silently if not empty
|
|
}
|
|
}
|
|
|
|
// ClearCache removes the version check cache file
|
|
func ClearCache() {
|
|
cachePath, err := getCachePath()
|
|
if err != nil {
|
|
return
|
|
}
|
|
os.Remove(cachePath)
|
|
}
|
|
|
|
// loadCache loads the version check cache from disk
|
|
func loadCache() (*Cache, error) {
|
|
cachePath, err := getCachePath()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
data, err := os.ReadFile(cachePath)
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
return nil, nil // No cache yet
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
var cache Cache
|
|
if err := json.Unmarshal(data, &cache); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &cache, nil
|
|
}
|
|
|
|
// saveCache saves the version check cache to disk
|
|
func saveCache(cache *Cache) error {
|
|
cachePath, err := getCachePath()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Ensure directory exists
|
|
if err := os.MkdirAll(filepath.Dir(cachePath), 0755); err != nil {
|
|
return err
|
|
}
|
|
|
|
data, err := json.Marshal(cache)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
return os.WriteFile(cachePath, data, 0644)
|
|
}
|
|
|
|
// fetchLatestVersion fetches the latest version from GitHub
|
|
func fetchLatestVersion() (string, error) {
|
|
url := fmt.Sprintf("https://api.github.com/repos/%s/releases/latest", githubRepo)
|
|
|
|
client := &http.Client{Timeout: 5 * time.Second}
|
|
resp, err := client.Get(url)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode != 200 {
|
|
return "", fmt.Errorf("GitHub API returned %d", resp.StatusCode)
|
|
}
|
|
|
|
var release struct {
|
|
TagName string `json:"tag_name"`
|
|
}
|
|
if err := json.NewDecoder(resp.Body).Decode(&release); err != nil {
|
|
return "", err
|
|
}
|
|
|
|
return strings.TrimPrefix(release.TagName, "v"), nil
|
|
}
|
|
|
|
// compareVersions returns true if v1 < v2 (proper semver comparison)
|
|
func compareVersions(v1, v2 string) bool {
|
|
if v1 == "dev" || v1 == "" {
|
|
return false // Don't prompt for dev builds
|
|
}
|
|
|
|
parts1 := strings.Split(v1, ".")
|
|
parts2 := strings.Split(v2, ".")
|
|
|
|
// Compare each part numerically
|
|
maxLen := len(parts1)
|
|
if len(parts2) > maxLen {
|
|
maxLen = len(parts2)
|
|
}
|
|
|
|
for i := 0; i < maxLen; i++ {
|
|
var n1, n2 int
|
|
if i < len(parts1) {
|
|
n1, _ = strconv.Atoi(parts1[i])
|
|
}
|
|
if i < len(parts2) {
|
|
n2, _ = strconv.Atoi(parts2[i])
|
|
}
|
|
|
|
if n1 < n2 {
|
|
return true // v1 < v2
|
|
}
|
|
if n1 > n2 {
|
|
return false // v1 > v2
|
|
}
|
|
}
|
|
|
|
return false // v1 == v2
|
|
}
|
|
|
|
// Check checks if a new version is available
|
|
// Returns nil if no check is needed or if there's no update
|
|
func Check(currentVersion string) *CheckResult {
|
|
// Don't check for dev builds
|
|
if currentVersion == "dev" || currentVersion == "" {
|
|
return nil
|
|
}
|
|
|
|
// Clean up legacy cache location (~/.skillshare/)
|
|
cleanupLegacyCache()
|
|
|
|
cache, _ := loadCache()
|
|
|
|
// If current version >= cached latest, clear stale cache (user may have manually updated)
|
|
if cache != nil && cache.LatestVersion != "" && !compareVersions(currentVersion, cache.LatestVersion) {
|
|
ClearCache()
|
|
cache = nil
|
|
}
|
|
|
|
// Check if we need to fetch
|
|
needsFetch := cache == nil || time.Since(cache.LastChecked) > checkInterval
|
|
|
|
if needsFetch {
|
|
// Fetch in foreground but with short timeout
|
|
latestVersion, err := fetchLatestVersion()
|
|
if err != nil {
|
|
// Silently fail - don't bother user with network errors
|
|
return nil
|
|
}
|
|
|
|
// Update cache
|
|
cache = &Cache{
|
|
LastChecked: time.Now(),
|
|
LatestVersion: latestVersion,
|
|
}
|
|
_ = saveCache(cache) // Ignore save errors
|
|
}
|
|
|
|
if cache == nil || cache.LatestVersion == "" {
|
|
return nil
|
|
}
|
|
|
|
// Compare versions
|
|
if compareVersions(currentVersion, cache.LatestVersion) {
|
|
return &CheckResult{
|
|
CurrentVersion: currentVersion,
|
|
LatestVersion: cache.LatestVersion,
|
|
UpdateAvailable: true,
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|