feat(release):完成双 release 运维闭环

internal/api/admin.go

@@ -85,6 +85,7 @@ func (s *Server) handleAdminIndex(w http.ResponseWriter, r *http.Request) {
 			"/admin/control/translation-glossary-delete",
 			"/admin/control/localized-publish",
 			"/admin/control/localized-rollback",
+			"/admin/control/release-cleanup",
 		},
 	}
 	if r.Method == http.MethodHead {
@@ -144,6 +145,10 @@ func (s *Server) handleAdminControl(w http.ResponseWriter, r *http.Request) {
 		s.handleAdminLocalizedRollback(w, r)
 		return
 	}
+	if action == "release-cleanup" {
+		s.handleAdminReleaseCleanup(w, r)
+		return
+	}
 	request, ok := decodeAdminControlRequest(w, r)
 	if !ok {
 		return
@@ -619,6 +624,34 @@ func (s *Server) handleAdminLocalizedStatus(w http.ResponseWriter, r *http.Reque
 	writeNoStoreJSON(w, http.StatusOK, result)
 }
 
+func (s *Server) handleAdminReleaseCleanup(w http.ResponseWriter, r *http.Request) {
+	backend, ok := s.backend.(ReleaseBackend)
+	if !ok || backend == nil {
+		writeErrorJSON(w, http.StatusServiceUnavailable, "release_backend_unavailable", "Rust bat release backend is unavailable")
+		return
+	}
+	var params backendrpc.ReleaseCleanupParams
+	if !decodeAdminTranslationJSON(w, r, &params) {
+		return
+	}
+	if params.Execute && strings.TrimSpace(params.PlanID) == "" {
+		writeErrorJSON(w, http.StatusBadRequest, "invalid_release_cleanup_params", "execute cleanup requires plan_id from a dry run")
+		return
+	}
+	result, err := backend.ReleaseCleanup(r.Context(), params)
+	if err != nil {
+		s.writeControlBackendError(w, "release-cleanup", err)
+		return
+	}
+	writeNoStoreJSON(w, http.StatusAccepted, AdminControlResponse{
+		Service:   "bat-api",
+		Action:    "release-cleanup",
+		RPCMethod: "release.cleanup",
+		Status:    "accepted",
+		Result:    result,
+	})
+}
+
 func (s *Server) handleAdminDiagnostics(w http.ResponseWriter, r *http.Request) {
 	if r.Method != http.MethodGet && r.Method != http.MethodHead {
 		writeErrorJSON(w, http.StatusMethodNotAllowed, "method_not_allowed", "method not allowed")

internal/api/cdn.go

@@ -14,11 +14,6 @@ func (s *Server) serveCDN(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
 		return
 	}
-	idx := s.index()
-	if idx == nil || idx.ResourceRoot == "" {
-		http.Error(w, "resource root not ready", http.StatusServiceUnavailable)
-		return
-	}
 	_, rel, err := SplitCDNPath(r.URL.Path)
 	if err != nil {
 		http.NotFound(w, r)
@@ -27,15 +22,47 @@ func (s *Server) serveCDN(w http.ResponseWriter, r *http.Request) {
 
 	var entry ResourceEntry
 	var hasEntry bool
-	if s.cfg.RequireIndexed {
-		entry, hasEntry = idx.Lookup(rel)
+	resourceRoot := ""
+	explicitRelease := false
+	channel := r.URL.Query().Get("channel")
+	releaseID := r.URL.Query().Get("release_id")
+	if channel != "" || releaseID != "" {
+		explicitRelease = true
+		channel, releaseID, selectorErr := releaseSelector(r)
+		if selectorErr != nil {
+			http.Error(w, selectorErr.Error(), http.StatusBadRequest)
+			return
+		}
+		selected, selectErr := s.loadReleaseDistribution(r, channel, releaseID)
+		if selectErr != nil {
+			http.Error(w, selectErr.Error(), http.StatusServiceUnavailable)
+			return
+		}
+		if selected == nil || !selected.Available || selected.ResourceRoot == "" {
+			http.Error(w, "selected release is not distributable", http.StatusConflict)
+			return
+		}
+		resourceRoot = selected.ResourceRoot
+		entry, hasEntry = releaseDistributionEntry(selected, rel)
+	} else {
+		idx := s.index()
+		if idx == nil || idx.ResourceRoot == "" {
+			http.Error(w, "resource root not ready", http.StatusServiceUnavailable)
+			return
+		}
+		resourceRoot = idx.ResourceRoot
+		if s.cfg.RequireIndexed {
+			entry, hasEntry = idx.Lookup(rel)
+		}
+	}
+	if explicitRelease || s.cfg.RequireIndexed {
 		if !hasEntry || !entry.Present || !entry.SizeMatch {
 			http.NotFound(w, r)
 			return
 		}
 	}
 
-	abs, err := ResolveUnderRoot(idx.ResourceRoot, rel, true)
+	abs, err := ResolveUnderRoot(resourceRoot, rel, true)
 	if err != nil {
 		http.NotFound(w, r)
 		return
@@ -45,7 +72,7 @@ func (s *Server) serveCDN(w http.ResponseWriter, r *http.Request) {
 		http.NotFound(w, r)
 		return
 	}
-	if s.cfg.RequireIndexed && s.cfg.VerifySize {
+	if (explicitRelease || s.cfg.RequireIndexed) && s.cfg.VerifySize {
 		if hasEntry && entry.Bytes > 0 && uint64(info.Size()) != entry.Bytes {
 			http.Error(w, "size mismatch with release index", http.StatusConflict)
 			return

internal/api/openapi.go

@@ -79,6 +79,52 @@ paths:
       responses:
         "200":
           description: Release summary.
+  /v1/releases:
+    get:
+      summary: Rust-owned official and localized release history
+      parameters:
+        - name: channel
+          in: query
+          schema:
+            type: string
+            enum: [official, localized]
+      responses:
+        "200":
+          description: Release history and manifest/artifact integrity summaries.
+        "503":
+          description: Rust bat release backend is unavailable.
+  /v1/distribution:
+    get:
+      summary: Select a verified official or localized release for distribution
+      parameters:
+        - name: channel
+          in: query
+          schema:
+            type: string
+            enum: [official, localized]
+            default: official
+        - name: release_id
+          in: query
+          schema:
+            type: string
+        - name: offset
+          in: query
+          schema:
+            type: integer
+            minimum: 0
+        - name: limit
+          in: query
+          schema:
+            type: integer
+            minimum: 1
+            maximum: 1000
+      responses:
+        "200":
+          description: Rust-verified selected release and resource manifest page.
+        "409":
+          description: Selected release is missing, stale, damaged, or not distributable.
+        "503":
+          description: Rust bat release backend is unavailable.
   /v1/resources:
     get:
       summary: Paginated resource manifest entries
@@ -551,6 +597,32 @@ paths:
           description: Missing or invalid admin token.
         "503":
           description: Rust bat localized backend is unavailable.
+  /admin/releases/status:
+    get:
+      summary: Read the unified Rust-owned release status view
+      responses:
+        "200":
+          description: Official/localized current relation and integrity status.
+        "401":
+          description: Missing or invalid admin token.
+        "503":
+          description: Rust bat release backend is unavailable.
+  /admin/releases:
+    get:
+      summary: Read Rust-owned historical release summaries
+      parameters:
+        - name: channel
+          in: query
+          schema:
+            type: string
+            enum: [official, localized]
+      responses:
+        "200":
+          description: Historical release summaries.
+        "401":
+          description: Missing or invalid admin token.
+        "503":
+          description: Rust bat release backend is unavailable.
   /admin/control/{action}:
     post:
       summary: Forward an allowlisted control or schedule action to Rust bat
@@ -560,7 +632,7 @@ paths:
           required: true
           schema:
             type: string
-            enum: [reload, refresh, restart, sync, verify, repair, catalog-refresh, schedule-add, schedule-update, schedule-remove, schedule-run, task-cancel, translation-task-update, translation-worker-run, translation-proofread, translation-memory-confirm, translation-glossary-add, translation-glossary-update, translation-glossary-approve, translation-glossary-deprecate, translation-glossary-delete, localized-publish, localized-rollback]
+            enum: [reload, refresh, restart, sync, verify, repair, catalog-refresh, schedule-add, schedule-update, schedule-remove, schedule-run, task-cancel, translation-task-update, translation-worker-run, translation-proofread, translation-memory-confirm, translation-glossary-add, translation-glossary-update, translation-glossary-approve, translation-glossary-deprecate, translation-glossary-delete, localized-publish, localized-rollback, release-cleanup]
       requestBody:
         required: false
         content:

internal/api/release_http.go

@@ -0,0 +1,239 @@
+package api
+
+import (
+	"net/http"
+	"strconv"
+	"strings"
+
+	"bat-api/internal/backendrpc"
+)
+
+func (s *Server) handleReleaseList(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		writeErrorJSON(w, http.StatusMethodNotAllowed, "method_not_allowed", "method not allowed")
+		return
+	}
+	backend, ok := s.backend.(ReleaseBackend)
+	if !ok || backend == nil {
+		writeErrorJSON(w, http.StatusServiceUnavailable, "release_backend_unavailable", "Rust bat release backend is unavailable")
+		return
+	}
+	channel := r.URL.Query().Get("channel")
+	result, err := backend.ReleaseList(r.Context(), backendrpc.ReleaseListParams{Channel: channel})
+	if err != nil {
+		s.writeControlBackendError(w, "release-list", err)
+		return
+	}
+	writeNoStoreJSON(w, http.StatusOK, result)
+}
+
+func (s *Server) handleReleaseDistribution(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		writeErrorJSON(w, http.StatusMethodNotAllowed, "method_not_allowed", "method not allowed")
+		return
+	}
+	channel, releaseID, err := releaseSelector(r)
+	if err != nil {
+		writeErrorJSON(w, http.StatusBadRequest, "invalid_release_selector", err.Error())
+		return
+	}
+	params, err := releaseDistributionParams(r, channel, releaseID)
+	if err != nil {
+		writeErrorJSON(w, http.StatusBadRequest, "invalid_release_query", err.Error())
+		return
+	}
+	page, err := s.requestReleaseDistribution(r, params)
+	if err != nil {
+		writeErrorJSON(w, http.StatusServiceUnavailable, "release_backend_unavailable", err.Error())
+		return
+	}
+	if page == nil {
+		writeErrorJSON(w, http.StatusServiceUnavailable, "release_backend_unavailable", "Rust release distribution returned no result")
+		return
+	}
+	status := http.StatusOK
+	if !page.Available {
+		status = http.StatusConflict
+	}
+	writeNoStoreJSON(w, status, page)
+}
+
+func (s *Server) handleAdminReleaseStatus(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet && r.Method != http.MethodHead {
+		writeErrorJSON(w, http.StatusMethodNotAllowed, "method_not_allowed", "method not allowed")
+		return
+	}
+	if !s.requireAdminToken(w, r) {
+		return
+	}
+	backend, ok := s.backend.(ReleaseBackend)
+	if !ok || backend == nil {
+		writeErrorJSON(w, http.StatusServiceUnavailable, "release_backend_unavailable", "Rust bat release backend is unavailable")
+		return
+	}
+	result, err := backend.ReleaseStatus(r.Context())
+	if err != nil {
+		s.writeControlBackendError(w, "release-status", err)
+		return
+	}
+	if r.Method == http.MethodHead {
+		w.Header().Set("Cache-Control", "no-store")
+		w.WriteHeader(http.StatusOK)
+		return
+	}
+	writeNoStoreJSON(w, http.StatusOK, result)
+}
+
+func (s *Server) handleAdminReleaseList(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet && r.Method != http.MethodHead {
+		writeErrorJSON(w, http.StatusMethodNotAllowed, "method_not_allowed", "method not allowed")
+		return
+	}
+	if !s.requireAdminToken(w, r) {
+		return
+	}
+	backend, ok := s.backend.(ReleaseBackend)
+	if !ok || backend == nil {
+		writeErrorJSON(w, http.StatusServiceUnavailable, "release_backend_unavailable", "Rust bat release backend is unavailable")
+		return
+	}
+	result, err := backend.ReleaseList(r.Context(), backendrpc.ReleaseListParams{
+		Channel: r.URL.Query().Get("channel"),
+	})
+	if err != nil {
+		s.writeControlBackendError(w, "release-list", err)
+		return
+	}
+	if r.Method == http.MethodHead {
+		w.Header().Set("Cache-Control", "no-store")
+		w.WriteHeader(http.StatusOK)
+		return
+	}
+	writeNoStoreJSON(w, http.StatusOK, result)
+}
+
+func releaseSelector(r *http.Request) (string, string, error) {
+	channel := strings.TrimSpace(r.URL.Query().Get("channel"))
+	releaseID := strings.TrimSpace(r.URL.Query().Get("release_id"))
+	if channel == "" {
+		channel = "official"
+	}
+	if channel != "official" && channel != "localized" {
+		return "", "", &releaseSelectorError{message: "channel must be official or localized"}
+	}
+	if releaseID == "." || releaseID == ".." ||
+		strings.Contains(releaseID, "/") ||
+		strings.Contains(releaseID, "\\") ||
+		strings.Contains(releaseID, ":") ||
+		strings.ContainsRune(releaseID, 0) {
+		return "", "", &releaseSelectorError{message: "release_id contains an unsafe path character"}
+	}
+	return channel, releaseID, nil
+}
+
+type releaseSelectorError struct {
+	message string
+}
+
+func (e *releaseSelectorError) Error() string {
+	return e.message
+}
+
+func (s *Server) loadReleaseDistribution(r *http.Request, channel, releaseID string) (*backendrpc.ReleaseDistributionPage, error) {
+	return s.loadReleaseDistributionFrom(r, backendrpc.ReleaseDistributionParams{
+		Channel:   channel,
+		ReleaseID: releaseID,
+		Offset:    0,
+		Limit:     1000,
+	})
+}
+
+func releaseDistributionParams(r *http.Request, channel, releaseID string) (backendrpc.ReleaseDistributionParams, error) {
+	params := backendrpc.ReleaseDistributionParams{
+		Channel:   channel,
+		ReleaseID: releaseID,
+	}
+	query := r.URL.Query()
+	if raw := strings.TrimSpace(query.Get("offset")); raw != "" {
+		offset, err := strconv.ParseUint(raw, 10, 64)
+		if err != nil || uint64(int(^uint(0)>>1)) < offset {
+			return backendrpc.ReleaseDistributionParams{}, &releaseSelectorError{
+				message: "offset must be a non-negative integer",
+			}
+		}
+		params.Offset = int(offset)
+	}
+	if raw := strings.TrimSpace(query.Get("limit")); raw != "" {
+		limit, err := strconv.ParseUint(raw, 10, 64)
+		if err != nil || limit == 0 || limit > 1000 {
+			return backendrpc.ReleaseDistributionParams{}, &releaseSelectorError{
+				message: "limit must be in 1..=1000",
+			}
+		}
+		params.Limit = int(limit)
+	}
+	return params, nil
+}
+
+func (s *Server) requestReleaseDistribution(r *http.Request, params backendrpc.ReleaseDistributionParams) (*backendrpc.ReleaseDistributionPage, error) {
+	backend, ok := s.backend.(ReleaseBackend)
+	if !ok || backend == nil {
+		return nil, &releaseSelectorError{message: "Rust bat release backend is unavailable"}
+	}
+	return backend.ReleaseDistribution(r.Context(), params)
+}
+
+func (s *Server) loadReleaseDistributionFrom(r *http.Request, params backendrpc.ReleaseDistributionParams) (*backendrpc.ReleaseDistributionPage, error) {
+	backend, ok := s.backend.(ReleaseBackend)
+	if !ok || backend == nil {
+		return nil, &releaseSelectorError{message: "Rust bat release backend is unavailable"}
+	}
+	pageSize := 1000
+	result, err := backend.ReleaseDistribution(r.Context(), params)
+	if err != nil || result == nil || !result.Available || result.Total <= len(result.Entries) {
+		return result, err
+	}
+	all := append([]backendrpc.ReleaseDistributionEntry(nil), result.Entries...)
+	for offset := len(all); offset < result.Total; {
+		next, nextErr := backend.ReleaseDistribution(r.Context(), backendrpc.ReleaseDistributionParams{
+			Channel:   params.Channel,
+			ReleaseID: params.ReleaseID,
+			Offset:    offset,
+			Limit:     pageSize,
+		})
+		if nextErr != nil {
+			return nil, nextErr
+		}
+		if next == nil || !next.Available || len(next.Entries) == 0 {
+			return nil, &releaseSelectorError{message: "Rust release distribution page is incomplete"}
+		}
+		all = append(all, next.Entries...)
+		offset = len(all)
+		if len(all) > result.Total {
+			all = all[:result.Total]
+			break
+		}
+	}
+	result.Entries = all
+	result.Offset = 0
+	result.Limit = len(all)
+	return result, nil
+}
+
+func releaseDistributionEntry(page *backendrpc.ReleaseDistributionPage, rel string) (ResourceEntry, bool) {
+	rel = strings.TrimPrefix(strings.ReplaceAll(rel, "\\", "/"), "/")
+	for _, entry := range page.Entries {
+		destination := strings.TrimPrefix(strings.ReplaceAll(entry.Destination, "\\", "/"), "/")
+		if destination == rel {
+			return ResourceEntry{
+				URL:          entry.URL,
+				RelativePath: destination,
+				Bytes:        entry.Bytes,
+				BLAKE3:       entry.BLAKE3,
+				Present:      true,
+				SizeMatch:    true,
+			}, true
+		}
+	}
+	return ResourceEntry{}, false
+}

internal/api/release_http_test.go

@@ -0,0 +1,175 @@
+package api
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"bat-api/internal/backendrpc"
+)
+
+type releaseBackendStub struct {
+	*fakeBackend
+	root               string
+	available          bool
+	distributionParams []backendrpc.ReleaseDistributionParams
+}
+
+func (b *controlBackend) ReleaseStatus(context.Context) (*backendrpc.ReleaseStatusReport, error) {
+	b.calls = append(b.calls, "release.status")
+	return &backendrpc.ReleaseStatusReport{Status: "ready", StatusCode: "distribution.ready"}, nil
+}
+
+func (b *controlBackend) ReleaseList(context.Context, backendrpc.ReleaseListParams) (*backendrpc.ReleaseListReport, error) {
+	b.calls = append(b.calls, "release.list")
+	return &backendrpc.ReleaseListReport{Status: "ready", StatusCode: "distribution.ready"}, nil
+}
+
+func (b *controlBackend) ReleaseDistribution(context.Context, backendrpc.ReleaseDistributionParams) (*backendrpc.ReleaseDistributionPage, error) {
+	b.calls = append(b.calls, "release.distribution")
+	return &backendrpc.ReleaseDistributionPage{Available: false, StatusCode: "distribution.blocked"}, nil
+}
+
+func (b *controlBackend) ReleaseCleanup(context.Context, backendrpc.ReleaseCleanupParams) (*backendrpc.ReleaseCleanupReport, error) {
+	b.calls = append(b.calls, "release.cleanup")
+	return &backendrpc.ReleaseCleanupReport{PlanID: "plan-1"}, nil
+}
+
+func (b *releaseBackendStub) ReleaseStatus(context.Context) (*backendrpc.ReleaseStatusReport, error) {
+	return &backendrpc.ReleaseStatusReport{
+		Status:                     "ready",
+		StatusCode:                 "distribution.ready",
+		OfficialCurrentReleaseID:   "official-1",
+		DefaultDistributionChannel: "official",
+		OfficialDistributionReady:  true,
+	}, nil
+}
+
+func (b *releaseBackendStub) ReleaseList(context.Context, backendrpc.ReleaseListParams) (*backendrpc.ReleaseListReport, error) {
+	return &backendrpc.ReleaseListReport{
+		Status:     "ready",
+		StatusCode: "distribution.ready",
+		Releases: []backendrpc.ReleaseSummary{{
+			Channel:                     "localized",
+			ID:                          "localized-1",
+			ManifestContractStatus:      "valid",
+			ArtifactIntegrityStatus:     "valid",
+			DistributionIntegrityStatus: "valid",
+		}},
+	}, nil
+}
+
+func (b *releaseBackendStub) ReleaseDistribution(_ context.Context, params backendrpc.ReleaseDistributionParams) (*backendrpc.ReleaseDistributionPage, error) {
+	b.distributionParams = append(b.distributionParams, params)
+	return &backendrpc.ReleaseDistributionPage{
+		Available:               b.available,
+		Channel:                 params.Channel,
+		ReleaseID:               params.ReleaseID,
+		ResourceRoot:            b.root,
+		Status:                  "ready",
+		StatusCode:              "distribution.ready",
+		ArtifactIntegrityStatus: "valid",
+		Total:                   1,
+		Limit:                   1000,
+		Entries: []backendrpc.ReleaseDistributionEntry{{
+			URL:         "https://prod-clientpatch.bluearchiveyostar.com/r93_fixture/TableBundles/TableCatalog.bytes",
+			Destination: "prod-clientpatch.bluearchiveyostar.com/r93_fixture/TableBundles/TableCatalog.bytes",
+			Bytes:       21,
+			BLAKE3:      "not-used-by-http-index",
+		}},
+	}, nil
+}
+
+func (*releaseBackendStub) ReleaseCleanup(context.Context, backendrpc.ReleaseCleanupParams) (*backendrpc.ReleaseCleanupReport, error) {
+	return &backendrpc.ReleaseCleanupReport{PlanID: "plan-1"}, nil
+}
+
+func TestReleaseHTTPForwardsTypedSelectionAndDoesNotFallback(t *testing.T) {
+	cfg := DefaultConfig()
+	if err := cfg.Normalize(); err != nil {
+		t.Fatal(err)
+	}
+	backend := &releaseBackendStub{fakeBackend: &fakeBackend{}, root: fixtureRoot(t), available: true}
+	server := NewServer(cfg, backend, nil)
+
+	recorder := httptest.NewRecorder()
+	server.Handler().ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, "/v1/releases?channel=localized", nil))
+	if recorder.Code != http.StatusOK {
+		t.Fatalf("release list status=%d body=%s", recorder.Code, recorder.Body.String())
+	}
+
+	recorder = httptest.NewRecorder()
+	server.Handler().ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, "/v1/distribution?channel=localized&release_id=localized-1&offset=2&limit=10", nil))
+	if recorder.Code != http.StatusOK {
+		t.Fatalf("distribution status=%d body=%s", recorder.Code, recorder.Body.String())
+	}
+	if len(backend.distributionParams) != 1 ||
+		backend.distributionParams[0].Channel != "localized" ||
+		backend.distributionParams[0].ReleaseID != "localized-1" ||
+		backend.distributionParams[0].Offset != 2 ||
+		backend.distributionParams[0].Limit != 10 {
+		t.Fatalf("distribution params=%#v", backend.distributionParams)
+	}
+
+	recorder = httptest.NewRecorder()
+	server.Handler().ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, "/prod-clientpatch.bluearchiveyostar.com/r93_fixture/TableBundles/TableCatalog.bytes?channel=localized&release_id=localized-1", nil))
+	if recorder.Code != http.StatusOK {
+		t.Fatalf("localized CDN status=%d body=%s", recorder.Code, recorder.Body.String())
+	}
+	if recorder.Body.String() != "TABLE_CATALOG_FIXTURE" {
+		t.Fatalf("localized CDN body=%q", recorder.Body.String())
+	}
+
+	cfg.RequireIndexed = false
+	unindexedServer := NewServer(cfg, backend, nil)
+	recorder = httptest.NewRecorder()
+	unindexedServer.Handler().ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, "/prod-clientpatch.bluearchiveyostar.com/r93_fixture/TableBundles/not-listed.bytes?channel=localized&release_id=localized-1", nil))
+	if recorder.Code != http.StatusNotFound {
+		t.Fatalf("unlisted localized CDN status=%d body=%s", recorder.Code, recorder.Body.String())
+	}
+
+	blocked := &releaseBackendStub{fakeBackend: &fakeBackend{}, root: fixtureRoot(t), available: false}
+	blockedServer := NewServer(cfg, blocked, nil)
+	recorder = httptest.NewRecorder()
+	blockedServer.Handler().ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, "/prod-clientpatch.bluearchiveyostar.com/r93_fixture/TableBundles/TableCatalog.bytes?channel=localized", nil))
+	if recorder.Code != http.StatusConflict {
+		t.Fatalf("blocked localized CDN status=%d body=%s", recorder.Code, recorder.Body.String())
+	}
+}
+
+func TestAdminReleaseCleanupRequiresAuthAndForwards(t *testing.T) {
+	cfg := DefaultConfig()
+	cfg.AuthToken = "control-token"
+	if err := cfg.Normalize(); err != nil {
+		t.Fatal(err)
+	}
+	backend := &controlBackend{fakeBackend: &fakeBackend{}}
+	server := NewServer(cfg, backend, nil)
+
+	recorder := httptest.NewRecorder()
+	server.Handler().ServeHTTP(recorder, httptest.NewRequest(http.MethodPost, "/admin/control/release-cleanup", nil))
+	if recorder.Code != http.StatusUnauthorized {
+		t.Fatalf("unauthenticated cleanup status=%d", recorder.Code)
+	}
+
+	request := httptest.NewRequest(http.MethodPost, "/admin/control/release-cleanup", strings.NewReader(`{"execute":false}`))
+	request.Header.Set("Authorization", "Bearer control-token")
+	recorder = httptest.NewRecorder()
+	server.Handler().ServeHTTP(recorder, request)
+	if recorder.Code != http.StatusAccepted {
+		t.Fatalf("dry-run cleanup status=%d body=%s", recorder.Code, recorder.Body.String())
+	}
+	if len(backend.calls) != 1 || backend.calls[0] != "release.cleanup" {
+		t.Fatalf("calls=%v", backend.calls)
+	}
+
+	request = httptest.NewRequest(http.MethodPost, "/admin/control/release-cleanup", strings.NewReader(`{"execute":true}`))
+	request.Header.Set("Authorization", "Bearer control-token")
+	recorder = httptest.NewRecorder()
+	server.Handler().ServeHTTP(recorder, request)
+	if recorder.Code != http.StatusBadRequest {
+		t.Fatalf("missing plan cleanup status=%d body=%s", recorder.Code, recorder.Body.String())
+	}
+}

