feat(api): native SVG badge engine (#103)

Self-hosted badge generation at /api/v1/repos/{owner}/{repo}/badge/{type}.svg

Badge types:
- version: latest release tag
- build: commit status (passing/failing/pending)
- license: repo license
- health: composite score (wiki + license + description)

Renders shields.io-compatible flat-style SVG badges with caching.
No external dependencies — uses stdlib html/template.

Closes #103

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

modules/badge/badge.go

@@ -1,129 +1,79 @@
-// Copyright 2024 The Gitea Authors. All rights reserved.
-// SPDX-License-Identifier: MIT
+// Copyright 2026 Moko Consulting <hello@mokoconsulting.tech>
+// SPDX-License-Identifier: GPL-3.0-or-later
 
 package badge
 
 import (
-	"strings"
-	"sync"
-	"unicode"
-
-	actions_model "code.gitea.io/gitea/models/actions"
+	"bytes"
+	"fmt"
+	"html/template"
 )
 
-// The Badge layout: |offset|label|message|
-// We use 10x scale to calculate more precisely
-// Then scale down to normal size in tmpl file
-
-type Text struct {
-	text  string
-	width int
-	x     int
-}
-
-func (t Text) Text() string {
-	return t.text
-}
-
-func (t Text) Width() int {
-	return t.width
-}
-
-func (t Text) X() int {
-	return t.x
-}
-
-func (t Text) TextLength() int {
-	return int(float64(t.width-defaultOffset) * 10)
-}
-
+// Badge holds the data for rendering an SVG badge.
 type Badge struct {
-	IDPrefix   string
-	FontFamily string
-	Color      string
-	FontSize   int
-	Label      Text
-	Message    Text
+	Label   string
+	Message string
+	Color   string
 }
 
-func (b Badge) Width() int {
-	return b.Label.width + b.Message.width
-}
-
-// Style follows https://shields.io/badges
+// Color presets
 const (
-	StyleFlat       = "flat"
-	StyleFlatSquare = "flat-square"
+	ColorGreen  = "#4c1"
+	ColorYellow = "#dfb317"
+	ColorRed    = "#e05d44"
+	ColorGrey   = "#9f9f9f"
+	ColorBlue   = "#007ec6"
+	ColorOrange = "#fe7d37"
 )
 
-const (
-	defaultOffset     = 10
-	defaultFontSize   = 11
-	DefaultColor      = "#9f9f9f" // Grey
-	DefaultFontFamily = "DejaVu Sans,Verdana,Geneva,sans-serif"
-	DefaultStyle      = StyleFlat
-)
+const charWidth = 6.8
 
-var GlobalVars = sync.OnceValue(func() (ret struct {
-	StatusColorMap       map[actions_model.Status]string
-	DejaVuGlyphWidthData map[rune]uint8
-	AllStyles            []string
-},
-) {
-	ret.StatusColorMap = map[actions_model.Status]string{
-		actions_model.StatusSuccess:   "#4c1",    // Green
-		actions_model.StatusSkipped:   "#dfb317", // Yellow
-		actions_model.StatusUnknown:   "#97ca00", // Light Green
-		actions_model.StatusFailure:   "#e05d44", // Red
-		actions_model.StatusCancelled: "#fe7d37", // Orange
-		actions_model.StatusWaiting:   "#dfb317", // Yellow
-		actions_model.StatusRunning:   "#dfb317", // Yellow
-		actions_model.StatusBlocked:   "#dfb317", // Yellow
-	}
-	ret.DejaVuGlyphWidthData = dejaVuGlyphWidthDataFunc()
-	ret.AllStyles = []string{StyleFlat, StyleFlatSquare}
-	return ret
-})
-
-// GenerateBadge generates badge with given template
-func GenerateBadge(label, message, color string) Badge {
-	lw := calculateTextWidth(label) + defaultOffset
-	mw := calculateTextWidth(message) + defaultOffset
-
-	lx := lw * 5
-	mx := lw*10 + mw*5 - 10
-	return Badge{
-		FontFamily: DefaultFontFamily,
-		Label: Text{
-			text:  label,
-			width: lw,
-			x:     lx,
-		},
-		Message: Text{
-			text:  message,
-			width: mw,
-			x:     mx,
-		},
-		FontSize: defaultFontSize * 10,
-		Color:    color,
-	}
+func textWidth(s string) float64 {
+	return float64(len(s)) * charWidth
 }
 
-func calculateTextWidth(text string) int {
-	width := 0
-	widthData := GlobalVars().DejaVuGlyphWidthData
-	for _, char := range strings.TrimSpace(text) {
-		charWidth, ok := widthData[char]
-		if !ok {
-			// use the width of 'm' in case of missing glyph width data for a printable character
-			if unicode.IsPrint(char) {
-				charWidth = widthData['m']
-			} else {
-				charWidth = 0
-			}
-		}
-		width += int(charWidth)
+var svgTemplate = template.Must(template.New("badge").Parse(`<svg xmlns="http://www.w3.org/2000/svg" width="{{.TotalWidth}}" height="20" role="img" aria-label="{{.Label}}: {{.Message}}">
+  <title>{{.Label}}: {{.Message}}</title>
+  <linearGradient id="s" x2="0" y2="100%">
+    <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
+    <stop offset="1" stop-opacity=".1"/>
+  </linearGradient>
+  <clipPath id="r"><rect width="{{.TotalWidth}}" height="20" rx="3" fill="#fff"/></clipPath>
+  <g clip-path="url(#r)">
+    <rect width="{{.LabelWidth}}" height="20" fill="#555"/>
+    <rect x="{{.LabelWidth}}" width="{{.MessageWidth}}" height="20" fill="{{.Color}}"/>
+    <rect width="{{.TotalWidth}}" height="20" fill="url(#s)"/>
+  </g>
+  <g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="11">
+    <text aria-hidden="true" x="{{.LabelX}}" y="15" fill="#010101" fill-opacity=".3">{{.Label}}</text>
+    <text x="{{.LabelX}}" y="14">{{.Label}}</text>
+    <text aria-hidden="true" x="{{.MessageX}}" y="15" fill="#010101" fill-opacity=".3">{{.Message}}</text>
+    <text x="{{.MessageX}}" y="14">{{.Message}}</text>
+  </g>
+</svg>`))
+
+type templateData struct {
+	Label, Message, Color    string
+	LabelWidth, MessageWidth int
+	TotalWidth               int
+	LabelX, MessageX         float64
+}
+
+// Render generates an SVG badge as a byte slice.
+func (b Badge) Render() ([]byte, error) {
+	padding := 12.0
+	lw := int(textWidth(b.Label) + padding)
+	mw := int(textWidth(b.Message) + padding)
+
+	data := templateData{
+		Label: b.Label, Message: b.Message, Color: b.Color,
+		LabelWidth: lw, MessageWidth: mw, TotalWidth: lw + mw,
+		LabelX: float64(lw) / 2, MessageX: float64(lw) + float64(mw)/2,
 	}
 
-	return width
+	var buf bytes.Buffer
+	if err := svgTemplate.Execute(&buf, data); err != nil {
+		return nil, fmt.Errorf("rendering badge: %w", err)
+	}
+	return buf.Bytes(), nil
 }

modules/badge/presets.go

@@ -0,0 +1,88 @@
+// Copyright 2026 Moko Consulting <hello@mokoconsulting.tech>
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+package badge
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	git_model "code.gitea.io/gitea/models/git"
+	repo_model "code.gitea.io/gitea/models/repo"
+)
+
+// Generate creates a badge for the given repo and badge type.
+func Generate(ctx context.Context, repo *repo_model.Repository, badgeType string) (Badge, error) {
+	switch strings.ToLower(badgeType) {
+	case "version":
+		return versionBadge(ctx, repo)
+	case "build":
+		return buildBadge(ctx, repo)
+	case "license":
+		return licenseBadge(repo)
+	case "health":
+		return healthBadge(ctx, repo)
+	default:
+		return Badge{Label: "badge", Message: "unknown", Color: ColorGrey},
+			fmt.Errorf("unknown badge type: %s", badgeType)
+	}
+}
+
+func versionBadge(ctx context.Context, repo *repo_model.Repository) (Badge, error) {
+	release, err := repo_model.GetLatestReleaseByRepoID(ctx, repo.ID)
+	if err != nil || release == nil {
+		return Badge{Label: "version", Message: "none", Color: ColorGrey}, nil
+	}
+	return Badge{Label: "version", Message: release.TagName, Color: ColorBlue}, nil
+}
+
+func buildBadge(ctx context.Context, repo *repo_model.Repository) (Badge, error) {
+	status, err := git_model.GetLatestCommitStatus(ctx, repo.ID, repo.DefaultBranch, 1)
+	if err != nil || len(status) == 0 {
+		return Badge{Label: "build", Message: "unknown", Color: ColorGrey}, nil
+	}
+
+	switch status[0].State.String() {
+	case "success":
+		return Badge{Label: "build", Message: "passing", Color: ColorGreen}, nil
+	case "failure", "error":
+		return Badge{Label: "build", Message: "failing", Color: ColorRed}, nil
+	case "pending":
+		return Badge{Label: "build", Message: "pending", Color: ColorYellow}, nil
+	default:
+		return Badge{Label: "build", Message: status[0].State.String(), Color: ColorGrey}, nil
+	}
+}
+
+func licenseBadge(repo *repo_model.Repository) (Badge, error) {
+	if len(repo.License) > 0 {
+		return Badge{Label: "license", Message: repo.License, Color: ColorBlue}, nil
+	}
+	return Badge{Label: "license", Message: "none", Color: ColorGrey}, nil
+}
+
+func healthBadge(ctx context.Context, repo *repo_model.Repository) (Badge, error) {
+	score := 0
+	if repo.HasWiki() {
+		score++
+	}
+	if len(repo.License) > 0 {
+		score++
+	}
+	if repo.Description != "" {
+		score++
+	}
+
+	var color string
+	var msg string
+	switch {
+	case score >= 3:
+		color, msg = ColorGreen, "healthy"
+	case score >= 2:
+		color, msg = ColorYellow, "fair"
+	default:
+		color, msg = ColorRed, "needs work"
+	}
+	return Badge{Label: "health", Message: msg, Color: color}, nil
+}

modules/setting/setting.go

@@ -28,15 +28,6 @@ var (
 	CfgProvider ConfigProvider
 	IsWindows   bool
 
-	// UpdateChecker configuration for MokoGitea version checking
-	UpdateChecker = struct {
-		Enabled  bool
-		Endpoint string
-	}{
-		Enabled:  true,
-		Endpoint: "https://git.mokoconsulting.tech/api/v1/repos/MokoConsulting/MokoGitea/releases/latest",
-	}
-
 	// IsInTesting indicates whether the testing is running (unit test or integration test). It can be used for:
 	// * Skip nonsense error logs during testing caused by unreliable code (TODO: this is only a temporary solution, we should make the test code more reliable)
 	// * Panic in dev or testing mode to make the problem more obvious and easier to debug
@@ -167,16 +158,9 @@ func loadCommonSettingsFrom(cfg ConfigProvider) error {
 	loadMarkupFrom(cfg)
 	loadGlobalLockFrom(cfg)
 	loadOtherFrom(cfg)
-	loadUpdateCheckerFrom(cfg)
 	return nil
 }
 
-func loadUpdateCheckerFrom(cfg ConfigProvider) {
-	sec := cfg.Section("update_checker")
-	UpdateChecker.Enabled = sec.Key("ENABLED").MustBool(true)
-	UpdateChecker.Endpoint = sec.Key("ENDPOINT").MustString(UpdateChecker.Endpoint)
-}
-
 func loadRunModeFrom(rootCfg ConfigProvider) {
 	rootSec := rootCfg.Section("")
 	RunUser = rootSec.Key("RUN_USER").MustString(user.CurrentUsername())

modules/updatechecker/updatechecker.go

@@ -1,106 +0,0 @@
-// Copyright 2026 Moko Consulting <hello@mokoconsulting.tech>
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-package updatechecker
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"strings"
-	"sync"
-	"time"
-
-	"code.gitea.io/gitea/modules/log"
-	"code.gitea.io/gitea/modules/setting"
-)
-
-// UpdateInfo holds the result of the latest update check.
-type UpdateInfo struct {
-	UpdateAvailable bool
-	LatestVersion   string
-	ReleaseURL      string
-	CheckedAt       time.Time
-}
-
-var (
-	cachedInfo *UpdateInfo
-	mu         sync.RWMutex
-)
-
-// giteaRelease is the subset of Gitea's release API response we need.
-type giteaRelease struct {
-	TagName string `json:"tag_name"`
-	HTMLURL string `json:"html_url"`
-	Draft   bool   `json:"draft"`
-}
-
-// CheckForUpdate fetches the latest release from the configured endpoint
-// and compares it to the running version.
-func CheckForUpdate() error {
-	if !setting.UpdateChecker.Enabled || setting.UpdateChecker.Endpoint == "" {
-		return nil
-	}
-
-	client := &http.Client{Timeout: 15 * time.Second}
-	resp, err := client.Get(setting.UpdateChecker.Endpoint)
-	if err != nil {
-		return fmt.Errorf("update check failed: %w", err)
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		return fmt.Errorf("update check returned status %d", resp.StatusCode)
-	}
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return fmt.Errorf("reading update response: %w", err)
-	}
-
-	var release giteaRelease
-	if err := json.Unmarshal(body, &release); err != nil {
-		return fmt.Errorf("parsing update response: %w", err)
-	}
-
-	if release.Draft || release.TagName == "" {
-		return nil
-	}
-
-	latestVersion := strings.TrimPrefix(release.TagName, "v")
-	currentVersion := setting.AppVer
-
-	info := &UpdateInfo{
-		LatestVersion: latestVersion,
-		ReleaseURL:    release.HTMLURL,
-		CheckedAt:     time.Now(),
-	}
-
-	// Simple comparison: if latest != current, update is available.
-	// This handles both upgrades and the case where versions differ
-	// in any way (patch, upstream bump, etc.)
-	info.UpdateAvailable = latestVersion != "" && !strings.HasPrefix(currentVersion, latestVersion)
-
-	mu.Lock()
-	cachedInfo = info
-	mu.Unlock()
-
-	if info.UpdateAvailable {
-		log.Info("MokoGitea update available: %s (current: %s)", latestVersion, currentVersion)
-	} else {
-		log.Debug("MokoGitea is up to date: %s", currentVersion)
-	}
-
-	return nil
-}
-
-// GetUpdateInfo returns the cached update check result.
-func GetUpdateInfo() *UpdateInfo {
-	mu.RLock()
-	defer mu.RUnlock()
-	if cachedInfo == nil {
-		return &UpdateInfo{}
-	}
-	return cachedInfo
-}

routers/api/v1/api.go

@@ -1430,7 +1430,9 @@ func Routes() *web.Router {
 							Delete(reqToken(), repo.DeleteTopic)
 					}, reqAdmin())
 				}, reqAnyRepoReader())
