mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
Accept leading v prefixes during version checks, keep local metadata builds in dev mode unless they are clean exact release tags, and prevent cleanup warnings from leaking into JSON-mode stderr.
241 lines
5.2 KiB
Go
241 lines
5.2 KiB
Go
package version
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"skillshare/internal/config"
|
|
)
|
|
|
|
// Version is set by main.go at startup
|
|
var Version = "dev"
|
|
|
|
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
|
|
InstallMethod InstallMethod
|
|
}
|
|
|
|
// getCachePath returns the path to the cache file
|
|
func getCachePath() string {
|
|
return filepath.Join(config.CacheDir(), cacheFileName)
|
|
}
|
|
|
|
// 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() {
|
|
os.Remove(getCachePath())
|
|
}
|
|
|
|
// GetCachedVersion returns the cached latest version if available
|
|
func GetCachedVersion() string {
|
|
cache, err := loadCache()
|
|
if err != nil || cache == nil {
|
|
return ""
|
|
}
|
|
return cache.LatestVersion
|
|
}
|
|
|
|
// loadCache loads the version check cache from disk
|
|
func loadCache() (*Cache, error) {
|
|
data, err := os.ReadFile(getCachePath())
|
|
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 := getCachePath()
|
|
|
|
// 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)
|
|
}
|
|
|
|
// compareVersions returns true if v1 < v2.
|
|
func compareVersions(v1, v2 string) (bool, error) {
|
|
if v1 == "dev" || v1 == "" {
|
|
return false, nil // Don't prompt for dev builds
|
|
}
|
|
|
|
parts1, err := parseVersionParts(v1)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
parts2, err := parseVersionParts(v2)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
// 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 = parts1[i]
|
|
}
|
|
if i < len(parts2) {
|
|
n2 = parts2[i]
|
|
}
|
|
|
|
if n1 < n2 {
|
|
return true, nil // v1 < v2
|
|
}
|
|
if n1 > n2 {
|
|
return false, nil // v1 > v2
|
|
}
|
|
}
|
|
|
|
return false, nil // v1 == v2
|
|
}
|
|
|
|
func parseVersionParts(ver string) ([]int, error) {
|
|
normalized := strings.TrimPrefix(ver, "v")
|
|
rawParts := strings.Split(normalized, ".")
|
|
parts := make([]int, len(rawParts))
|
|
for i, part := range rawParts {
|
|
n, err := strconv.Atoi(part)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("non-numeric version segment %q in %q", part, ver)
|
|
}
|
|
parts[i] = n
|
|
}
|
|
return parts, nil
|
|
}
|
|
|
|
// Check checks if a new version is available.
|
|
// method determines where to look: InstallBrew queries Homebrew,
|
|
// InstallDirect queries the GitHub Release API.
|
|
// Returns nil if no check is needed or if there's no update.
|
|
func Check(currentVersion string, method InstallMethod) *CheckResult {
|
|
// Don't check for dev builds
|
|
if currentVersion == "dev" || currentVersion == "" {
|
|
return nil
|
|
}
|
|
if _, err := parseVersionParts(currentVersion); err != nil {
|
|
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 != "" {
|
|
currentOlderThanCached, err := compareVersions(currentVersion, cache.LatestVersion)
|
|
if err != nil {
|
|
ClearCache()
|
|
cache = nil
|
|
} else if !currentOlderThanCached {
|
|
ClearCache()
|
|
cache = nil
|
|
}
|
|
}
|
|
|
|
// Check if we need to fetch
|
|
needsFetch := cache == nil || time.Since(cache.LastChecked) > checkInterval
|
|
|
|
if needsFetch {
|
|
var latestVersion string
|
|
var err error
|
|
|
|
switch method {
|
|
case InstallBrew:
|
|
latestVersion, err = FetchBrewLatestVersion()
|
|
default:
|
|
latestVersion, err = FetchLatestVersionOnly()
|
|
}
|
|
|
|
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
|
|
updateAvailable, err := compareVersions(currentVersion, cache.LatestVersion)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
if updateAvailable {
|
|
return &CheckResult{
|
|
CurrentVersion: currentVersion,
|
|
LatestVersion: cache.LatestVersion,
|
|
UpdateAvailable: true,
|
|
InstallMethod: method,
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|