feat: add backend, admin console and live monitoring

Integrate tunasync management, SQLite authentication and content settings, real monitoring and per-repository pull speeds. Add Chinese-only announcements and mirror help, editable related links, admin layout updates, deployment tools and tests.
This commit is contained in:
2026-11-01 18:04:01 +08:00
parent addadd7d15
commit f8cef413d6
57 changed files with 4222 additions and 101 deletions
+402
View File
@@ -0,0 +1,402 @@
package main
import (
"bytes"
"encoding/json"
"errors"
"image"
_ "image/jpeg"
_ "image/png"
"io"
"net/http"
"net/mail"
"net/url"
"os"
"path/filepath"
"regexp"
"sort"
"strings"
"time"
)
var identifier = regexp.MustCompile(`^[a-zA-Z0-9][a-zA-Z0-9_.+-]{0,127}$`)
func validName(value string) bool {
return identifier.MatchString(value) && value != "." && value != ".."
}
func validText(value Localized, required bool, limit int) bool {
has := false
if len(value) > 20 {
return false
}
for locale, text := range value {
if len(locale) > 48 || !localeIdentifier.MatchString(locale) {
return false
}
if len(text) > limit {
return false
}
if strings.TrimSpace(text) != "" {
has = true
}
}
return !required || has
}
var localeIdentifier = regexp.MustCompile(`^[a-zA-Z]{2,3}(?:-[a-zA-Z0-9]{2,8})*$`)
func webURL(value string, empty bool) bool {
if empty && value == "" {
return true
}
u, e := url.Parse(value)
return e == nil && (u.Scheme == "http" || u.Scheme == "https") && u.Host != "" && u.User == nil && len(value) < 2048
}
func navigationURL(value string) bool {
if webURL(value, false) {
return true
}
if !strings.HasPrefix(value, "/") || strings.HasPrefix(value, "//") || len(value) >= 2048 || strings.ContainsAny(value, "\\\r\n\t") {
return false
}
u, err := url.Parse(value)
return err == nil && u.Scheme == "" && u.Host == "" && u.User == nil
}
func imageURL(value string) bool {
if strings.HasPrefix(value, "/assets/") || strings.HasPrefix(value, "/uploads/") {
return !strings.Contains(value, "..") && !strings.ContainsAny(value, "\\?#")
}
u, e := url.Parse(value)
return e == nil && u.Scheme == "https" && u.Host != "" && u.User == nil
}
func strict(raw []byte, value any) bool {
d := json.NewDecoder(bytes.NewReader(raw))
d.DisallowUnknownFields()
return d.Decode(value) == nil
}
func (a *App) listRecords(w http.ResponseWriter, r *http.Request) {
kind := r.PathValue("kind")
if kind != "announcements" && kind != "mirrors" && kind != "settings" {
fail(w, 404, "NOT_FOUND")
return
}
if _, ok := a.require(w, r, kind != "announcements"); !ok {
return
}
records, err := a.records(kind)
if err != nil {
a.internal(w, err)
return
}
respond(w, 200, records)
}
func (a *App) putRecord(w http.ResponseWriter, r *http.Request) {
kind, id := r.PathValue("kind"), r.PathValue("id")
if !validName(id) || (kind != "announcements" && kind != "mirrors" && kind != "settings") {
fail(w, 400, "INVALID_INPUT")
return
}
s, ok := a.require(w, r, kind != "announcements")
if !ok {
return
}
var body struct {
Data json.RawMessage `json:"data"`
Revision int `json:"revision"`
}
if !readJSON(w, r, &body) {
return
}
var value any
switch kind {
case "announcements":
var d Announcement
if !strict(body.Data, &d) || strings.TrimSpace(d.Title) == "" || len(d.Title) > 300 || len(d.Body) > 250000 || (d.Published && strings.TrimSpace(d.Body) == "") {
fail(w, 400, "INVALID_INPUT")
return
}
if d.Date == "" {
d.Date = time.Now().UTC().Format(time.RFC3339)
}
if _, err := time.Parse(time.RFC3339, d.Date); err != nil {
fail(w, 400, "INVALID_INPUT")
return
}
value = d
case "mirrors":
var d MirrorMetadata
if !strict(body.Data, &d) || d.Name != id || !validText(d.Description, false, 1000) || len(d.Help) > 250000 || !webURL(d.Website, true) || (d.Category != "os" && d.Category != "language" && d.Category != "other") {
fail(w, 400, "INVALID_INPUT")
return
}
value = d
case "settings":
var d Settings
if id != "site" || !strict(body.Data, &d) || !validText(d.Name, true, 200) || !validText(d.Description, false, 2000) || !validText(d.Address, false, 2000) || !imageURL(d.LogoLight) || !imageURL(d.LogoDark) || !imageURL(d.Favicon) || !imageURL(d.Avatar) || len(d.Links) > 50 || len(d.RelatedLinks) > 50 || len(d.Downloads) > 100 {
fail(w, 400, "INVALID_INPUT")
return
}
var fields map[string]json.RawMessage
json.Unmarshal(body.Data, &fields)
if _, provided := fields["relatedLinks"]; !provided {
// Preserve saved sidebar changes when an older open form submits without this field.
current, err := a.record("settings", "site")
var existing Settings
if err != nil || decodeData(current.Data, &existing) != nil {
fail(w, 409, "CONFLICT")
return
}
d.RelatedLinks = existing.RelatedLinks
}
if d.RelatedLinks == nil {
d.RelatedLinks = []RelatedLink{}
}
for _, link := range d.RelatedLinks {
if !validText(link.Title, true, 200) || (link.Kind != "help" && link.Kind != "url") || (link.Kind == "help" && link.URL != "") || (link.Kind == "url" && !navigationURL(link.URL)) {
fail(w, 400, "INVALID_INPUT")
return
}
}
if d.Email != "" {
if parsed, err := mail.ParseAddress(d.Email); err != nil || parsed.Address != d.Email {
fail(w, 400, "INVALID_INPUT")
return
}
}
for _, link := range d.Links {
if !validText(link.Title, true, 200) || !webURL(link.URL, false) {
fail(w, 400, "INVALID_INPUT")
return
}
}
for _, download := range d.Downloads {
if strings.TrimSpace(download.Name) == "" || len(download.Name) > 100 || len(download.Version) > 100 || !webURL(download.URL, false) {
fail(w, 400, "INVALID_INPUT")
return
}
}
value = d
}
result, err := a.saveRecord(kind, id, value, body.Revision)
if errors.Is(err, errConflict) {
fail(w, 409, "CONFLICT")
return
}
if err != nil {
a.internal(w, err)
return
}
a.audit(s, "record_save", kind+"/"+id, "success")
respond(w, 200, result)
}
func (a *App) deleteRecord(w http.ResponseWriter, r *http.Request) {
kind, id := r.PathValue("kind"), r.PathValue("id")
if kind != "announcements" && kind != "mirrors" {
fail(w, 400, "INVALID_INPUT")
return
}
s, ok := a.require(w, r, kind != "announcements")
if !ok {
return
}
var body struct {
Revision int `json:"revision"`
}
if !readJSON(w, r, &body) {
return
}
result, err := a.db.Exec("UPDATE records SET deleted=1,revision=revision+1,updated=? WHERE kind=? AND id=? AND revision=? AND deleted=0", time.Now().UnixMilli(), kind, id, body.Revision)
if err != nil {
a.internal(w, err)
return
}
count, _ := result.RowsAffected()
if count != 1 {
fail(w, 409, "CONFLICT")
return
}
a.audit(s, "record_delete", kind+"/"+id, "success")
respond(w, 200, map[string]bool{"ok": true})
}
func (a *App) upload(w http.ResponseWriter, r *http.Request) {
s, ok := a.require(w, r, true)
if !ok {
return
}
r.Body = http.MaxBytesReader(w, r.Body, 5<<20)
if err := r.ParseMultipartForm(4 << 20); err != nil {
fail(w, 400, "INVALID_IMAGE")
return
}
if r.MultipartForm != nil {
defer r.MultipartForm.RemoveAll()
}
file, _, err := r.FormFile("file")
if err != nil {
fail(w, 400, "INVALID_IMAGE")
return
}
defer file.Close()
content, err := io.ReadAll(io.LimitReader(file, 4<<20+1))
if err != nil || len(content) > 4<<20 {
fail(w, 400, "INVALID_IMAGE")
return
}
conf, format, err := image.DecodeConfig(bytes.NewReader(content))
if err != nil || (format != "png" && format != "jpeg") || conf.Width < 1 || conf.Height < 1 || conf.Width > 8192 || conf.Height > 8192 || int64(conf.Width)*int64(conf.Height) > 32000000 {
fail(w, 400, "INVALID_IMAGE")
return
}
ext := ".png"
if format == "jpeg" {
ext = ".jpg"
}
name := tokenHash(randomToken())[:24] + ext
if err = os.WriteFile(filepath.Join(a.cfg.Data, "uploads", name), content, 0644); err != nil {
a.internal(w, err)
return
}
a.audit(s, "upload", name, "success")
respond(w, 201, map[string]string{"url": "/uploads/" + name})
}
func (a *App) public(w http.ResponseWriter, r *http.Request) {
site, err := a.record("settings", "site")
if err != nil {
a.internal(w, err)
return
}
metadata, err := a.records("mirrors")
if err != nil {
a.internal(w, err)
return
}
metas := map[string]MirrorMetadata{}
for _, record := range metadata {
var m MirrorMetadata
if decodeData(record.Data, &m) == nil {
metas[record.ID] = m
}
}
jobs, updated, upstreamError := a.cachedJobs()
mirrors := []PublicMirror{}
for _, job := range jobs {
meta, exists := metas[job.Name]
if exists && !meta.Visible {
continue
}
if !exists {
meta = MirrorMetadata{Name: job.Name, Category: "other", Visible: true, Description: Localized{}}
}
mirrors = append(mirrors, publicMirror(job, meta))
}
sort.Slice(mirrors, func(i, j int) bool { return mirrors[i].Name < mirrors[j].Name })
announcements, err := a.records("announcements")
if err != nil {
a.internal(w, err)
return
}
published := []Record{}
for _, record := range announcements {
var d Announcement
if decodeData(record.Data, &d) == nil && d.Published {
record.Data = d
published = append(published, record)
}
}
sort.SliceStable(published, func(i, j int) bool {
a, b := published[i].Data.(Announcement), published[j].Data.(Announcement)
if a.Pinned != b.Pinned {
return a.Pinned
}
return a.Date > b.Date
})
if len(published) > 100 {
published = published[:100]
}
respond(w, 200, map[string]any{"site": site.Data, "mirrors": mirrors, "announcements": published, "source": map[string]any{"updatedAt": updated, "stale": upstreamError != "" || updated == 0 || time.Now().UnixMilli()-updated > 60000, "code": upstreamError}})
}
func (a *App) overview(w http.ResponseWriter, r *http.Request) {
if _, ok := a.require(w, r, false); !ok {
return
}
jobs, updated, code := a.cachedJobs()
workers := []Worker{}
err := a.managerGet(r.Context(), "/workers", &workers)
if err != nil && code == "" {
code = "TUNASYNC_UNAVAILABLE"
}
respond(w, 200, map[string]any{"jobs": jobs, "workers": workers, "worker": a.cfg.Worker, "updatedAt": updated, "code": code, "configAvailable": a.cfg.WorkerConfig != "", "logsAvailable": a.cfg.Logs != ""})
}
func (a *App) auditList(w http.ResponseWriter, r *http.Request) {
if _, ok := a.require(w, r, true); !ok {
return
}
rows, err := a.db.Query("SELECT id,username,action,target,result,created FROM audit ORDER BY id DESC LIMIT 200")
if err != nil {
a.internal(w, err)
return
}
defer rows.Close()
out := []map[string]any{}
for rows.Next() {
var id, created int64
var username, action, target, result string
if err = rows.Scan(&id, &username, &action, &target, &result, &created); err != nil {
a.internal(w, err)
return
}
out = append(out, map[string]any{"id": id, "username": username, "action": action, "target": target, "result": result, "created": created})
}
respond(w, 200, out)
}
func (a *App) users(w http.ResponseWriter, r *http.Request) {
if _, ok := a.require(w, r, true); !ok {
return
}
rows, err := a.db.Query("SELECT id,username,role,created FROM users ORDER BY id")
if err != nil {
a.internal(w, err)
return
}
defer rows.Close()
out := []map[string]any{}
for rows.Next() {
var id, created int64
var username, role string
if err = rows.Scan(&id, &username, &role, &created); err != nil {
a.internal(w, err)
return
}
out = append(out, map[string]any{"id": id, "username": username, "role": role, "created": created})
}
respond(w, 200, out)
}
func (a *App) createUser(w http.ResponseWriter, r *http.Request) {
s, ok := a.require(w, r, true)
if !ok {
return
}
var body struct {
Username string `json:"username"`
Password string `json:"password"`
Role string `json:"role"`
}
if !readJSON(w, r, &body) {
return
}
if !validName(body.Username) || (body.Role != "admin" && body.Role != "editor") {
fail(w, 400, "INVALID_INPUT")
return
}
hash, err := hashPassword(body.Password)
if err != nil {
fail(w, 400, "INVALID_PASSWORD")
return
}
if _, err = a.db.Exec("INSERT INTO users(username,password,role,created) VALUES(?,?,?,?)", body.Username, hash, body.Role, time.Now().UnixMilli()); err != nil {
fail(w, 409, "CONFLICT")
return
}
a.audit(s, "user_create", body.Username, "success")
respond(w, 201, map[string]bool{"ok": true})
}