Исправлена проблема с перемещением готового пакета из временной дирректории сборки (в случае зависимости)

Исправление работы с мультипакетами

.gitea/workflows/release.yaml

@@ -78,12 +78,31 @@ jobs:
           token: ${{ secrets.GITEAPUBLIC }}
           path: alr-default
 
-      - name: Update version in alr-bin
+      - name: Calculate checksum
         run: |
-          # Замените значения в файле с конфигурацией
+          # Вычисляем SHA256 контрольную сумму архива
+          CHECKSUM=$(sha256sum alr-${{ env.VERSION }}-linux-x86_64.tar.gz | awk '{print $1}')
+          echo "Archive checksum: $CHECKSUM"
+          echo "CHECKSUM=$CHECKSUM" >> $GITHUB_ENV
+
+      - name: Update version and checksum in alr-bin
+        run: |
+          # Обновляем версию
           sed -i "s/version='[0-9]\+\.[0-9]\+\.[0-9]\+'/version='${{ env.VERSION }}'/g" alr-default/alr-bin/alr.sh
           sed -i "s/release='[0-9]\+'/release='1'/g" alr-default/alr-bin/alr.sh
 
+          # Обновляем контрольную сумму
+          sed -i "s/checksums=('[^']*')/checksums=('${{ env.CHECKSUM }}')/g" alr-default/alr-bin/alr.sh
+
+      - name: Commit and push changes to alr-default
+        run: |
+          cd alr-default
+          git config user.name "gitea"
+          git config user.email "admin@plemya-x.ru"
+          git add alr-bin/alr.sh
+          git commit -m "Обновление alr-bin до версии ${{ env.VERSION }}"
+          git push
+
       - name: Install alr
         env:
           CREATE_SYSTEM_RESOURCES: 0

build.go

