Merge pull request #41 from AppsGanin/feat/i18n

feat(i18n)!: Russian/English across the panel, bots, subscription page and CLI

Author: AppsGanin

cmd/rospanel/cli.go

@@ -49,7 +49,7 @@ func ensureHealthyDB(dbPath, dataDir string) error {
 		return fmt.Errorf("database is corrupt and there is no local backup to restore from. "+
 			"The damaged file is left at %s. Restore an off-box backup with `rospanel restore <file>`, "+
 			"or wipe and start fresh with `rospanel reset`. "+
-			"Turn on scheduled local backups (Настройки → Бэкапы) so this is recoverable next time", dbPath)
+			"Turn on scheduled local backups (Settings → Backups) so this is recoverable next time", dbPath)
 	}
 
 	quarantine, qerr := quarantineDB(dbPath)

cmd/rospanel/dbrecover.go

@@ -89,7 +89,7 @@ func main() {
 		case "help", "--help", "-h":
 			printUsage(os.Stdout)
 		default:
-			fmt.Fprintf(os.Stderr, "неизвестная команда %q\n\n", os.Args[1])
+			fmt.Fprintf(os.Stderr, "unknown command %q\n\n", os.Args[1])
 			printUsage(os.Stderr)
 			os.Exit(2)
 		}

cmd/rospanel/main.go

@@ -43,7 +43,7 @@ func runNode(args []string) {
 	case "help", "--help", "-h":
 		printNodeUsage(os.Stdout)
 	default:
-		fmt.Fprintf(os.Stderr, "неизвестная node-команда %q\n\n", args[0])
+		fmt.Fprintf(os.Stderr, "unknown node command %q\n\n", args[0])
 		printNodeUsage(os.Stderr)
 		os.Exit(2)
 	}
@@ -221,9 +221,9 @@ func runNodeUninstall(args []string) {
 		log.Fatal("node uninstall: run as root (sudo)")
 	}
 	if !hasYesFlag(args) && !confirmTTY(
-		"Удалить systemd-сервис rospanel-node? Нода будет остановлена.\n"+
-			"Данные ноды сохранятся, бинарь не удаляется. Продолжить? [y/N]: ") {
-		fmt.Println("Отменено.")
+		"Remove the rospanel-node systemd service? The node will be stopped.\n"+
+			"Node data is kept and the binary is not removed. Continue? [y/N]: ") {
+		fmt.Println("Cancelled.")
 		return
 	}
 	_ = exec.Command("systemctl", "disable", "--now", "rospanel-node").Run()

cmd/rospanel/node.go

