Installierte Package Version wird ab jetzt erfasst.

cmd/ginie/main.go

@@ -1,82 +1,100 @@
 package main
 
 import (
-    "fmt"
+	"fmt"
-    "os"
+	"os"
-
-    "gitea.home.musaberdem.de/musabe24/ginie/internal/repos"
-    "gitea.home.musaberdem.de/musabe24/ginie/internal/version"
-    "gitea.home.musaberdem.de/musabe24/ginie/internal/install"
 
+	"gitea.home.musaberdem.de/musabe24/ginie/internal/install"
+	"gitea.home.musaberdem.de/musabe24/ginie/internal/repos"
+	"gitea.home.musaberdem.de/musabe24/ginie/internal/version"
 )
 
 func main() {
-    if len(os.Args) < 2 {
+	if len(os.Args) < 2 {
-        fmt.Println("Ginie – Git Native Installer Engine")
+		fmt.Println("Ginie – Git Native Installer Engine")
-        fmt.Println("Usage: ginie <command> [arguments]")
+		fmt.Println("Usage: ginie <command> [arguments]")
-        return
-    }
-
-    cmd := os.Args[1]
-
-    switch cmd {
-
-    case "--version", "-v":
-        fmt.Println("ginie version", version.Version)
-        return
-
-    case "add":
-        if len(os.Args) < 3 {
-            fmt.Println("Usage: ginie add <GitHub-URL>")
-            return
-        }
-        url := os.Args[2]
-
-        err := repos.AddRepo(url)
-        if err != nil {
-            fmt.Println("Fehler:", err)
-            return
-        }
-
-        fmt.Println("Repo hinzugefügt:", url)
-        return
-
-    case "list":
-        reposList, err := repos.ListRepos()
-        if err != nil {
-            fmt.Println("Fehler beim Laden:", err)
-            return
-        }
-
-        if len(reposList) == 0 {
-            fmt.Println("Noch keine Repositories hinzugefügt. Nutze:")
-            fmt.Println("  ginie add <GitHub-URL>")
-            return
-        }
-
-        fmt.Println("Registrierte Repositories:")
-        for _, r := range reposList {
-            fmt.Printf("- %s/%s (%s)\n", r.Owner, r.Name, r.URL)
-        }
-        return
-        
-    case "install":
-	    if len(os.Args) < 3 {
-		fmt.Println("Usage: ginie install <name[:version]>")
 		return
-	    }
+	}
-	    target := os.Args[2]
 
-	    err := install.Install(target)
+	cmd := os.Args[1]
-	    if err != nil {
+
-		fmt.Println("Fehler:", err)
+	switch cmd {
+
+	case "--version", "-v":
+		fmt.Println("ginie version", version.Version)
 		return
-	    }
-	    return
 
+	case "add":
+		if len(os.Args) < 3 {
+			fmt.Println("Usage: ginie add <GitHub-URL>")
+			return
+		}
+		url := os.Args[2]
 
-    default:
+		err := repos.AddRepo(url)
-        fmt.Println("Unbekannter Befehl:", cmd)
+		if err != nil {
-        return
+			fmt.Println("Fehler:", err)
-    }
+			return
+		}
+
+		fmt.Println("Repo hinzugefügt:", url)
+		return
+
+	case "remove":
+		if len(os.Args) < 3 {
+			fmt.Println("Usage: ginie remove <GitHub-URL>")
+			return
+		}
+		url := os.Args[2]
+
+		err := repos.RemoveRepo(url)
+		if err != nil {
+			fmt.Println("Fehler:", err)
+			return
+		}
+
+		fmt.Println("Repo entfernt:", url)
+		return
+
+	case "list":
+		reposList, err := repos.ListRepos()
+		if err != nil {
+			fmt.Println("Fehler beim Laden:", err)
+			return
+		}
+
+		if len(reposList) == 0 {
+			fmt.Println("Noch keine Repositories hinzugefügt. Nutze:")
+			fmt.Println("  ginie add <GitHub-URL>")
+			return
+		}
+
+		fmt.Println("Registrierte Repositories:")
+		for _, r := range reposList {
+			version := r.InstalledVersion
+			if version == "" {
+				version = "nicht installiert"
+			}
+			fmt.Printf("- %s/%s (%s) – Version: %s\n", r.Owner, r.Name, r.URL, version)
+		}
+		return
+
+	case "install":
+		if len(os.Args) < 3 {
+			fmt.Println("Usage: ginie install <name[:version]>")
+			return
+		}
+		target := os.Args[2]
+
+		err := install.Install(target)
+		if err != nil {
+			fmt.Println("Fehler:", err)
+			return
+		}
+		return
+
+	default:
+		fmt.Println("Unbekannter Befehl:", cmd)
+		return
+	}
 }

