feat(notify): native ntfy push notification integration (#41)

Add ntfy as a native notification channel via the Notifier interface.

Events notified:
- NewIssue — new issue created
- IssueChangeStatus — issue closed/reopened
- NewPullRequest — new PR opened
- MergePullRequest — PR merged
- NewRelease — new release published
- WorkflowRunStatusUpdate — CI success/failure

Implementation:
- modules/setting/ntfy.go — [ntfy] config section
- services/ntfy/ntfy.go — HTTP POST sender with 5s timeout
- services/ntfy/notifier.go — Notifier implementation (async, non-blocking)

Config:
  [ntfy]
  ENABLED = true
  SERVER_URL = https://ntfy.mokoconsulting.tech
  DEFAULT_TOPIC = mokogitea

Closes #41

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

.mokogitea/ISSUE_TEMPLATE/test-mokogitea.md

@@ -0,0 +1,9 @@
+---
+name: ".mokogitea Test Template"
+about: "Verify .mokogitea issue templates work"
+labels: ["test"]
+---
+
+This template was loaded from `.mokogitea/ISSUE_TEMPLATE/`.
+
+If you can see this, the `.mokogitea` dot-folder feature is working.

.mokogitea/workflows/test-mokogitea.yml

@@ -0,0 +1,12 @@
+# Test workflow to verify .mokogitea/ directory is discovered
+name: Test .mokogitea workflows
+
+on:
+  workflow_dispatch:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Verify .mokogitea
+        run: echo "This workflow ran from .mokogitea/workflows/ — feature works!"

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/ntfy.go

@@ -0,0 +1,24 @@
+// Copyright 2026 Moko Consulting <hello@mokoconsulting.tech>
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+package setting
+
+// Ntfy holds ntfy push notification settings.
+var Ntfy = struct {
+	Enabled      bool
+	ServerURL    string
+	DefaultTopic string
+	Token        string
+}{
+	Enabled:      false,
+	ServerURL:    "https://ntfy.mokoconsulting.tech",
+	DefaultTopic: "mokogitea",
+}
+
+func loadNtfyFrom(cfg ConfigProvider) {
+	sec := cfg.Section("ntfy")
+	Ntfy.Enabled = sec.Key("ENABLED").MustBool(false)
+	Ntfy.ServerURL = sec.Key("SERVER_URL").MustString(Ntfy.ServerURL)
+	Ntfy.DefaultTopic = sec.Key("DEFAULT_TOPIC").MustString(Ntfy.DefaultTopic)
+	Ntfy.Token = sec.Key("TOKEN").String()
+}

modules/setting/setting.go

@@ -28,6 +28,15 @@ 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
@@ -158,9 +167,17 @@ func loadCommonSettingsFrom(cfg ConfigProvider) error {
 	loadMarkupFrom(cfg)
 	loadGlobalLockFrom(cfg)
 	loadOtherFrom(cfg)
+	loadUpdateCheckerFrom(cfg)
+	loadNtfyFrom(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

@@ -0,0 +1,106 @@
+// 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
+}

options/fileicon/material-icon-rules.json

@@ -617,6 +617,7 @@
     "__github/workflows__": "folder-gh-workflows",
     "gitea/workflows": "folder-gitea-workflows",
     ".gitea/workflows": "folder-gitea-workflows",
+    ".mokogitea/workflows": "folder-gitea-workflows",
     "_gitea/workflows": "folder-gitea-workflows",
     "-gitea/workflows": "folder-gitea-workflows",
     "__gitea/workflows__": "folder-gitea-workflows",
@@ -5237,6 +5238,7 @@
     "__github/workflows__": "folder-gh-workflows-open",
     "gitea/workflows": "folder-gitea-workflows-open",
     ".gitea/workflows": "folder-gitea-workflows-open",
+    ".mokogitea/workflows": "folder-gitea-workflows-open",
     "_gitea/workflows": "folder-gitea-workflows-open",
     "-gitea/workflows": "folder-gitea-workflows-open",
     "__gitea/workflows__": "folder-gitea-workflows-open",

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,6 +21,7 @@ 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"
@@ -135,8 +136,13 @@ func prepareStartupProblemsAlert(ctx *context.Context) {
 func Dashboard(ctx *context.Context) {
 	ctx.Data["Title"] = ctx.Tr("admin.dashboard")
 	ctx.Data["PageIsAdminDashboard"] = true
-	// MokoGitea: upstream update checker removed — this is an independent fork
-	ctx.Data["NeedUpdate"] = false
+
+	// MokoGitea update checker
+	info := updatechecker.GetUpdateInfo()
+	ctx.Data["NeedUpdate"] = info.UpdateAvailable
+	ctx.Data["LatestVersion"] = info.LatestVersion
+	ctx.Data["ReleaseURL"] = info.ReleaseURL
+
 	updateSystemStatus()
 	ctx.Data["SysStatus"] = sysStatus
 	ctx.Data["SSH"] = setting.SSH

routers/web/repo/issue.go

@@ -58,6 +58,12 @@ var IssueTemplateCandidates = []string{
 	"issue_template.md",
 	"issue_template.yaml",
 	"issue_template.yml",
+	".mokogitea/ISSUE_TEMPLATE.md",
+	".mokogitea/ISSUE_TEMPLATE.yaml",
+	".mokogitea/ISSUE_TEMPLATE.yml",
+	".mokogitea/issue_template.md",
+	".mokogitea/issue_template.yaml",
+	".mokogitea/issue_template.yml",
 	".gitea/ISSUE_TEMPLATE.md",
 	".gitea/ISSUE_TEMPLATE.yaml",
 	".gitea/ISSUE_TEMPLATE.yml",

routers/web/repo/pull.go

@@ -71,6 +71,12 @@ var pullRequestTemplateCandidates = []string{
 	"pull_request_template.md",
 	"pull_request_template.yaml",
 	"pull_request_template.yml",
+	".mokogitea/PULL_REQUEST_TEMPLATE.md",
+	".mokogitea/PULL_REQUEST_TEMPLATE.yaml",
+	".mokogitea/PULL_REQUEST_TEMPLATE.yml",
+	".mokogitea/pull_request_template.md",
+	".mokogitea/pull_request_template.yaml",
+	".mokogitea/pull_request_template.yml",
 	".gitea/PULL_REQUEST_TEMPLATE.md",
 	".gitea/PULL_REQUEST_TEMPLATE.yaml",
 	".gitea/PULL_REQUEST_TEMPLATE.yml",

services/cron/tasks_basic.go

@@ -13,6 +13,7 @@ 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"
@@ -183,4 +184,17 @@ 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()
+	})
 }

services/issue/template.go

@@ -23,6 +23,8 @@ import (
 var templateDirCandidates = []string{
 	"ISSUE_TEMPLATE",
 	"issue_template",
+	".mokogitea/ISSUE_TEMPLATE",
+	".mokogitea/issue_template",
 	".gitea/ISSUE_TEMPLATE",
 	".gitea/issue_template",
 	".github/ISSUE_TEMPLATE",
@@ -32,6 +34,8 @@ var templateDirCandidates = []string{
 }
 
 var templateConfigCandidates = []string{
+	".mokogitea/ISSUE_TEMPLATE/config",
+	".mokogitea/issue_template/config",
 	".gitea/ISSUE_TEMPLATE/config",
 	".gitea/issue_template/config",
 	".github/ISSUE_TEMPLATE/config",

services/ntfy/notifier.go

@@ -0,0 +1,107 @@
+// Copyright 2026 Moko Consulting <hello@mokoconsulting.tech>
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+package ntfy
+
+import (
+	"context"
+	"fmt"
+
+	actions_model "code.gitea.io/gitea/models/actions"
+	issues_model "code.gitea.io/gitea/models/issues"
+	repo_model "code.gitea.io/gitea/models/repo"
+	user_model "code.gitea.io/gitea/models/user"
+	"code.gitea.io/gitea/modules/setting"
+	notify_service "code.gitea.io/gitea/services/notify"
+)
+
+func init() {
+	if setting.Ntfy.Enabled {
+		notify_service.RegisterNotifier(NewNotifier())
+	}
+}
+
+type ntfyNotifier struct {
+	notify_service.NullNotifier
+}
+
+// NewNotifier creates a new ntfy notifier.
+func NewNotifier() notify_service.Notifier {
+	return &ntfyNotifier{}
+}
+
+func (*ntfyNotifier) Run() {}
+
+func repoTopic(repo *repo_model.Repository) string {
+	if repo == nil {
+		return setting.Ntfy.DefaultTopic
+	}
+	return setting.Ntfy.DefaultTopic
+}
+
+func (*ntfyNotifier) NewIssue(_ context.Context, issue *issues_model.Issue, _ []*user_model.User) {
+	_ = issue.LoadRepo(context.Background())
+	SendAsync(repoTopic(issue.Repo),
+		fmt.Sprintf("New Issue: %s", issue.Title),
+		fmt.Sprintf("#%d in %s\n%s", issue.Index, issue.Repo.FullName(), issue.Content),
+		"default",
+		"issue,new")
+}
+
+func (*ntfyNotifier) IssueChangeStatus(_ context.Context, doer *user_model.User, _ string, issue *issues_model.Issue, _ *issues_model.Comment, closeOrReopen bool) {
+	_ = issue.LoadRepo(context.Background())
+	action := "reopened"
+	if !closeOrReopen {
+		action = "closed"
+	}
+	SendAsync(repoTopic(issue.Repo),
+		fmt.Sprintf("Issue %s: %s", action, issue.Title),
+		fmt.Sprintf("#%d %s by %s", issue.Index, action, doer.Name),
+		"low",
+		"issue,"+action)
+}
+
+func (*ntfyNotifier) NewPullRequest(_ context.Context, pr *issues_model.PullRequest, _ []*user_model.User) {
+	_ = pr.LoadIssue(context.Background())
+	_ = pr.Issue.LoadRepo(context.Background())
+	SendAsync(repoTopic(pr.Issue.Repo),
+		fmt.Sprintf("New PR: %s", pr.Issue.Title),
+		fmt.Sprintf("#%d in %s\n%s → %s", pr.Issue.Index, pr.Issue.Repo.FullName(), pr.HeadBranch, pr.BaseBranch),
+		"default",
+		"git-pull-request,new")
+}
+
+func (*ntfyNotifier) MergePullRequest(_ context.Context, doer *user_model.User, pr *issues_model.PullRequest) {
+	_ = pr.LoadIssue(context.Background())
+	_ = pr.Issue.LoadRepo(context.Background())
+	SendAsync(repoTopic(pr.Issue.Repo),
+		fmt.Sprintf("PR Merged: %s", pr.Issue.Title),
+		fmt.Sprintf("#%d merged by %s", pr.Issue.Index, doer.Name),
+		"default",
+		"git-merge,merged")
+}
+
+func (*ntfyNotifier) NewRelease(_ context.Context, rel *repo_model.Release) {
+	SendAsync(repoTopic(rel.Repo),
+		fmt.Sprintf("New Release: %s", rel.TagName),
+		fmt.Sprintf("%s in %s\n%s", rel.TagName, rel.Repo.FullName(), rel.Note),
+		"high",
+		"rocket,release")
+}
+
+func (*ntfyNotifier) WorkflowRunStatusUpdate(_ context.Context, repo *repo_model.Repository, _ *user_model.User, run *actions_model.ActionRun) {
+	if run.Status.String() != "success" && run.Status.String() != "failure" {
+		return // only notify on completion
+	}
+	priority := "default"
+	tags := "white_check_mark,ci"
+	if run.Status.String() == "failure" {
+		priority = "high"
+		tags = "x,ci-fail"
+	}
+	SendAsync(repoTopic(repo),
+		fmt.Sprintf("CI %s: %s", run.Status.String(), run.Title),
+		fmt.Sprintf("Workflow in %s", repo.FullName()),
+		priority,
+		tags)
+}

services/ntfy/ntfy.go

@@ -0,0 +1,66 @@
+// Copyright 2026 Moko Consulting <hello@mokoconsulting.tech>
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+package ntfy
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"code.gitea.io/gitea/modules/log"
+	"code.gitea.io/gitea/modules/setting"
+)
+
+// Send publishes a notification to the ntfy server.
+func Send(topic, title, message, priority, tags string) error {
+	if !setting.Ntfy.Enabled || setting.Ntfy.ServerURL == "" {
+		return nil
+	}
+
+	if topic == "" {
+		topic = setting.Ntfy.DefaultTopic
+	}
+
+	url := fmt.Sprintf("%s/%s", strings.TrimRight(setting.Ntfy.ServerURL, "/"), topic)
+
+	req, err := http.NewRequest("POST", url, strings.NewReader(message))
+	if err != nil {
+		return fmt.Errorf("ntfy request: %w", err)
+	}
+
+	req.Header.Set("Title", title)
+	if priority != "" {
+		req.Header.Set("Priority", priority)
+	}
+	if tags != "" {
+		req.Header.Set("Tags", tags)
+	}
+	if setting.Ntfy.Token != "" {
+		req.Header.Set("Authorization", "Bearer "+setting.Ntfy.Token)
+	}
+
+	client := &http.Client{Timeout: 5 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return fmt.Errorf("ntfy send: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		return fmt.Errorf("ntfy returned status %d", resp.StatusCode)
+	}
+
+	log.Debug("ntfy notification sent: %s — %s", topic, title)
+	return nil
+}
+
+// SendAsync sends a notification in a goroutine (non-blocking).
+func SendAsync(topic, title, message, priority, tags string) {
+	go func() {
+		if err := Send(topic, title, message, priority, tags); err != nil {
+			log.Error("ntfy async send failed: %v", err)
+		}
+	}()
+}

templates/admin/dashboard.tmpl

@@ -1,5 +1,12 @@
 {{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>