internal/api/rpc_release.go

@@ -113,6 +113,15 @@ type LocalizedBackend interface {
 	LocalizedRollback(ctx context.Context, params backendrpc.LocalizedRollbackParams) (json.RawMessage, error)
 }
 
+// ReleaseBackend exposes Rust-owned dual-release queries, distribution
+// selection and the explicit cleanup operation.
+type ReleaseBackend interface {
+	ReleaseStatus(ctx context.Context) (*backendrpc.ReleaseStatusReport, error)
+	ReleaseList(ctx context.Context, params backendrpc.ReleaseListParams) (*backendrpc.ReleaseListReport, error)
+	ReleaseDistribution(ctx context.Context, params backendrpc.ReleaseDistributionParams) (*backendrpc.ReleaseDistributionPage, error)
+	ReleaseCleanup(ctx context.Context, params backendrpc.ReleaseCleanupParams) (*backendrpc.ReleaseCleanupReport, error)
+}
+
 // RPCClient adapts *backendrpc.Client to Backend.
 type RPCClient struct {
 	Client *backendrpc.Client
@@ -253,6 +262,22 @@ func (r RPCClient) LocalizedRollback(ctx context.Context, params backendrpc.Loca
 	return r.Client.LocalizedRollback(ctx, params)
 }
 
+func (r RPCClient) ReleaseStatus(ctx context.Context) (*backendrpc.ReleaseStatusReport, error) {
+	return r.Client.ReleaseStatus(ctx)
+}
+
+func (r RPCClient) ReleaseList(ctx context.Context, params backendrpc.ReleaseListParams) (*backendrpc.ReleaseListReport, error) {
+	return r.Client.ReleaseList(ctx, params)
+}
+
+func (r RPCClient) ReleaseDistribution(ctx context.Context, params backendrpc.ReleaseDistributionParams) (*backendrpc.ReleaseDistributionPage, error) {
+	return r.Client.ReleaseDistribution(ctx, params)
+}
+
+func (r RPCClient) ReleaseCleanup(ctx context.Context, params backendrpc.ReleaseCleanupParams) (*backendrpc.ReleaseCleanupReport, error) {
+	return r.Client.ReleaseCleanup(ctx, params)
+}
+
 func (r RPCClient) ParseStatus(ctx context.Context) (json.RawMessage, error) {
 	return r.Client.ParseStatus(ctx)
 }

internal/api/server.go

@@ -51,6 +51,8 @@ func (s *Server) Handler() http.Handler {
 	mux.HandleFunc("/v1/bootstrap", s.handleBootstrap)
 	mux.HandleFunc("/v1/launcher/bootstrap", s.handleLauncherBootstrap)
 	mux.HandleFunc("/v1/release", s.handleRelease)
+	mux.HandleFunc("/v1/releases", s.handleReleaseList)
+	mux.HandleFunc("/v1/distribution", s.handleReleaseDistribution)
 	mux.HandleFunc("/v1/resources", s.handleResources)
 	mux.HandleFunc("/v1/server-info", s.handleServerInfoDebug)
 	mux.HandleFunc("/api/launcher/game/config", s.handleLauncherGameConfig)
@@ -80,6 +82,8 @@ func (s *Server) Handler() http.Handler {
 	mux.HandleFunc("/admin/translation/glossary/query", s.handleAdminGlossaryQuery)
 	mux.HandleFunc("/admin/translation/glossary/diagnose", s.handleAdminGlossaryDiagnose)
 	mux.HandleFunc("/admin/translation/status", s.handleAdminLocalizedStatus)
+	mux.HandleFunc("/admin/releases/status", s.handleAdminReleaseStatus)
+	mux.HandleFunc("/admin/releases", s.handleAdminReleaseList)
 	mux.HandleFunc("/admin/control/", s.handleAdminControl)
 	mux.HandleFunc("/admin/", s.handleAdminIndex)
 	mux.HandleFunc("/"+ServerInfoHost+"/", s.handleServerInfoCDN)
@@ -132,6 +136,8 @@ func (s *Server) handleRoot(w http.ResponseWriter, r *http.Request) {
 				"/v1/bootstrap",
 				"/v1/launcher/bootstrap",
 				"/v1/release",
+				"/v1/releases",
+				"/v1/distribution",
 				"/v1/resources",
 				"/v1/server-info",
 				"/api/launcher/game/config",
@@ -162,6 +168,8 @@ func (s *Server) handleRoot(w http.ResponseWriter, r *http.Request) {
 				"/admin/translation/glossary/query",
 				"/admin/translation/glossary/diagnose",
 				"/admin/translation/status",
+				"/admin/releases/status",
+				"/admin/releases",
 				"/admin/control/{action}",
 			},
 		})