internal/install/install.go

@@ -1,183 +1,196 @@
 package install
 
 import (
-    "encoding/json"
+	"encoding/json"
-    "errors"
+	"errors"
-    "fmt"
+	"fmt"
-    "io"
+	"io"
-    "net/http"
+	"net/http"
-    "os"
+	"os"
-    "os/exec"
+	"os/exec"
-    "path/filepath"
+	"path/filepath"
-    "strings"
+	"strings"
 
-    "gitea.home.musaberdem.de/musabe24/ginie/internal/repos"
+	"gitea.home.musaberdem.de/musabe24/ginie/internal/repos"
 )
 
 type Installed struct {
-    Name      string `json:"name"`
+	Name      string `json:"name"`
-    Version   string `json:"version"`
+	Version   string `json:"version"`
-    AssetName string `json:"asset"`
+	AssetName string `json:"asset"`
-    AssetURL  string `json:"url"`
+	AssetURL  string `json:"url"`
 }
 
 func configPath() (string, error) {
-    home, err := os.UserHomeDir()
+	home, err := os.UserHomeDir()
-    if err != nil {
+	if err != nil {
-        return "", err
+		return "", err
-    }
+	}
 
-    dir := filepath.Join(home, ".config", "ginie")
+	dir := filepath.Join(home, ".config", "ginie")
-    os.MkdirAll(dir, 0755)
+	os.MkdirAll(dir, 0755)
 
-    return filepath.Join(dir, "installed.json"), nil
+	return filepath.Join(dir, "installed.json"), nil
 }
 
 func LoadInstalled() ([]Installed, error) {
-    path, _ := configPath()
+	path, _ := configPath()
-    data, err := os.ReadFile(path)
+	data, err := os.ReadFile(path)
 
-    if os.IsNotExist(err) {
+	if os.IsNotExist(err) {
-        return []Installed{}, nil
+		return []Installed{}, nil
-    }
+	}
-    if err != nil {
+	if err != nil {
-        return nil, err
+		return nil, err
-    }
+	}
 
-    var out []Installed
+	var out []Installed
-    err = json.Unmarshal(data, &out)
+	err = json.Unmarshal(data, &out)
-    return out, err
+	return out, err
 }
 
 func SaveInstalled(list []Installed) error {
-    path, _ := configPath()
+	path, _ := configPath()
-    data, err := json.MarshalIndent(list, "", "  ")
+	data, err := json.MarshalIndent(list, "", "  ")
-    if err != nil {
+	if err != nil {
-        return err
+		return err
-    }
+	}
-    return os.WriteFile(path, data, 0644)
+	return os.WriteFile(path, data, 0644)
 }
 
 func parseNameVersion(input string) (name string, version string) {
-    parts := strings.Split(input, ":")
+	parts := strings.Split(input, ":")
-    if len(parts) == 1 {
+	if len(parts) == 1 {
-        return parts[0], "" // keine Version
+		return parts[0], "" // keine Version
-    }
+	}
-    return parts[0], parts[1]
+	return parts[0], parts[1]
 }
 
 func Install(pkg string) error {
-    name, version := parseNameVersion(pkg)
+	name, version := parseNameVersion(pkg)
 
-    // Repo suchen
+	// Repo suchen
-    all, err := repos.LoadRepos()
+	all, err := repos.LoadRepos()
-    if err != nil {
+	if err != nil {
-        return err
+		return err
-    }
+	}
 
-    var repo repos.Repo
+	var repo repos.Repo
-    found := false
+	found := false
-    for _, r := range all {
+	for _, r := range all {
-        if r.Name == name {
+		if r.Name == name {
-            repo = r
+			repo = r
-            found = true
+			found = true
-            break
+			break
-        }
+		}
-    }
+	}
-    if !found {
+	if !found {
-        return errors.New("Repo nicht gefunden. Nutze: ginie add <URL>")
+		return errors.New("Repo nicht gefunden. Nutze: ginie add <URL>")
-    }
+	}
 
-    // Release-API-URL
+	// Release-API-URL
-    api := ""
+	api := ""
-    if version == "" {
+	if version == "" {
-        api = fmt.Sprintf("https://api.github.com/repos/%s/%s/releases/latest", repo.Owner, repo.Name)
+		api = fmt.Sprintf("https://api.github.com/repos/%s/%s/releases/latest", repo.Owner, repo.Name)
-    } else {
+	} else {
-        api = fmt.Sprintf("https://api.github.com/repos/%s/%s/releases/tags/%s", repo.Owner, repo.Name, version)
+		api = fmt.Sprintf("https://api.github.com/repos/%s/%s/releases/tags/%s", repo.Owner, repo.Name, version)
-    }
+	}
 
-    // API abfragen
+	// API abfragen
-    resp, err := http.Get(api)
+	resp, err := http.Get(api)
-    if err != nil {
+	if err != nil {
-        return err
+		return err
-    }
+	}
-    defer resp.Body.Close()
+	defer resp.Body.Close()
 
-    if resp.StatusCode != 200 {
+	if resp.StatusCode != 200 {
-        return fmt.Errorf("GitHub API Fehler: %s", resp.Status)
+		return fmt.Errorf("GitHub API Fehler: %s", resp.Status)
-    }
+	}
 
-    var release struct {
+	var release struct {
-        TagName string `json:"tag_name"`
+		TagName string `json:"tag_name"`
-        Assets  []struct {
+		Assets  []struct {
-            Name        string `json:"name"`
+			Name               string `json:"name"`
-            BrowserDownloadURL string `json:"browser_download_url"`
+			BrowserDownloadURL string `json:"browser_download_url"`
-        } `json:"assets"`
+		} `json:"assets"`
-    }
+	}
 
-    if err := json.NewDecoder(resp.Body).Decode(&release); err != nil {
+	if err := json.NewDecoder(resp.Body).Decode(&release); err != nil {
-        return err
+		return err
-    }
+	}
 
-    if len(release.Assets) == 0 {
+	if len(release.Assets) == 0 {
-        return errors.New("Release hat keine Assets")
+		return errors.New("Release hat keine Assets")
-    }
+	}
 
-    // Asset-Auswahl
+	installedVersion := release.TagName
-    fmt.Println("Verfügbare Assets:")
+	if installedVersion == "" {
-    for i, a := range release.Assets {
+		installedVersion = version
-        fmt.Printf("[%d] %s\n", i, a.Name)
+	}
-    }
 
-    fmt.Print("Wähle Asset-Nummer: ")
+	// Asset-Auswahl
-    var choice int
+	fmt.Println("Verfügbare Assets:")
-    fmt.Scan(&choice)
+	for i, a := range release.Assets {
+		fmt.Printf("[%d] %s\n", i, a.Name)
+	}
 
-    if choice < 0 || choice >= len(release.Assets) {
+	fmt.Print("Wähle Asset-Nummer: ")
-        return errors.New("Ungültige Auswahl")
+	var choice int
-    }
+	fmt.Scan(&choice)
 
-    asset := release.Assets[choice]
+	if choice < 0 || choice >= len(release.Assets) {
+		return errors.New("Ungültige Auswahl")
+	}
 
-    // Datei herunterladen
+	asset := release.Assets[choice]
-    fmt.Println("Lade herunter:", asset.Name)
 
-    out, err := os.Create(asset.Name)
+	// Datei herunterladen
-    if err != nil {
+	fmt.Println("Lade herunter:", asset.Name)
-        return err
-    }
-    defer out.Close()
 
-    dl, err := http.Get(asset.BrowserDownloadURL)
+	out, err := os.Create(asset.Name)
-    if err != nil {
+	if err != nil {
-        return err
+		return err
-    }
+	}
-    defer dl.Body.Close()
+	defer out.Close()
 
-    _, err = io.Copy(out, dl.Body)
+	dl, err := http.Get(asset.BrowserDownloadURL)
-    if err != nil {
+	if err != nil {
-        return err
+		return err
-    }
+	}
+	defer dl.Body.Close()
 
-    fmt.Println("Download abgeschlossen.")
+	_, err = io.Copy(out, dl.Body)
+	if err != nil {
+		return err
+	}
 
-    // Installation (unterstützt .deb)
+	fmt.Println("Download abgeschlossen.")
-    if strings.HasSuffix(asset.Name, ".deb") {
-        fmt.Println("Installiere .deb Datei…")
-        cmd := exec.Command("sudo", "dpkg", "-i", asset.Name)
-        cmd.Stdout = os.Stdout
-        cmd.Stderr = os.Stderr
-        err := cmd.Run()
-        if err != nil {
-            fmt.Println("Package konnte nicht installiert werden.")
-        }
-        err = os.Remove(asset.Name)
-        if err != nil {
-            fmt.Println("Package konnte nicht gelöscht werden.")
-        }
-        return err
-    }
 
-    return errors.New("Asset-Typ wird noch nicht unterstützt")
+	// Installation (unterstützt .deb)
+	if strings.HasSuffix(asset.Name, ".deb") {
+		fmt.Println("Installiere .deb Datei…")
+		cmd := exec.Command("sudo", "dpkg", "-i", asset.Name)
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		// Run the install command
+		err := cmd.Run()
+		if err != nil {
+			fmt.Println("Package konnte nicht installiert werden.")
+		}
+		// Remove debian package file
+		err = os.Remove(asset.Name)
+		if err != nil {
+			fmt.Println("Package konnte nicht gelöscht werden.")
+		}
+		if installedVersion == "" {
+			installedVersion = "unknown"
+		}
+		if err := repos.SetInstalledVersion(repo.Name, installedVersion); err != nil {
+			fmt.Println("Speichern der installierten Version nicht möglich.")
+			return err
+		}
+		return nil
+	}
+
+	return errors.New("Asset-Typ wird noch nicht unterstützt")
 }