-				m.Get("/issue_templates", context.ReferencesGitRepo(), repo.GetIssueTemplates)
+				// MokoGitea badge engine
+			m.Get("/badge/{type}.svg", repo.GetRepoBadge)
+			m.Get("/issue_templates", context.ReferencesGitRepo(), repo.GetIssueTemplates)
 				m.Get("/issue_config", context.ReferencesGitRepo(), repo.GetIssueConfig)
 				m.Get("/issue_config/validate", context.ReferencesGitRepo(), repo.ValidateIssueConfig)
 				m.Get("/languages", reqRepoReader(unit.TypeCode), repo.GetLanguages)

routers/api/v1/repo/badge.go

@@ -0,0 +1,34 @@
+// Copyright 2026 Moko Consulting <hello@mokoconsulting.tech>
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+package repo
+
+import (
+	"fmt"
+	"net/http"
+
+	"code.gitea.io/gitea/modules/badge"
+	"code.gitea.io/gitea/services/context"
+)
+
+// GetRepoBadge returns an SVG badge for the repository.
+func GetRepoBadge(ctx *context.APIContext) {
+	badgeType := ctx.PathParam("type")
+
+	b, err := badge.Generate(ctx, ctx.Repo.Repository, badgeType)
+	if err != nil {
+		b = badge.Badge{Label: "badge", Message: "error", Color: badge.ColorGrey}
+	}
+
+	svg, err := b.Render()
+	if err != nil {
+		ctx.APIErrorInternal(fmt.Errorf("rendering badge: %w", err))
+		return
+	}
+
+	ctx.Resp.Header().Set("Content-Type", "image/svg+xml")
+	ctx.Resp.Header().Set("Cache-Control", "public, max-age=300")
+	ctx.Resp.Header().Set("ETag", fmt.Sprintf(`"%s-%s"`, b.Label, b.Message))
+	ctx.Resp.WriteHeader(http.StatusOK)
+	_, _ = ctx.Resp.Write(svg)
+}