@@ -63,7 +63,7 @@ func BuildCmd() *cli.Command {
 			},
 		},
 		Action: func(c *cli.Context) error {
-			if err := utils.EnuseIsPrivilegedGroupMember(); err != nil {
+			if err := utils.CheckUserPrivileges(); err != nil {
 				return err
 			}
 
@@ -197,6 +197,13 @@ func BuildCmd() *cli.Command {
 
 			for _, pkg := range res {
 				name := filepath.Base(pkg.Path)
+
+				// Проверяем, существует ли файл перед перемещением
+				if _, err := os.Stat(pkg.Path); os.IsNotExist(err) {
+					slog.Info("Package file already moved or removed, skipping", "path", pkg.Path)
+					continue
+				}
+
 				err = osutils.Move(pkg.Path, filepath.Join(wd, name))
 				if err != nil {
 					return cliutils.FormatCliExit(gotext.Get("Error moving the package"), err)

config.go

@@ -76,6 +76,7 @@ var configKeys = []string{
 	"autoPull",
 	"logLevel",
 	"ignorePkgUpdates",
+	"updateSystemOnUpgrade",
 }
 
 func SetConfig() *cli.Command {
@@ -137,6 +138,12 @@ func SetConfig() *cli.Command {
 					}
 				}
 				deps.Cfg.System.SetIgnorePkgUpdates(updates)
+			case "updateSystemOnUpgrade":
+				boolValue, err := strconv.ParseBool(value)
+				if err != nil {
+					return cliutils.FormatCliExit(gotext.Get("invalid boolean value for %s: %s", key, value), err)
+				}
+				deps.Cfg.System.SetUpdateSystemOnUpgrade(boolValue)
 			case "repo", "repos":
 				return cliutils.FormatCliExit(gotext.Get("use 'repo add/remove' commands to manage repositories"), nil)
 			default:
@@ -206,6 +213,8 @@ func GetConfig() *cli.Command {
 				} else {
 					fmt.Println(strings.Join(updates, ", "))
 				}
+			case "updateSystemOnUpgrade":
+				fmt.Println(deps.Cfg.UpdateSystemOnUpgrade())
 			case "repo", "repos":
 				repos := deps.Cfg.Repos()
 				if len(repos) == 0 {

e2e-tests/issue_130_install_test.go

@@ -45,17 +45,17 @@ func TestE2EIssue130Install(t *testing.T) {
 	)
 	runMatrixSuite(
 		t,
-		"alr install {package}+alr-{repo}",
+		"alr install {package}+{repo}",
 		COMMON_SYSTEMS,
 		func(t *testing.T, r capytest.Runner) {
 			t.Parallel()
 			defaultPrepare(t, r)
 
-			r.Command("sudo", "alr", "in", fmt.Sprintf("foo-pkg+alr-%s", REPO_NAME_FOR_E2E_TESTS)).
+			r.Command("sudo", "alr", "in", fmt.Sprintf("foo-pkg+%s", REPO_NAME_FOR_E2E_TESTS)).
 				ExpectSuccess().
 				Run(t)
 
-			r.Command("sudo", "alr", "in", fmt.Sprintf("bar-pkg+alr-%s", "NOT_REPO_NAME_FOR_E2E_TESTS")).
+			r.Command("sudo", "alr", "in", fmt.Sprintf("bar-pkg+%s", "NOT_REPO_NAME_FOR_E2E_TESTS")).
 				ExpectFailure().
 				Run(t)
 		},

fix.go

@@ -131,22 +131,22 @@ func FixCmd() *cli.Command {
 				}
 			}
 
-			// Создаем базовый каталог /tmp/alr с владельцем root:wheel и правами 775
+			// Создаем базовый каталог /tmp/alr с владельцем root:wheel и правами 2775
-			err = utils.EnsureTempDirWithRootOwner(tmpDir, 0o775)
+			err = utils.EnsureTempDirWithRootOwner(tmpDir, 0o2775)
 			if err != nil {
 				slog.Warn(gotext.Get("Unable to create temporary directory"), "error", err)
 			}
 
 			// Создаем каталог dl с правами для группы wheel
 			dlDir := filepath.Join(tmpDir, "dl")
-			err = utils.EnsureTempDirWithRootOwner(dlDir, 0o775)
+			err = utils.EnsureTempDirWithRootOwner(dlDir, 0o2775)
 			if err != nil {
 				slog.Warn(gotext.Get("Unable to create download directory"), "error", err)
 			}
 
 			// Создаем каталог pkgs с правами для группы wheel
 			pkgsDir := filepath.Join(tmpDir, "pkgs")
-			err = utils.EnsureTempDirWithRootOwner(pkgsDir, 0o775)
+			err = utils.EnsureTempDirWithRootOwner(pkgsDir, 0o2775)
 			if err != nil {
 				slog.Warn(gotext.Get("Unable to create packages directory"), "error", err)
 			}
@@ -158,7 +158,8 @@ func FixCmd() *cli.Command {
 				// Проверяем, есть ли файлы в директории
 				entries, err := os.ReadDir(tmpDir)
 				if err == nil && len(entries) > 0 {
-					fixCmd := execWithPrivileges("chown", "-R", "root:wheel", tmpDir)
+					group := utils.GetPrivilegedGroup()
+					fixCmd := execWithPrivileges("chown", "-R", "root:"+group, tmpDir)
 					if fixErr := fixCmd.Run(); fixErr != nil {
 						slog.Warn(gotext.Get("Unable to fix file ownership"), "error", fixErr)
 					}
@@ -172,28 +173,13 @@ func FixCmd() *cli.Command {
 
 			slog.Info(gotext.Get("Rebuilding cache"))
 
-			// Пробуем создать директорию кэша
+			// Создаем директорию кэша с правильными правами
-			err = os.MkdirAll(paths.CacheDir, 0o775)
+			slog.Info(gotext.Get("Creating cache directory"))
+			err = utils.EnsureTempDirWithRootOwner(paths.CacheDir, 0o2775)
 			if err != nil {
-				// Если не получилось, пробуем через sudo с правильными правами для группы wheel
-				slog.Info(gotext.Get("Creating cache directory with sudo"))
-				sudoCmd := execWithPrivileges("mkdir", "-p", paths.CacheDir)
-				if sudoErr := sudoCmd.Run(); sudoErr != nil {
 				return cliutils.FormatCliExit(gotext.Get("Unable to create new cache directory"), err)
 			}
 
-				// Устанавливаем права 775 и группу wheel
-				chmodCmd := execWithPrivileges("chmod", "775", paths.CacheDir)
-				if chmodErr := chmodCmd.Run(); chmodErr != nil {
-					return cliutils.FormatCliExit(gotext.Get("Unable to set cache directory permissions"), chmodErr)
-				}
-				
-				chgrpCmd := execWithPrivileges("chgrp", "wheel", paths.CacheDir)
-				if chgrpErr := chgrpCmd.Run(); chgrpErr != nil {
-					return cliutils.FormatCliExit(gotext.Get("Unable to set cache directory group"), chgrpErr)
-				}
-			}
-
 			deps, err = appbuilder.
 				New(ctx).
 				WithConfig().

internal/build/build.go

@@ -32,6 +32,7 @@ import (
 	"gitea.plemya-x.ru/Plemya-x/ALR/internal/cliutils"
 	"gitea.plemya-x.ru/Plemya-x/ALR/internal/config"
 	"gitea.plemya-x.ru/Plemya-x/ALR/internal/manager"
+	"gitea.plemya-x.ru/Plemya-x/ALR/internal/stats"
 	"gitea.plemya-x.ru/Plemya-x/ALR/pkg/alrsh"
 	"gitea.plemya-x.ru/Plemya-x/ALR/pkg/distro"
 	"gitea.plemya-x.ru/Plemya-x/ALR/pkg/types"
@@ -319,9 +320,9 @@ func (b *Builder) BuildPackage(
 	}
 
 	var builtDeps []*BuiltDep
+	var remainingVars []*alrsh.Package
 
 	if !input.opts.Clean {
-		var remainingVars []*alrsh.Package
 		for _, vars := range varsOfPackages {
 			builtPkgPath, ok, err := b.cacheExecutor.CheckForBuiltPackage(ctx, input, vars)
 			if err != nil {
@@ -330,6 +331,7 @@ func (b *Builder) BuildPackage(
 			if ok {
 				builtDeps = append(builtDeps, &BuiltDep{
 					Path: builtPkgPath,
+					Name: vars.Name,
 				})
 			} else {
 				remainingVars = append(remainingVars, vars)
@@ -337,8 +339,12 @@ func (b *Builder) BuildPackage(
 		}
 
 		if len(remainingVars) == 0 {
+			slog.Info(gotext.Get("Using cached package"), "name", basePkg)
 			return builtDeps, nil
 		}
+		
+		// Обновляем varsOfPackages только теми пакетами, которые нужно собрать
+		varsOfPackages = remainingVars
 	}
 
 	slog.Debug("ViewScript")
@@ -401,11 +407,21 @@ func (b *Builder) BuildPackage(
 
 	// We filter so as not to re-build what has already been built at the `installBuildDeps` stage.
 	var filteredDepends []string
+	
+	// Создаем набор подпакетов текущего мультипакета для исключения циклических зависимостей
+	currentPackageNames := make(map[string]struct{})
+	for _, pkg := range input.packages {
+		currentPackageNames[pkg] = struct{}{}
+	}
+	
 	for _, d := range depends {
 		if _, found := depNames[d]; !found {
+			// Исключаем зависимости, которые являются подпакетами текущего мультипакета
+			if _, isCurrentPackage := currentPackageNames[d]; !isCurrentPackage {
 				filteredDepends = append(filteredDepends, d)
 			}
 		}
+	}
 
 	slog.Debug("BuildALRDeps")
 	newBuiltDeps, repoDeps, err := b.BuildALRDeps(ctx, input, filteredDepends)
@@ -528,6 +544,13 @@ func (b *Builder) InstallALRPackages(
 		if err != nil {
 			return err
 		}
+		
+		// Отслеживание установки ALR пакетов
+		for _, dep := range res {
+			if stats.ShouldTrackPackage(dep.Name) {
+				stats.TrackInstallation(ctx, dep.Name, "upgrade")
+			}
+		}
 	}
 
 	return nil
@@ -552,11 +575,13 @@ func (b *Builder) BuildALRDeps(
 		repoDeps = notFound
 
 		// Если для некоторых пакетов есть несколько опций, упрощаем их все в один срез
-		pkgs := cliutils.FlattenPkgs(
+		// Для зависимостей указываем isDependency = true
+		pkgs := cliutils.FlattenPkgsWithContext(
 			ctx,
 			found,
 			"install",
 			input.BuildOpts().Interactive,
+			true,
 		)
 		type item struct {
 			pkg      *alrsh.Package
@@ -691,6 +716,13 @@ func (i *Builder) InstallPkgs(
 		if err != nil {
 			return nil, err
 		}
+		
+		// Отслеживание установки локальных пакетов
+		for _, dep := range builtDeps {
+			if stats.ShouldTrackPackage(dep.Name) {
+				stats.TrackInstallation(ctx, dep.Name, "install")
+			}
+		}
 	}
 
 	if len(repoDeps) > 0 {
@@ -700,6 +732,13 @@ func (i *Builder) InstallPkgs(
 		if err != nil {
 			return nil, err
 		}
+		
+		// Отслеживание установки пакетов из репозитория
+		for _, pkg := range repoDeps {
+			if stats.ShouldTrackPackage(pkg) {
+				stats.TrackInstallation(ctx, pkg, "install")
+			}
+		}
 	}
 
 	return builtDeps, nil

internal/build/script_executor.go

@@ -167,15 +167,30 @@ func (e *LocalScriptExecutor) ExecuteSecondPass(
 		pkgName := packager.ConventionalFileName(pkgInfo) // Получаем имя файла пакета
 		pkgPath := filepath.Join(dirs.BaseDir, pkgName)   // Определяем путь к пакету
 
+		slog.Info("Creating package file", "path", pkgPath, "name", pkgName)
+
 		pkgFile, err := os.Create(pkgPath)
 		if err != nil {
+			slog.Error("Failed to create package file", "path", pkgPath, "error", err)
+			return nil, err
+		}
+		defer pkgFile.Close()
+
+		slog.Info("Packaging with nfpm", "format", pkgFormat)
+		err = packager.Package(pkgInfo, pkgFile)
+		if err != nil {
+			slog.Error("Failed to create package", "path", pkgPath, "error", err)
 			return nil, err
 		}
 
-		err = packager.Package(pkgInfo, pkgFile)
+		slog.Info("Package created successfully", "path", pkgPath)
-		if err != nil {
+
+		// Проверяем, что файл действительно существует
+		if _, err := os.Stat(pkgPath); err != nil {
+			slog.Error("Package file not found after creation", "path", pkgPath, "error", err)
 			return nil, err
 		}
+		slog.Info("Package file verified to exist", "path", pkgPath)
 
 		builtDeps = append(builtDeps, &BuiltDep{
 			Name: vars.Name,

internal/build/utils.go

@@ -49,12 +49,21 @@ import (
 
 // Функция prepareDirs подготавливает директории для сборки.
 func prepareDirs(dirs types.Directories) error {
-	// Пробуем удалить базовую директорию, если она существует
+	// Удаляем только директории источников и упаковки, не трогаем файлы пакетов в BaseDir
-	err := os.RemoveAll(dirs.BaseDir)
+	err := os.RemoveAll(dirs.SrcDir)
 	if err != nil {
-		// Если не можем удалить (например, принадлежит root), логируем и продолжаем
+		slog.Debug("Failed to remove src directory", "path", dirs.SrcDir, "error", err)
-		// Новые директории будут созданы или перезаписаны
+	}
-		slog.Debug("Failed to remove base directory", "path", dirs.BaseDir, "error", err)
+
+	err = os.RemoveAll(dirs.PkgDir)
+	if err != nil {
+		slog.Debug("Failed to remove pkg directory", "path", dirs.PkgDir, "error", err)
+	}
+
+	// Создаем базовую директорию для пакета с setgid битом
+	err = utils.EnsureTempDirWithRootOwner(dirs.BaseDir, 0o2775)
+	if err != nil {
+		return err
 	}
 
 	// Создаем директории с правильным владельцем для /tmp/alr с setgid битом
@@ -169,15 +178,16 @@ func normalizeContents(contents []*files.Content) {
 	}
 }
 
-var RegexpALRPackageName = regexp.MustCompile(`^(?P<package>[^+]+)\+alr-(?P<repo>.+)$`)
+var RegexpALRPackageName = regexp.MustCompile(`^(?P<package>[^+]+)\+(?P<repo>.+)$`)
 
 func getBasePkgInfo(vars *alrsh.Package, input interface {
 	RepositoryProvider
 	OsInfoProvider
 },
 ) *nfpm.Info {
+	repo := input.Repository()
 	return &nfpm.Info{
-		Name:    fmt.Sprintf("%s+alr-%s", vars.Name, input.Repository()),
+		Name:    fmt.Sprintf("%s+%s", vars.Name, repo),
 		Arch:    cpu.Arch(),
 		Version: vars.Version,
 		Release: overrides.ReleasePlatformSpecific(vars.Release, input.OSRelease()),

internal/build/utils_test.go

@@ -0,0 +1,158 @@
+// ALR - Any Linux Repository
+// Copyright (C) 2025 The ALR Authors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package build
+
+import (
+	"testing"
+
+	"gitea.plemya-x.ru/Plemya-x/ALR/pkg/alrsh"
+	"gitea.plemya-x.ru/Plemya-x/ALR/pkg/distro"
+)
+
+type mockInput struct {
+	repo    string
+	osInfo  *distro.OSRelease
+}
+
+func (m *mockInput) Repository() string {
+	return m.repo
+}
+
+func (m *mockInput) OSRelease() *distro.OSRelease {
+	return m.osInfo
+}
+
+func TestGetBasePkgInfo(t *testing.T) {
+	tests := []struct {
+		name         string
+		packageName  string
+		repoName     string
+		expectedName string
+	}{
+		{
+			name:         "обычный репозиторий",
+			packageName:  "test-package",
+			repoName:     "default",
+			expectedName: "test-package+default",
+		},
+		{
+			name:         "репозиторий с alr- префиксом",
+			packageName:  "test-package",
+			repoName:     "alr-default",
+			expectedName: "test-package+alr-default",
+		},
+		{
+			name:         "репозиторий с двойным alr- префиксом",
+			packageName:  "test-package",
+			repoName:     "alr-alr-repo",
+			expectedName: "test-package+alr-alr-repo",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			pkg := &alrsh.Package{
+				Name:    tt.packageName,
+				Version: "1.0.0",
+				Release: 1,
+			}
+
+			input := &mockInput{
+				repo: tt.repoName,
+				osInfo: &distro.OSRelease{
+					ID: "test",
+				},
+			}
+
+			info := getBasePkgInfo(pkg, input)
+
+			if info.Name != tt.expectedName {
+				t.Errorf("getBasePkgInfo() имя пакета = %v, ожидается %v", info.Name, tt.expectedName)
+			}
+		})
+	}
+}
+
+func TestRegexpALRPackageName(t *testing.T) {
+	tests := []struct {
+		name         string
+		packageName  string
+		expectedPkg  string
+		expectedRepo string
+		shouldMatch  bool
+	}{
+		{
+			name:         "новый формат - обычный репозиторий",
+			packageName:  "test-package+default",
+			expectedPkg:  "test-package",
+			expectedRepo: "default",
+			shouldMatch:  true,
+		},
+		{
+			name:         "новый формат - alr-default репозиторий",
+			packageName:  "test-package+alr-default",
+			expectedPkg:  "test-package",
+			expectedRepo: "alr-default",
+			shouldMatch:  true,
+		},
+		{
+			name:         "новый формат - двойной alr- префикс",
+			packageName:  "test-package+alr-alr-repo",
+			expectedPkg:  "test-package",
+			expectedRepo: "alr-alr-repo",
+			shouldMatch:  true,
+		},
+		{
+			name:        "некорректный формат - без плюса",
+			packageName: "test-package",
+			shouldMatch: false,
+		},
+		{
+			name:        "некорректный формат - пустое имя пакета",
+			packageName: "+repo",
+			shouldMatch: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			matches := RegexpALRPackageName.FindStringSubmatch(tt.packageName)
+
+			if tt.shouldMatch {
+				if matches == nil {
+					t.Errorf("RegexpALRPackageName должен найти совпадение для %q", tt.packageName)
+					return
+				}
+
+				packageName := matches[RegexpALRPackageName.SubexpIndex("package")]
+				repoName := matches[RegexpALRPackageName.SubexpIndex("repo")]
+
+				if packageName != tt.expectedPkg {
+					t.Errorf("RegexpALRPackageName извлеченное имя пакета = %v, ожидается %v", packageName, tt.expectedPkg)
+				}
+
+				if repoName != tt.expectedRepo {
+					t.Errorf("RegexpALRPackageName извлеченное имя репозитория = %v, ожидается %v", repoName, tt.expectedRepo)
+				}
+			} else {
+				if matches != nil {
+					t.Errorf("RegexpALRPackageName не должен найти совпадение для %q", tt.packageName)
+				}
+			}
+		})
+	}
+}

internal/cliutils/prompt.go

@@ -103,22 +103,62 @@ func ShowScript(path, name, style string) error {
 // FlattenPkgs attempts to flatten the a map of slices of packages into a single slice
 // of packages by prompting the user if multiple packages match.
 func FlattenPkgs(ctx context.Context, found map[string][]alrsh.Package, verb string, interactive bool) []alrsh.Package {
+	return FlattenPkgsWithContext(ctx, found, verb, interactive, false)
+}
+
+// FlattenPkgsWithContext расширенная версия FlattenPkgs с контекстом обработки зависимостей
+func FlattenPkgsWithContext(ctx context.Context, found map[string][]alrsh.Package, verb string, interactive bool, isDependency bool) []alrsh.Package {
 	var outPkgs []alrsh.Package
 	for _, pkgs := range found {
-		if len(pkgs) > 1 && interactive {
+		if len(pkgs) > 1 {
+			// Проверяем, являются ли пакеты подпакетами одного мультипакета
+			if isMultiPackage(pkgs) && verb == "install" {
+				// Для мультипакетов при установке ВСЕГДА берем все подпакеты без выбора
+				// Это правильное поведение как для прямой установки, так и для зависимостей
+				outPkgs = append(outPkgs, pkgs...)
+			} else if interactive {
+				// Для разных пакетов с одинаковым именем - показываем меню выбора
 				choice, err := PkgPrompt(ctx, pkgs, verb, interactive)
 				if err != nil {
 					slog.Error(gotext.Get("Error prompting for choice of package"))
 					os.Exit(1)
 				}
 				outPkgs = append(outPkgs, choice)
-		} else if len(pkgs) == 1 || !interactive {
+			} else {
+				// Если не интерактивный режим - берем первый
+				outPkgs = append(outPkgs, pkgs[0])
+			}
+		} else {
+			// Если только один пакет - берем его
 			outPkgs = append(outPkgs, pkgs[0])
 		}
 	}
 	return outPkgs
 }
 
+// isMultiPackage проверяет, являются ли пакеты подпакетами одного мультипакета
+func isMultiPackage(pkgs []alrsh.Package) bool {
+	if len(pkgs) <= 1 {
+		return false
+	}
+	
+	// Проверяем, что у всех пакетов одинаковый BasePkgName и Repository
+	firstBasePkg := pkgs[0].BasePkgName
+	firstRepo := pkgs[0].Repository
+	
+	if firstBasePkg == "" {
+		return false // Не мультипакет
+	}
+	
+	for _, pkg := range pkgs[1:] {
+		if pkg.BasePkgName != firstBasePkg || pkg.Repository != firstRepo {
+			return false
+		}
+	}
+	
+	return true
+}
+
 // PkgPrompt asks the user to choose between multiple packages.
 func PkgPrompt(ctx context.Context, options []alrsh.Package, verb string, interactive bool) (alrsh.Package, error) {
 	if !interactive {

internal/config/config.go

@@ -22,11 +22,13 @@ package config
 import (
 	"fmt"
 	"os"
+	"os/exec"
 	"path/filepath"
 
 	"github.com/goccy/go-yaml"
 	"github.com/knadh/koanf/providers/confmap"
 	"github.com/knadh/koanf/v2"
+	ktoml "github.com/knadh/koanf/parsers/toml/v2"
 
 	"gitea.plemya-x.ru/Plemya-x/ALR/internal/constants"
 	"gitea.plemya-x.ru/Plemya-x/ALR/pkg/types"
@@ -56,6 +58,7 @@ func defaultConfigKoanf() *koanf.Koanf {
 		"ignorePkgUpdates": []string{},
 		"logLevel":         "info",
 		"autoPull":         true,
+		"updateSystemOnUpgrade": false,
 		"repos": []types.Repo{
 			{
 				Name: "alr-default",
@@ -114,6 +117,11 @@ func (c *ALRConfig) Load() error {
 		}
 	}
 
+	// Выполняем миграцию конфигурации при необходимости
+	if err := c.migrateConfig(); err != nil {
+		return fmt.Errorf("failed to migrate config: %w", err)
+	}
+
 	return nil
 }
 
@@ -125,6 +133,126 @@ func (c *ALRConfig) ToYAML() (string, error) {
 	return string(data), nil
 }
 
+func (c *ALRConfig) migrateConfig() error {
+	// Проверяем, существует ли конфигурационный файл
+	if _, err := os.Stat(constants.SystemConfigPath); os.IsNotExist(err) {
+		// Если файла нет, создаем полный конфигурационный файл с дефолтными значениями
+		if err := c.createDefaultConfig(); err != nil {
+			// Если не удается создать конфиг, это не критично - продолжаем работу
+			// но выводим предупреждение
+			fmt.Fprintf(os.Stderr, "Предупреждение: не удалось создать конфигурационный файл %s: %v\n", constants.SystemConfigPath, err)
+			return nil
+		}
+	} else {
+		// Если файл существует, проверяем, есть ли в нем новая опция
+		if !c.System.k.Exists("updateSystemOnUpgrade") {
+			// Если опции нет, добавляем ее со значением по умолчанию
+			c.System.SetUpdateSystemOnUpgrade(false)
+			// Сохраняем обновленную конфигурацию
+			if err := c.System.Save(); err != nil {
+				// Если не удается сохранить - это не критично, продолжаем работу
+				return nil
+			}
+		}
+	}
+	
+	return nil
+}
+
+func (c *ALRConfig) createDefaultConfig() error {
+	// Проверяем, запущен ли процесс от root
+	if os.Getuid() != 0 {
+		// Если не root, пытаемся запустить создание конфига с повышением привилегий
+		return c.createDefaultConfigWithPrivileges()
+	}
+	
+	// Если уже root, создаем конфиг напрямую
+	return c.doCreateDefaultConfig()
+}
+
+func (c *ALRConfig) createDefaultConfigWithPrivileges() error {
+	// Если useRootCmd отключен, просто пытаемся создать без повышения привилегий
+	if !c.cfg.UseRootCmd {
+		return c.doCreateDefaultConfig()
+	}
+	
+	// Определяем команду для повышения привилегий
+	rootCmd := c.cfg.RootCmd
+	if rootCmd == "" {
+		rootCmd = "sudo" // fallback
+	}
+	
+	// Создаем временный файл с дефолтной конфигурацией
+	tmpFile, err := os.CreateTemp("", "alr-config-*.toml")
+	if err != nil {
+		return fmt.Errorf("не удалось создать временный файл: %w", err)
+	}
+	defer os.Remove(tmpFile.Name())
+	defer tmpFile.Close()
+	
+	// Генерируем дефолтную конфигурацию во временный файл
+	defaults := defaultConfigKoanf()
+	tempSystemConfig := &SystemConfig{k: defaults}
+	
+	bytes, err := tempSystemConfig.k.Marshal(ktoml.Parser())
+	if err != nil {
+		return fmt.Errorf("не удалось сериализовать конфигурацию: %w", err)
+	}
+	
+	if _, err := tmpFile.Write(bytes); err != nil {
+		return fmt.Errorf("не удалось записать во временный файл: %w", err)
+	}
+	tmpFile.Close()
+	
+	// Используем команду повышения привилегий для создания директории и копирования файла
+	
+	// Создаем директорию с правами
+	configDir := filepath.Dir(constants.SystemConfigPath)
+	mkdirCmd := exec.Command(rootCmd, "mkdir", "-p", configDir)
+	if err := mkdirCmd.Run(); err != nil {
+		return fmt.Errorf("не удалось создать директорию %s: %w", configDir, err)
+	}
+	
+	// Копируем файл в нужное место
+	cpCmd := exec.Command(rootCmd, "cp", tmpFile.Name(), constants.SystemConfigPath)
+	if err := cpCmd.Run(); err != nil {
+		return fmt.Errorf("не удалось скопировать конфигурацию в %s: %w", constants.SystemConfigPath, err)
+	}
+	
+	// Устанавливаем правильные права доступа
+	chmodCmd := exec.Command(rootCmd, "chmod", "644", constants.SystemConfigPath)
+	if err := chmodCmd.Run(); err != nil {
+		// Не критично, продолжаем
+		fmt.Fprintf(os.Stderr, "Предупреждение: не удалось установить права доступа для %s: %v\n", constants.SystemConfigPath, err)
+	}
+	
+	return nil
+}
+
+func (c *ALRConfig) doCreateDefaultConfig() error {
+	// Проверяем, существует ли директория для конфига
+	configDir := filepath.Dir(constants.SystemConfigPath)
+	if _, err := os.Stat(configDir); os.IsNotExist(err) {
+		// Пытаемся создать директорию
+		if err := os.MkdirAll(configDir, 0755); err != nil {
+			return fmt.Errorf("не удалось создать директорию %s: %w", configDir, err)
+		}
+	}
+
+	// Загружаем дефолтную конфигурацию
+	defaults := defaultConfigKoanf()
+	
+	// Копируем все дефолтные значения в системную конфигурацию
+	c.System.k = defaults
+	
+	// Сохраняем конфигурацию в файл
+	if err := c.System.Save(); err != nil {
+		return fmt.Errorf("не удалось сохранить конфигурацию в %s: %w", constants.SystemConfigPath, err)
+	}
+	
+	return nil
+}
+
 func (c *ALRConfig) RootCmd() string             { return c.cfg.RootCmd }
 func (c *ALRConfig) PagerStyle() string          { return c.cfg.PagerStyle }
 func (c *ALRConfig) AutoPull() bool              { return c.cfg.AutoPull }
@@ -133,4 +261,5 @@ func (c *ALRConfig) SetRepos(repos []types.Repo) { c.System.SetRepos(repos) }
 func (c *ALRConfig) IgnorePkgUpdates() []string  { return c.cfg.IgnorePkgUpdates }
 func (c *ALRConfig) LogLevel() string            { return c.cfg.LogLevel }
 func (c *ALRConfig) UseRootCmd() bool            { return c.cfg.UseRootCmd }
+func (c *ALRConfig) UpdateSystemOnUpgrade() bool { return c.cfg.UpdateSystemOnUpgrade }
 func (c *ALRConfig) GetPaths() *Paths            { return c.paths }

internal/config/system_config.go

@@ -142,3 +142,10 @@ func (c *SystemConfig) SetRepos(v []types.Repo) {
 		panic(err)
 	}
 }
+
+func (c *SystemConfig) SetUpdateSystemOnUpgrade(v bool) {
+	err := c.k.Set("updateSystemOnUpgrade", v)
+	if err != nil {
+		panic(err)
+	}
+}

internal/constants/constants.go

@@ -20,5 +20,6 @@ const (
 	SystemConfigPath = "/etc/alr/alr.toml"
 	SystemCachePath  = "/var/cache/alr"
 	TempDir          = "/tmp/alr"
-	PrivilegedGroup  = "wheel"
+	// PrivilegedGroup - устарело, используйте GetPrivilegedGroup()
+	PrivilegedGroup  = "wheel" // оставлено для обратной совместимости
 )

internal/db/db.go

@@ -62,11 +62,9 @@ func (d *Database) Connect() error {
 	dbDir := filepath.Dir(dsn)
 	if _, err := os.Stat(dbDir); err != nil {
 		if os.IsNotExist(err) {
-			// Директория не существует - пытаемся создать
+			// Директория не существует - не пытаемся создать
-			if mkErr := os.MkdirAll(dbDir, 0775); mkErr != nil {
+			// Пользователь должен использовать alr fix для создания системных каталогов
-				// Не смогли создать - вернём ошибку, пользователь должен использовать alr fix
+			return fmt.Errorf("cache directory does not exist, please run 'sudo alr fix' to create it")
-				return fmt.Errorf("cache directory does not exist, please run 'alr fix' to create it: %w", mkErr)
-			}
 		} else {
 			return fmt.Errorf("failed to check database directory: %w", err)
 		}

internal/manager/apt.go

@@ -140,16 +140,19 @@ func (a *APT) ListInstalled(opts *Opts) (map[string]string, error) {
 }
 
 func (a *APT) IsInstalled(pkg string) (bool, error) {
-	cmd := exec.Command("dpkg-query", "-l", pkg)
+	cmd := exec.Command("dpkg-query", "-f", "${Status}", "-W", pkg)
 	output, err := cmd.CombinedOutput()
 	if err != nil {
 		if exitErr, ok := err.(*exec.ExitError); ok {
-			// Exit code 1 means the package is not installed
+			// Код выхода 1 означает что пакет не найден
 			if exitErr.ExitCode() == 1 {
 				return false, nil
 			}
 		}
 		return false, fmt.Errorf("apt: isinstalled: %w, output: %s", err, output)
 	}
-	return true, nil
+
+	status := strings.TrimSpace(string(output))
+	// Проверяем что пакет действительно установлен (статус должен содержать "install ok installed")
+	return strings.Contains(status, "install ok installed"), nil
 }

internal/repos/find.go

@@ -47,9 +47,9 @@ func (rs *Repos) FindPkgs(ctx context.Context, pkgs []string) (map[string][]alrs
 			name := parts[1]
 			result, err = rs.db.GetPkgs(ctx, "name = ? AND repository = ?", name, repo)
 
-		case strings.Contains(pkgName, "+alr-"):
+		case strings.Contains(pkgName, "+"):
-			// pkg+alr-repo
+			// pkg+repo
-			parts := strings.SplitN(pkgName, "+alr-", 2)
+			parts := strings.SplitN(pkgName, "+", 2)
 			name := parts[0]
 			repo := parts[1]
 			result, err = rs.db.GetPkgs(ctx, "name = ? AND repository = ?", name, repo)
@@ -60,6 +60,13 @@ func (rs *Repos) FindPkgs(ctx context.Context, pkgs []string) (map[string][]alrs
 				return nil, nil, fmt.Errorf("FindPkgs: get by provides: %w", err)
 			}
 
+			if len(result) == 0 {
+				result, err = rs.db.GetPkgs(ctx, "basepkg_name = ?", pkgName)
+				if err != nil {
+					return nil, nil, fmt.Errorf("FindPkgs: get by basepkg_name: %w", err)
+				}
+			}
+
 			if len(result) == 0 {
 				result, err = rs.db.GetPkgs(ctx, "name LIKE ?", pkgName)
 			}

internal/shutils/helpers/files_find.go

@@ -177,3 +177,228 @@ func filesFindCmd(hc interp.HandlerContext, cmd string, args []string) error {
 
 	return outputFiles(hc, foundFiles)
 }
+
+func filesFindBinCmd(hc interp.HandlerContext, cmd string, args []string) error {
+	namePattern := "*"
+	if len(args) > 0 {
+		namePattern = args[0]
+	}
+
+	binPath := "./usr/bin/"
+	realPath := path.Join(hc.Dir, binPath)
+
+	if err := validateDir(realPath, "files-find-bin"); err != nil {
+		return err
+	}
+
+	var binFiles []string
+	err := filepath.Walk(realPath, func(p string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if !info.IsDir() && matchNamePattern(info.Name(), namePattern) {
+			relPath, relErr := makeRelativePath(hc.Dir, p)
+			if relErr != nil {
+				return relErr
+			}
+			binFiles = append(binFiles, relPath)
+		}
+		return nil
+	})
+	if err != nil {
+		return fmt.Errorf("files-find-bin: %w", err)
+	}
+
+	return outputFiles(hc, binFiles)
+}
+
+func filesFindLibCmd(hc interp.HandlerContext, cmd string, args []string) error {
+	namePattern := "*"
+	if len(args) > 0 {
+		namePattern = args[0]
+	}
+
+	libPaths := []string{"./usr/lib/", "./usr/lib64/"}
+	var libFiles []string
+
+	for _, libPath := range libPaths {
+		realPath := path.Join(hc.Dir, libPath)
+		if _, err := os.Stat(realPath); os.IsNotExist(err) {
+			continue
+		}
+
+		err := filepath.Walk(realPath, func(p string, info os.FileInfo, err error) error {
+			if err != nil {
+				return err
+			}
+
+			if !info.IsDir() && matchNamePattern(info.Name(), namePattern) {
+				relPath, relErr := makeRelativePath(hc.Dir, p)
+				if relErr != nil {
+					return relErr
+				}
+				libFiles = append(libFiles, relPath)
+			}
+			return nil
+		})
+		if err != nil {
+			return fmt.Errorf("files-find-lib: %w", err)
+		}
+	}
+
+	return outputFiles(hc, libFiles)
+}
+
+func filesFindIncludeCmd(hc interp.HandlerContext, cmd string, args []string) error {
+	namePattern := "*"
+	if len(args) > 0 {
+		namePattern = args[0]
+	}
+
+	includePath := "./usr/include/"
+	realPath := path.Join(hc.Dir, includePath)
+
+	if err := validateDir(realPath, "files-find-include"); err != nil {
+		return err
+	}
+
+	var includeFiles []string
+	err := filepath.Walk(realPath, func(p string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if !info.IsDir() && matchNamePattern(info.Name(), namePattern) {
+			relPath, relErr := makeRelativePath(hc.Dir, p)
+			if relErr != nil {
+				return relErr
+			}
+			includeFiles = append(includeFiles, relPath)
+		}
+		return nil
+	})
+	if err != nil {
+		return fmt.Errorf("files-find-include: %w", err)
+	}
+
+	return outputFiles(hc, includeFiles)
+}
+
+func filesFindShareCmd(hc interp.HandlerContext, cmd string, args []string) error {
+	namePattern := "*"
+	sharePath := "./usr/share/"
+
+	if len(args) > 0 {
+		if len(args) == 1 {
+			sharePath = "./usr/share/" + args[0] + "/"
+		} else {
+			sharePath = "./usr/share/" + args[0] + "/"
+			namePattern = args[1]
+		}
+	}
+
+	realPath := path.Join(hc.Dir, sharePath)
+
+	if err := validateDir(realPath, "files-find-share"); err != nil {
+		return err
+	}
+
+	var shareFiles []string
+	err := filepath.Walk(realPath, func(p string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if !info.IsDir() && matchNamePattern(info.Name(), namePattern) {
+			relPath, relErr := makeRelativePath(hc.Dir, p)
+			if relErr != nil {
+				return relErr
+			}
+			shareFiles = append(shareFiles, relPath)
+		}
+		return nil
+	})
+	if err != nil {
+		return fmt.Errorf("files-find-share: %w", err)
+	}
+
+	return outputFiles(hc, shareFiles)
+}
+
+func filesFindManCmd(hc interp.HandlerContext, cmd string, args []string) error {
+	namePattern := "*"
+	manSection := "*"
+
+	if len(args) > 0 {
+		if len(args) == 1 {
+			manSection = args[0]
+		} else {
+			manSection = args[0]
+			namePattern = args[1]
+		}
+	}
+
+	manPath := "./usr/share/man/man" + manSection + "/"
+	realPath := path.Join(hc.Dir, manPath)
+
+	if err := validateDir(realPath, "files-find-man"); err != nil {
+		return err
+	}
+
+	var manFiles []string
+	err := filepath.Walk(realPath, func(p string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if !info.IsDir() && matchNamePattern(info.Name(), namePattern) {
+			relPath, relErr := makeRelativePath(hc.Dir, p)
+			if relErr != nil {
+				return relErr
+			}
+			manFiles = append(manFiles, relPath)
+		}
+		return nil
+	})
+	if err != nil {
+		return fmt.Errorf("files-find-man: %w", err)
+	}
+
+	return outputFiles(hc, manFiles)
+}
+
+func filesFindConfigCmd(hc interp.HandlerContext, cmd string, args []string) error {
+	namePattern := "*"
+	if len(args) > 0 {
+		namePattern = args[0]
+	}
+
+	configPath := "./etc/"
+	realPath := path.Join(hc.Dir, configPath)
+
+	if err := validateDir(realPath, "files-find-config"); err != nil {
+		return err
+	}
+
+	var configFiles []string
+	err := filepath.Walk(realPath, func(p string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if !info.IsDir() && matchNamePattern(info.Name(), namePattern) {
+			relPath, relErr := makeRelativePath(hc.Dir, p)
+			if relErr != nil {
+				return relErr
+			}
+			configFiles = append(configFiles, relPath)
+		}
+		return nil
+	})
+	if err != nil {
+		return fmt.Errorf("files-find-config: %w", err)
+	}
+
+	return outputFiles(hc, configFiles)
+}

internal/shutils/helpers/helpers.go

@@ -59,6 +59,12 @@ var Helpers = handlers.ExecFuncs{
 	"files-find":        filesFindCmd,
 	"files-find-lang":   filesFindLangCmd,
 	"files-find-doc":    filesFindDocCmd,
+	"files-find-bin":    filesFindBinCmd,
+	"files-find-lib":    filesFindLibCmd,
+	"files-find-include": filesFindIncludeCmd,
+	"files-find-share":  filesFindShareCmd,
+	"files-find-man":    filesFindManCmd,
+	"files-find-config": filesFindConfigCmd,
 }
 
 // Restricted contains restricted read-only helper commands
@@ -68,6 +74,12 @@ var Restricted = handlers.ExecFuncs{
 	"files-find":        filesFindCmd,
 	"files-find-lang":   filesFindLangCmd,
 	"files-find-doc":    filesFindDocCmd,
+	"files-find-bin":    filesFindBinCmd,
+	"files-find-lib":    filesFindLibCmd,
+	"files-find-include": filesFindIncludeCmd,
+	"files-find-share":  filesFindShareCmd,
+	"files-find-man":    filesFindManCmd,
+	"files-find-config": filesFindConfigCmd,
 }
 
 func installHelperCmd(prefix string, perms os.FileMode) handlers.ExecFunc {

internal/stats/tracker.go

@@ -0,0 +1,106 @@
+// ALR - Any Linux Repository
+// Copyright (C) 2025 The ALR Authors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package stats
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os"
+	"strings"
+	"time"
+)
+
+type InstallationData struct {
+	PackageName string `json:"packageName"`
+	Version     string `json:"version,omitempty"`
+	InstallType string `json:"installType"` // "install" or "upgrade"
+	UserAgent   string `json:"userAgent"`
+	Fingerprint string `json:"fingerprint,omitempty"`
+}
+
+var (
+	apiEndpoints = []string{
+		"https://alr.plemya-x.ru/api/packages/track-install",
+		"http://localhost:3001/api/packages/track-install",
+	}
+	userAgent = "ALR-CLI/1.0"
+)
+
+func generateFingerprint(packageName string) string {
+	hostname, _ := os.Hostname()
+	data := fmt.Sprintf("%s_%s_%s", hostname, packageName, time.Now().Format("2006-01-02"))
+	hash := sha256.Sum256([]byte(data))
+	return hex.EncodeToString(hash[:])
+}
+
+// TrackInstallation отправляет статистику установки пакета
+func TrackInstallation(ctx context.Context, packageName string, installType string) {
+	// Запускаем в отдельной горутине, чтобы не блокировать основной процесс
+	go func() {
+		data := InstallationData{
+			PackageName: packageName,
+			InstallType: installType,
+			UserAgent:   userAgent,
+			Fingerprint: generateFingerprint(packageName),
+		}
+
+		jsonData, err := json.Marshal(data)
+		if err != nil {
+			return // Тихо игнорируем ошибки - статистика не критична
+		}
+
+		// Пробуем отправить запрос к разным endpoint-ам
+		for _, endpoint := range apiEndpoints {
+			if sendRequest(endpoint, jsonData) {
+				return // Если хотя бы один запрос прошёл успешно, выходим
+			}
+		}
+	}()
+}
+
+func sendRequest(endpoint string, data []byte) bool {
+	client := &http.Client{
+		Timeout: 5 * time.Second,
+	}
+
+	req, err := http.NewRequest("POST", endpoint, bytes.NewBuffer(data))
+	if err != nil {
+		return false
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("User-Agent", userAgent)
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return false
+	}
+	defer resp.Body.Close()
+
+	return resp.StatusCode >= 200 && resp.StatusCode < 300
+}
+
+// ShouldTrackPackage проверяет, нужно ли отслеживать установку этого пакета
+func ShouldTrackPackage(packageName string) bool {
+	// Отслеживаем только alr-bin
+	return strings.Contains(packageName, "alr-bin")
+}

internal/utils/cmd.go

@@ -19,14 +19,12 @@ package utils
 import (
 	"os"
 	"os/exec"
-	"os/user"
 
 	"github.com/leonelquinteros/gotext"
 	"github.com/urfave/cli/v2"
 
 	"gitea.plemya-x.ru/Plemya-x/ALR/internal/cliutils"
 	appbuilder "gitea.plemya-x.ru/Plemya-x/ALR/internal/cliutils/app_builder"
-	"gitea.plemya-x.ru/Plemya-x/ALR/internal/constants"
 )
 
 // IsNotRoot проверяет, что текущий пользователь не является root
@@ -34,39 +32,10 @@ func IsNotRoot() bool {
 	return os.Getuid() != 0
 }
 
-// EnuseIsPrivilegedGroupMember проверяет, что пользователь является членом привилегированной группы (wheel)
+// EnuseIsPrivilegedGroupMember проверяет, что пользователь является членом привилегированной группы (wheel/sudo)
+// DEPRECATED: используйте CheckUserPrivileges() из utils.go
 func EnuseIsPrivilegedGroupMember() error {
-	// В CI пропускаем проверку группы wheel
+	return CheckUserPrivileges()
-	if os.Getenv("CI") == "true" {
-		return nil
-	}
-	
-	// Если пользователь root, пропускаем проверку
-	if os.Geteuid() == 0 {
-		return nil
-	}
-	
-	currentUser, err := user.Current()
-	if err != nil {
-		return err
-	}
-
-	group, err := user.LookupGroup(constants.PrivilegedGroup)
-	if err != nil {
-		return err
-	}
-
-	groups, err := currentUser.GroupIds()
-	if err != nil {
-		return err
-	}
-
-	for _, gid := range groups {
-		if gid == group.Gid {
-			return nil
-		}
-	}
-	return cliutils.FormatCliExit(gotext.Get("You need to be a %s member to perform this action", constants.PrivilegedGroup), nil)
 }
 
 func RootNeededAction(f cli.ActionFunc) cli.ActionFunc {

internal/utils/privileged_group.go

@@ -0,0 +1,76 @@
+// ALR - Any Linux Repository
+// Copyright (C) 2025 The ALR Authors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package utils
+
+import (
+	"context"
+	"os/user"
+	"sync"
+
+	"gitea.plemya-x.ru/Plemya-x/ALR/pkg/distro"
+)
+
+var (
+	privilegedGroupCache string
+	privilegedGroupOnce  sync.Once
+)
+
+// GetPrivilegedGroup определяет правильную привилегированную группу для текущего дистрибутива.
+// Дистрибутивы на базе Debian/Ubuntu используют группу "sudo", остальные - "wheel".
+func GetPrivilegedGroup() string {
+	privilegedGroupOnce.Do(func() {
+		privilegedGroupCache = detectPrivilegedGroup()
+	})
+	return privilegedGroupCache
+}
+
+func detectPrivilegedGroup() string {
+	// Попробуем определить дистрибутив
+	ctx := context.Background()
+	osInfo, err := distro.ParseOSRelease(ctx)
+	if err != nil {
+		// Если не можем определить дистрибутив, проверяем какие группы существуют
+		return detectGroupByAvailability()
+	}
+
+	// Проверяем ID и семейство дистрибутива
+	// Debian и его производные (Ubuntu, Mint, PopOS и т.д.) используют sudo
+	if osInfo.ID == "debian" || osInfo.ID == "ubuntu" {
+		return "sudo"
+	}
+
+	// Проверяем семейство дистрибутива через ID_LIKE
+	for _, like := range osInfo.Like {
+		if like == "debian" || like == "ubuntu" {
+			return "sudo"
+		}
+	}
+
+	// Для остальных дистрибутивов (Fedora, RHEL, Arch, openSUSE, ALT Linux) используется wheel
+	return "wheel"
+}
+
+// detectGroupByAvailability проверяет существование групп в системе
+func detectGroupByAvailability() string {
+	// Сначала проверяем группу sudo (более распространена)
+	if _, err := user.LookupGroup("sudo"); err == nil {
+		return "sudo"
+	}
+
+	// Если sudo не найдена, возвращаем wheel
+	return "wheel"
+}

internal/utils/utils.go

@@ -17,8 +17,10 @@
 package utils
 
 import (
+	"fmt"
 	"os"
 	"os/exec"
+	"os/user"
 	"strings"
 
 	"golang.org/x/sys/unix"
@@ -28,23 +30,23 @@ func NoNewPrivs() error {
 	return unix.Prctl(unix.PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0)
 }
 
-// EnsureTempDirWithRootOwner создает каталог в /tmp/alr с правами для группы wheel
+// EnsureTempDirWithRootOwner создает каталог в /tmp/alr или /var/cache/alr с правами для привилегированной группы
-// Все каталоги в /tmp/alr принадлежат root:wheel с правами 775
+// Все каталоги в /tmp/alr и /var/cache/alr принадлежат root:привилегированная_группа с правами 2775
 // Для других каталогов использует стандартные права
 func EnsureTempDirWithRootOwner(path string, mode os.FileMode) error {
-	if strings.HasPrefix(path, "/tmp/alr") {
+	needsElevation := strings.HasPrefix(path, "/tmp/alr") || strings.HasPrefix(path, "/var/cache/alr")
-		// Сначала создаем директорию обычным способом
-		err := os.MkdirAll(path, mode)
-		if err != nil {
-			return err
-		}
 
+	if needsElevation {
 		// В CI или если мы уже root, не нужно использовать sudo
 		isRoot := os.Geteuid() == 0
 		isCI := os.Getenv("CI") == "true"
 
 		// В CI создаем директории с обычными правами
 		if isCI {
+			err := os.MkdirAll(path, mode)
+			if err != nil {
+				return err
+			}
 			// В CI не используем группу wheel и не меняем права
 			// Устанавливаем базовые права 777 для временных каталогов
 			chmodCmd := exec.Command("chmod", "777", path)
@@ -52,36 +54,48 @@ func EnsureTempDirWithRootOwner(path string, mode os.FileMode) error {
 			return nil
 		}
 
-		// Для обычной работы устанавливаем права и группу wheel
+		// Для обычной работы устанавливаем права и привилегированную группу
 		permissions := "2775"
-		group := "wheel"
+		group := GetPrivilegedGroup()
 
-		var chmodCmd, chownCmd *exec.Cmd
+		var mkdirCmd, chmodCmd, chownCmd *exec.Cmd
 		if isRoot {
 			// Выполняем команды напрямую без sudo
+			mkdirCmd = exec.Command("mkdir", "-p", path)
 			chmodCmd = exec.Command("chmod", permissions, path)
 			chownCmd = exec.Command("chown", "root:"+group, path)
 		} else {
-			// Используем sudo для обычных пользователей
+			// Используем sudo для всех операций с привилегированными каталогами
+			mkdirCmd = exec.Command("sudo", "mkdir", "-p", path)
 			chmodCmd = exec.Command("sudo", "chmod", permissions, path)
 			chownCmd = exec.Command("sudo", "chown", "root:"+group, path)
 		}
 
-		// Устанавливаем права с setgid битом
+		// Создаем директорию через sudo если нужно
-		err = chmodCmd.Run()
+		err := mkdirCmd.Run()
 		if err != nil {
-			// Для root игнорируем ошибки, если группа wheel не существует
+			// Игнорируем ошибку если директория уже существует
 			if !isRoot {
-				return err
+				// Проверяем существует ли директория
+				if _, statErr := os.Stat(path); statErr != nil {
+					return fmt.Errorf("не удалось создать директорию %s: %w", path, err)
+				}
 			}
 		}
 
-		// Устанавливаем владельца root:wheel
+		// Устанавливаем права с setgid битом для наследования группы
+		err = chmodCmd.Run()
+		if err != nil {
+			if !isRoot {
+				return fmt.Errorf("не удалось установить права на %s: %w", path, err)
+			}
+		}
+
+		// Устанавливаем владельца root:группа
 		err = chownCmd.Run()
 		if err != nil {
-			// Для root игнорируем ошибки, если группа wheel не существует
 			if !isRoot {
-				return err
+				return fmt.Errorf("не удалось установить владельца на %s: %w", path, err)
 			}
 		}
 
@@ -91,3 +105,60 @@ func EnsureTempDirWithRootOwner(path string, mode os.FileMode) error {
 	// Для остальных каталогов обычное создание
 	return os.MkdirAll(path, mode)
 }
+
+// IsUserInGroup проверяет, состоит ли пользователь в указанной группе
+func IsUserInGroup(username, groupname string) bool {
+	u, err := user.Lookup(username)
+	if err != nil {
+		return false
+	}
+
+	groups, err := u.GroupIds()
+	if err != nil {
+		return false
+	}
+
+	targetGroup, err := user.LookupGroup(groupname)
+	if err != nil {
+		return false
+	}
+
+	for _, gid := range groups {
+		if gid == targetGroup.Gid {
+			return true
+		}
+	}
+	return false
+}
+
+// CheckUserPrivileges проверяет, что пользователь имеет необходимые привилегии для работы с ALR
+// Пользователь должен быть root или состоять в группе wheel/sudo
+func CheckUserPrivileges() error {
+	// Если пользователь root - все в порядке
+	if os.Geteuid() == 0 {
+		return nil
+	}
+
+	// В CI не проверяем привилегии
+	if os.Getenv("CI") == "true" {
+		return nil
+	}
+
+	currentUser, err := user.Current()
+	if err != nil {
+		return fmt.Errorf("не удалось получить информацию о текущем пользователе: %w", err)
+	}
+
+	privilegedGroup := GetPrivilegedGroup()
+
+	// Проверяем членство в привилегированной группе
+	if !IsUserInGroup(currentUser.Username, privilegedGroup) {
+		return fmt.Errorf("пользователь %s не имеет необходимых привилегий для работы с ALR.\n"+
+			"Для работы с ALR необходимо быть пользователем root или состоять в группе %s.\n"+
+			"Выполните команду: sudo usermod -a -G %s %s\n"+
+			"Затем перезайдите в систему или выполните: newgrp %s",
+			currentUser.Username, privilegedGroup, privilegedGroup, currentUser.Username, privilegedGroup)
+	}
+
+	return nil
+}

pkg/types/config.go

@@ -28,6 +28,7 @@ type Config struct {
 	Repos               []Repo   `json:"repo" koanf:"repo"`
 	AutoPull            bool     `json:"autoPull" koanf:"autoPull"`
 	LogLevel            string   `json:"logLevel" koanf:"logLevel"`
+	UpdateSystemOnUpgrade bool   `json:"updateSystemOnUpgrade" koanf:"updateSystemOnUpgrade"`
 }
 
 // Repo represents a ALR repo within a configuration file

refresh.go

@@ -21,6 +21,7 @@ import (
 	"github.com/urfave/cli/v2"
 
 	appbuilder "gitea.plemya-x.ru/Plemya-x/ALR/internal/cliutils/app_builder"
+	"gitea.plemya-x.ru/Plemya-x/ALR/internal/utils"
 )
 
 func RefreshCmd() *cli.Command {
@@ -29,6 +30,9 @@ func RefreshCmd() *cli.Command {
 		Usage:   gotext.Get("Pull all repositories that have changed"),
 		Aliases: []string{"ref"},
 		Action: func(c *cli.Context) error {
+			if err := utils.CheckUserPrivileges(); err != nil {
+				return err
+			}
 
 			ctx := c.Context
 

scripts/install.sh

@@ -56,6 +56,31 @@ installPkg() {
   esac
 }
 
+trackInstallation() {
+  # Отправить статистику установки (не критично если не получится)
+  if command -v curl &>/dev/null; then
+    # Генерируем уникальный отпечаток на основе hostname и даты
+    fingerprint=$(echo "$(hostname)_$(date +%Y-%m-%d)" | sha256sum 2>/dev/null | cut -d' ' -f1 || echo "$(hostname)_$(date +%Y-%m-%d)")
+    
+    # Пробуем разные домены/порты для отправки статистики
+    for api_url in "https://alr.plemya-x.ru/api/packages/track-install" "http://localhost:3001/api/packages/track-install"; do
+      curl -s -m 5 -X POST "$api_url" \
+        -H "Content-Type: application/json" \
+        -H "User-Agent: ALR-InstallScript/1.0" \
+        -d "{
+          \"packageName\": \"alr-bin\",
+          \"installType\": \"script\",
+          \"userAgent\": \"ALR-InstallScript/1.0\",
+          \"fingerprint\": \"$fingerprint\"
+        }" >/dev/null 2>&1
+      # Если один запрос удался, не пробуем остальные
+      if [ $? -eq 0 ]; then
+        break
+      fi
+    done
+  fi
+}
+
 if ! command -v curl &>/dev/null; then
   error "Этот скрипт требует команду curl. Пожалуйста, установите её и запустите снова."
 fi
@@ -142,16 +167,15 @@ if [ -z "$noPkgMgr" ]; then
   info "Получен список файлов релиза"
 
   if [ "$pkgMgr" == "pacman" ]; then
-      latestFile=$(echo "$fileList" | grep -E "alr-bin-.*\.pkg\.tar\.zst" | sort -V | tail -n 1)
+      latestFile=$(echo "$fileList" | grep -E "alr-bin.*-(${arch}|any)\.pkg\.tar\.zst" | sort -V | tail -n 1)
   elif [ "$pkgMgr" == "apt" ]; then
-      latestFile=$(echo "$fileList" | grep -E "alr-bin-.*\.${debArch}\.deb" | sort -V | tail -n 1)
+      latestFile=$(echo "$fileList" | grep -E "alr-bin.*_(${debArch}|all)\.deb" | sort -V | tail -n 1)
   elif [[ "$pkgMgr" == "dnf" || "$pkgMgr" == "yum" || "$pkgMgr" == "zypper" ]]; then
-      latestFile=$(echo "$fileList" | grep -E "alr-bin-.*\.${rpmArch}\.rpm" | grep -v 'alt[0-9]*' | sort -V | tail -n 1)
+      latestFile=$(echo "$fileList" | grep -E "alr-bin.*\.(${rpmArch}|noarch)\.rpm" | grep -v 'alt[0-9]*' | sort -V | tail -n 1)
   elif [ "$pkgMgr" == "apt-get" ]; then
-      # ALT Linux использует RPM с особой маркировкой
+      latestFile=$(echo "$fileList" | grep -E "alr-bin.*-alt[0-9]+\.(${rpmArch}|noarch)\.rpm" | sort -V | tail -n 1)
-      latestFile=$(echo "$fileList" | grep -E "alr-bin-.*-alt[0-9]+\.${rpmArch}\.rpm" | sort -V | tail -n 1)
   elif [ "$pkgMgr" == "apk" ]; then
-      latestFile=$(echo "$fileList" | grep -E "alr-bin-.*\.apk" | sort -V | tail -n 1)
+      latestFile=$(echo "$fileList" | grep -E "alr-bin.*\.apk" | sort -V | tail -n 1)
   else
       error "Не поддерживаемый менеджер пакетов для автоматической установки"
   fi
@@ -187,6 +211,9 @@ if [ -z "$noPkgMgr" ]; then
   info "Установка пакета ALR"
   installPkg "$pkgMgr" "$fname"
 
+  # Отправляем статистику установки
+  trackInstallation
+
   info "Очистка"
   rm -f "$fname"
   trap - EXIT

upgrade.go

@@ -84,6 +84,19 @@ func UpgradeCmd() *cli.Command {
 			}
 			defer deps.Defer()
 
+			// Обновляем систему, если это включено в конфигурации
+			if deps.Cfg.UpdateSystemOnUpgrade() {
+				slog.Info(gotext.Get("Updating system packages..."))
+				err = deps.Manager.UpgradeAll(&manager.Opts{
+					NoConfirm: !c.Bool("interactive"),
+					Args:      manager.Args,
+				})
+				if err != nil {
+					return cliutils.FormatCliExit(gotext.Get("Error updating system packages"), err)
+				}
+				slog.Info(gotext.Get("System packages updated successfully"))
+			}
+
 			builder, err := build.NewMainBuilder(
 				deps.Cfg,
 				deps.Manager,