-

internal/repos/repos.go

@@ -1,108 +1,154 @@
 package repos
 
 import (
-    "encoding/json"
+	"encoding/json"
-    "errors"
+	"errors"
-    "os"
+	"os"
-    "path/filepath"
+	"path/filepath"
-    "strings"
+	"strings"
 )
 
 type Repo struct {
-    URL   string `json:"url"`
+	URL              string `json:"url"`
-    Owner string `json:"owner"`
+	Owner            string `json:"owner"`
-    Name  string `json:"name"`
+	Name             string `json:"name"`
+	InstalledVersion string `json:"installed_version,omitempty"`
 }
 
 func configPath() (string, error) {
-    home, err := os.UserHomeDir()
+	home, err := os.UserHomeDir()
-    if err != nil {
+	if err != nil {
-        return "", err
+		return "", err
-    }
+	}
 
-    dir := filepath.Join(home, ".config", "ginie")
+	dir := filepath.Join(home, ".config", "ginie")
-    os.MkdirAll(dir, 0755)
+	os.MkdirAll(dir, 0755)
 
-    return filepath.Join(dir, "repos.json"), nil
+	return filepath.Join(dir, "repos.json"), nil
 }
 
 func LoadRepos() ([]Repo, error) {
-    path, err := configPath()
+	path, err := configPath()
-    if err != nil {
+	if err != nil {
-        return nil, err
+		return nil, err
-    }
+	}
 
-    data, err := os.ReadFile(path)
+	data, err := os.ReadFile(path)
-    if os.IsNotExist(err) {
+	if os.IsNotExist(err) {
-        return []Repo{}, nil
+		return []Repo{}, nil
-    }
+	}
-    if err != nil {
+	if err != nil {
-        return nil, err
+		return nil, err
-    }
+	}
 
-    var repos []Repo
+	var repos []Repo
-    err = json.Unmarshal(data, &repos)
+	err = json.Unmarshal(data, &repos)
-    if err != nil {
+	if err != nil {
-        return nil, err
+		return nil, err
-    }
+	}
 
-    return repos, nil
+	return repos, nil
 }
 
 func SaveRepos(repos []Repo) error {
-    path, err := configPath()
+	path, err := configPath()
-    if err != nil {
+	if err != nil {
-        return err
+		return err
-    }
+	}
 
-    data, err := json.MarshalIndent(repos, "", "  ")
+	data, err := json.MarshalIndent(repos, "", "  ")
-    if err != nil {
+	if err != nil {
-        return err
+		return err
-    }
+	}
 
-    return os.WriteFile(path, data, 0644)
+	return os.WriteFile(path, data, 0644)
 }
 
 func ParseGitHubURL(raw string) (Repo, error) {
-    if !strings.HasPrefix(raw, "https://github.com/") {
+	if !strings.HasPrefix(raw, "https://github.com/") {
-        return Repo{}, errors.New("URL ist kein gültiger GitHub-Link")
+		return Repo{}, errors.New("URL ist kein gültiger GitHub-Link")
-    }
+	}
 
-    parts := strings.Split(strings.TrimPrefix(raw, "https://github.com/"), "/")
+	parts := strings.Split(strings.TrimPrefix(raw, "https://github.com/"), "/")
-    if len(parts) < 2 {
+	if len(parts) < 2 {
-        return Repo{}, errors.New("GitHub-Link hat nicht das Format: https://github.com/<owner>/<repo>")
+		return Repo{}, errors.New("GitHub-Link hat nicht das Format: https://github.com/<owner>/<repo>")
-    }
+	}
 
-    return Repo{
+	return Repo{
-        URL:   raw,
+		URL:   raw,
-        Owner: parts[0],
+		Owner: parts[0],
-        Name:  parts[1],
+		Name:  parts[1],
-    }, nil
+	}, nil
 }
 
 func AddRepo(url string) error {
-    repo, err := ParseGitHubURL(url)
+	repo, err := ParseGitHubURL(url)
-    if err != nil {
+	if err != nil {
-        return err
+		return err
-    }
+	}
 
-    repos, err := LoadRepos()
+	repos, err := LoadRepos()
-    if err != nil {
+	if err != nil {
-        return err
+		return err
-    }
+	}
 
-    // prüfen ob bereits vorhanden
+	// prüfen ob bereits vorhanden
-    for _, r := range repos {
+	for _, r := range repos {
-        if r.URL == repo.URL {
+		if r.URL == repo.URL {
-            return errors.New("Repo existiert bereits")
+			return errors.New("Repo existiert bereits")
-        }
+		}
-    }
+	}
 
-    repos = append(repos, repo)
+	repos = append(repos, repo)
 
-    return SaveRepos(repos)
+	return SaveRepos(repos)
+}
+
+func RemoveRepo(url string) error {
+	repos, err := LoadRepos()
+	if err != nil {
+		return err
+	}
+
+	index := -1
+	for i, r := range repos {
+		if r.URL == url {
+			index = i
+			break
+		}
+	}
+
+	if index == -1 {
+		return errors.New("Repo nicht gefunden")
+	}
+
+	repos = append(repos[:index], repos[index+1:]...)
+
+	return SaveRepos(repos)
 }
 
 func ListRepos() ([]Repo, error) {
-    return LoadRepos()
+	return LoadRepos()
+}
+
+func SetInstalledVersion(name string, version string) error {
+	repos, err := LoadRepos()
+	if err != nil {
+		return err
+	}
+
+	updated := false
+	for i := range repos {
+		if repos[i].Name == name {
+			repos[i].InstalledVersion = version
+			updated = true
+			break
+		}
+	}
+
+	if !updated {
+		return errors.New("Repo nicht gefunden")
+	}
+
+	return SaveRepos(repos)
 }