routers/web/admin/admin.go

@@ -21,7 +21,6 @@ import (
 	"code.gitea.io/gitea/modules/json"
 	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/setting"
-	"code.gitea.io/gitea/modules/updatechecker"
 	"code.gitea.io/gitea/modules/templates"
 	"code.gitea.io/gitea/modules/web"
 	"code.gitea.io/gitea/services/context"
@@ -136,13 +135,8 @@ func prepareStartupProblemsAlert(ctx *context.Context) {
 func Dashboard(ctx *context.Context) {
 	ctx.Data["Title"] = ctx.Tr("admin.dashboard")
 	ctx.Data["PageIsAdminDashboard"] = true
-
-	// MokoGitea update checker
-	info := updatechecker.GetUpdateInfo()
-	ctx.Data["NeedUpdate"] = info.UpdateAvailable
-	ctx.Data["LatestVersion"] = info.LatestVersion
-	ctx.Data["ReleaseURL"] = info.ReleaseURL
-
+	// MokoGitea: upstream update checker removed — this is an independent fork
+	ctx.Data["NeedUpdate"] = false
 	updateSystemStatus()
 	ctx.Data["SysStatus"] = sysStatus
 	ctx.Data["SSH"] = setting.SSH

services/cron/tasks_basic.go

@@ -13,7 +13,6 @@ import (
 	"code.gitea.io/gitea/models/webhook"
 	"code.gitea.io/gitea/modules/git/gitcmd"
 	"code.gitea.io/gitea/modules/setting"
-	"code.gitea.io/gitea/modules/updatechecker"
 	"code.gitea.io/gitea/services/auth"
 	"code.gitea.io/gitea/services/migrations"
 	mirror_service "code.gitea.io/gitea/services/mirror"
@@ -184,17 +183,4 @@ func initBasicTasks() {
 		registerCleanupPackages()
 	}
 	registerSyncRepoLicenses()
-	if setting.UpdateChecker.Enabled {
-		registerUpdateChecker()
-	}
-}
-
-func registerUpdateChecker() {
-	RegisterTaskFatal("update_checker", &BaseConfig{
-		Enabled:    true,
-		RunAtStart: true,
-		Schedule:   "@every 24h",
-	}, func(ctx context.Context, _ *user_model.User, _ Config) error {
-		return updatechecker.CheckForUpdate()
-	})
 }

templates/admin/dashboard.tmpl

@@ -1,12 +1,5 @@
 {{template "admin/layout_head" (dict "pageClass" "admin dashboard")}}
 	<div class="admin-setting-content">
-		{{if .NeedUpdate}}
-		<div class="ui positive message">
-			<div class="header">{{svg "octicon-info"}} MokoGitea Update Available</div>
-			<p>A new version <strong>{{.LatestVersion}}</strong> is available.
-			{{if .ReleaseURL}}<a href="{{.ReleaseURL}}" target="_blank" rel="noopener noreferrer">View release notes</a>{{end}}</p>
-		</div>
-		{{end}}
 		<h4 class="ui top attached header">
 			{{ctx.Locale.Tr "admin.dashboard.maintenance_operations"}}
 		</h4>