@@ -39,7 +39,7 @@ import (
 // generate the Xray config, start the background loops and serve the admin API +
 // masquerade/subscription surface until a termination signal arrives.
 func runServer(dataDir string) {
-	log.Printf("startup: РосПанель %s booting (data dir %s)", version.Version, dataDir)
+	log.Printf("startup: RosPanel %s booting (data dir %s)", version.Version, dataDir)
 	adminAddr := env("ROSPANEL_ADMIN_ADDR", "127.0.0.1:8080")
 	startupStage("resolving Xray binary")
 	xrayBin := resolveXrayBin(env("XRAY_BIN", "xray"), filepath.Join(dataDir, "bin"))
@@ -308,7 +308,7 @@ func bootstrapTLS(st *store.Store, certPath, keyPath, acmeDir string) error {
 	if err != nil {
 		return err
 	}
-	// A real host set in the panel (setup wizard → Settings → Домен) always wins.
+	// A real host set in the panel (setup wizard → Settings → Domain) always wins.
 	// When none is set yet — or a previous boot persisted the loopback fallback —
 	// resolve one for an unattended first boot: an explicit ROSPANEL_HOST (domain
 	// or IP) takes priority so an operator can pin a domain; otherwise auto-detect

cmd/rospanel/service.go

@@ -134,7 +134,7 @@ func (s *Store) Matcher() *Matcher { return s.matcher }
 // FileInfo is one category's state, for the settings UI.
 type FileInfo struct {
 	Category string `json:"category"`
-	Title    string `json:"title"`
+	TitleKey string `json:"title_key"` // dictionary key; the panel words it
 	Enabled  bool   `json:"enabled"`
 	Present  bool   `json:"present"`           // a cached feed on disk, or a non-empty custom list
 	Entries  int    `json:"entries"`           // entries currently loaded in the matcher
@@ -149,7 +149,7 @@ func (s *Store) Status() []FileInfo {
 	out := make([]FileInfo, 0, len(Feeds)+1)
 	for _, cat := range feedCats() {
 		fi := FileInfo{
-			Category: string(cat), Title: cat.Title(),
+			Category: string(cat), TitleKey: cat.TitleKey(),
 			Enabled: s.catEnabled(cat), Entries: counts[cat],
 		}
 		if st, err := os.Stat(s.path(cat)); err == nil {
@@ -162,7 +162,7 @@ func (s *Store) Status() []FileInfo {
 	customSet := strings.TrimSpace(s.custom) != ""
 	s.cfgMu.Unlock()
 	out = append(out, FileInfo{
-		Category: string(CatCustom), Title: CatCustom.Title(),
+		Category: string(CatCustom), TitleKey: CatCustom.TitleKey(),
 		Enabled: s.catEnabled(CatCustom), Present: customSet, Entries: counts[CatCustom],
 	})
 	return out

internal/abuse/feeds.go

@@ -11,11 +11,11 @@ func TestIPMatchCIDRAndBoundaries(t *testing.T) {
 	m.SetIP(CatBadIP, []string{"10.0.0.0/24", "192.0.2.5", "2001:db8::/32"})
 
 	hit := []string{
-		"10.0.0.0",     // network address
-		"10.0.0.1",     //
-		"10.0.0.255",   // broadcast / last in /24
-		"192.0.2.5",    // single host
-		"2001:db8::1",  // inside v6 prefix
+		"10.0.0.0",    // network address
+		"10.0.0.1",    //
+		"10.0.0.255",  // broadcast / last in /24
+		"192.0.2.5",   // single host
+		"2001:db8::1", // inside v6 prefix
 		"2001:db8:ffff:ffff::1",
 	}
 	for _, ip := range hit {
@@ -25,9 +25,9 @@ func TestIPMatchCIDRAndBoundaries(t *testing.T) {
 	}
 
 	miss := []string{
-		"10.0.1.0",   // just past the /24
+		"10.0.1.0", // just past the /24
 		"9.255.255.255",
-		"192.0.2.4",  // adjacent to the single host
+		"192.0.2.4", // adjacent to the single host
 		"192.0.2.6",
 		"2001:db9::1", // just past the v6 /32
 		"8.8.8.8",

internal/abuse/ipmatch_test.go

@@ -43,19 +43,13 @@ const (
 	CatGambling Category = "gambling"
 )
 
-// Title is the Russian label shown in the panel.
-func (c Category) Title() string {
+// TitleKey is the dictionary key for the category's name. It is a key and not a
+// word because the only reader is a Telegram alert, and which language that alert
+// is written in is a setting, not a build-time constant.
+func (c Category) TitleKey() string {
 	switch c {
-	case CatCustom:
-		return "Свой список"
-	case CatBadIP:
-		return "Вредоносный IP"
-	case CatMalware:
-		return "Вредоносное ПО"
-	case CatPiracy:
-		return "Пиратство"
-	case CatGambling:
-		return "Азартные игры"
+	case CatCustom, CatBadIP, CatMalware, CatPiracy, CatGambling:
+		return "abuse." + string(c)
 	}
 	return string(c)
 }

internal/abuse/matcher.go

@@ -2,7 +2,7 @@
 // colour and logo. The name and accent live in the settings table (so they ride
 // along in the SQLite backup); a custom logo is a file under <dataDir>/branding/
 // (which the data-dir tar backup already captures). When nothing is configured
-// the built-in РосПанель defaults apply.
+// the built-in RosPanel defaults apply.
 package branding
 
 import (
@@ -20,12 +20,14 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
+
+	"github.com/AppsGanin/rospanel/internal/model"
 )
 
 //go:embed default-logo.svg
 var defaultLogoSVG []byte
 
-// DefaultLogo returns the built-in РосПанель logo (SVG).
+// DefaultLogo returns the built-in RosPanel logo (SVG).
 func DefaultLogo() []byte { return defaultLogoSVG }
 
 const (
@@ -47,7 +49,7 @@ type Theme struct {
 	Surface string `json:"surface"` // cards / inputs / panels
 }
 
-// DefaultTheme is the stock РосПанель palette (Госуслуги-style blue on a soft
+// DefaultTheme is the stock RosPanel palette (Gosuslugi-style blue on a soft
 // blue page with white surfaces).
 func DefaultTheme() Theme {
 	return Theme{
@@ -100,27 +102,30 @@ func pick(v, fallback string) string {
 // NormalizeTheme validates each provided colour and returns the JSON to persist.
 // Empty fields are dropped (⇒ default applies); a non-empty non-hex field errors.
 func NormalizeTheme(t Theme) (string, error) {
-	clean := func(name, v string) (string, error) {
+	// Which colour failed is part of the message, and it is a word — so each field
+	// gets its own code rather than one code with the field name glued in: an
+	// argument travels verbatim and would arrive at an English panel in Russian.
+	clean := func(code, fallback, v string) (string, error) {
 		v = strings.ToLower(strings.TrimSpace(v))
 		if v == "" || accentRe.MatchString(v) {
 			return v, nil
 		}
-		return "", fmt.Errorf("цвет «%s» должен быть в формате #RRGGBB", name)
+		return "", model.FieldErr(code, fallback)
 	}
 	var err error
-	if t.Accent, err = clean("акцент", t.Accent); err != nil {
+	if t.Accent, err = clean("err.badColorAccent", "цвет «акцент» должен быть в формате #RRGGBB", t.Accent); err != nil {
 		return "", err
 	}
-	if t.Text, err = clean("текст", t.Text); err != nil {
+	if t.Text, err = clean("err.badColorText", "цвет «текст» должен быть в формате #RRGGBB", t.Text); err != nil {
 		return "", err
 	}
-	if t.Muted, err = clean("приглушённый текст", t.Muted); err != nil {
+	if t.Muted, err = clean("err.badColorMuted", "цвет «приглушённый текст» должен быть в формате #RRGGBB", t.Muted); err != nil {
 		return "", err
 	}
-	if t.Bg, err = clean("фон", t.Bg); err != nil {
+	if t.Bg, err = clean("err.badColorBg", "цвет «фон» должен быть в формате #RRGGBB", t.Bg); err != nil {
 		return "", err
 	}
-	if t.Surface, err = clean("поверхность", t.Surface); err != nil {
+	if t.Surface, err = clean("err.badColorSurface", "цвет «поверхность» должен быть в формате #RRGGBB", t.Surface); err != nil {
 		return "", err
 	}
 	if t == (Theme{}) {
@@ -229,17 +234,17 @@ func SaveLogo(dataDir string, r io.Reader) error {
 		return err
 	}
 	if len(b) == 0 {
-		return fmt.Errorf("пустой файл")
+		return model.FieldErr("err.emptyFile", "пустой файл")
 	}
 	if len(b) > MaxLogoBytes {
-		return fmt.Errorf("логотип больше %d КБ", MaxLogoBytes>>10)
+		return model.FieldErr("err.logoTooBig", "логотип больше {{kb}} КБ", map[string]any{"kb": MaxLogoBytes >> 10})
 	}
 	cfg, format, err := image.DecodeConfig(bytes.NewReader(b))
 	if err != nil || (format != "png" && format != "jpeg") {
-		return fmt.Errorf("нужен PNG или JPEG")
+		return model.FieldErr("err.needPngJpeg", "нужен PNG или JPEG")
 	}
 	if cfg.Width > maxLogoDim || cfg.Height > maxLogoDim {
-		return fmt.Errorf("изображение больше %d×%d пикселей", maxLogoDim, maxLogoDim)
+		return model.FieldErr("err.imageTooLarge", "изображение больше {{dim}}×{{dim}} пикселей", map[string]any{"dim": maxLogoDim})
 	}
 	if err := os.MkdirAll(brandingDir(dataDir), 0o700); err != nil {
 		return err

internal/branding/branding.go

@@ -1,15 +1,75 @@
 package core
 
-import "fmt"
+import (
+	"errors"
+	"fmt"
+	"strings"
 
-// ValidationError marks an error caused by bad operator input rather than a
-// server fault. The server layer maps it to HTTP 400 (vs 500 for everything
-// else); its message is operator-facing (Russian) and safe to show in the UI.
-type ValidationError struct{ Msg string }
+	"github.com/AppsGanin/rospanel/internal/model"
+)
+
+// ValidationError marks an error caused by bad operator input rather than a server
+// fault. The server layer maps it to HTTP 400 (vs 500 for everything else).
+//
+// It carries a dictionary CODE alongside the message, and the panel renders that
+// code against its own dictionaries — the panel's language is a per-browser choice
+// the server cannot see, so a message worded here would be stuck in one language on
+// a bilingual page.
+//
+// Msg is not dead weight: it is the fallback the panel shows for a code it does not
+// know, so a build whose dictionaries lag the server still reads as a sentence
+// rather than as "err.tokenRequired". It is also what Error() returns, which is what
+// lands in the logs and in the external REST API, where there is no dictionary.
+type ValidationError struct {
+	Msg  string
+	Code string
+	Args map[string]any
+}
 
 func (e *ValidationError) Error() string { return e.Msg }
 
-// invalid builds a ValidationError with a formatted operator-facing message.
+// invalid builds a ValidationError with a formatted operator-facing message and no
+// code. Kept for the messages the panel never surfaces; anything an operator can see
+// should use invalidCode so it can be translated.
 func invalid(format string, a ...any) error {
 	return &ValidationError{Msg: fmt.Sprintf(format, a...)}
 }
+
+// invalidCode builds a ValidationError the panel can translate. code names an entry
+// under err.* in the frontend dictionaries; fallback is the wording shown when that
+// entry is missing; args are interpolated into both.
+//
+// code comes first on purpose: a call site should read as the thing that went wrong,
+// not as a sentence that happens to carry an id.
+func invalidCode(code, fallback string, args ...map[string]any) error {
+	e := &ValidationError{Msg: fallback, Code: code}
+	if len(args) > 0 && args[0] != nil {
+		e.Args = args[0]
+		// Fill the fallback too: it is what a stale panel renders, and a bare
+		// template with unfilled slots would read worse than the raw code.
+		e.Msg = interpolate(fallback, args[0])
+	}
+	return e
+}
+
+// interpolate fills {{name}} placeholders. The panel does the same to the translated
+// string; this keeps the untranslated path from showing braces to an operator.
+func interpolate(s string, args map[string]any) string {
+	for k, v := range args {
+		s = strings.ReplaceAll(s, "{{"+k+"}}", fmt.Sprint(v))
+	}
+	return s
+}
+
+// fromFieldErr turns a model-layer validation failure into a ValidationError,
+// carrying its code across the layer boundary. The model cannot build a
+// ValidationError itself — that would invert the import — so it raises a FieldError
+// and this is where the two meet. An uncoded error still becomes a 400; it just
+// falls back to its own text in the panel.
+func fromFieldErr(err error) error {
+	var fe *model.FieldError
+	if errors.As(err, &fe) {
+		return &ValidationError{Msg: fe.Msg, Code: fe.Code, Args: fe.Args}
+	}
+	return invalid("%s", err.Error())
+}