CrossRelay stage 0+1: Go gateway with Anthropic<->Chat Completions relay, Tauri shell, bilingual management UI

- Go gateway (stdlib only): /v1/messages non-stream + SSE, /v1/messages/count_tokens,
  management API /api/* (providers CRUD, apply/restore, settings, backups, logs)
- Protocol conversion: Anthropic Messages <-> Chat Completions with a streaming
  state machine keyed by content block index (text, tool_use, parallel calls)
- ~/.claude/settings.json guarded read/write: timestamped backups, managed env
  keys only, one-click restore
- Tauri 2 shell: spawns the gateway sidecar, parses the random port from stdout,
  stdin pipe watchdog prevents orphans, kills the child on exit
- React frontend: Dashboard/Providers/Settings, zh-CN + en-US, TanStack Query
- Tests: Go table-driven + httptest integration (all green), vitest + RTL

internal/gateway/messages.go

@@ -0,0 +1,127 @@
+package gateway
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+
+	"gitea.rutua.cn/kate522/CrossRelay/internal/anthropic"
+	"gitea.rutua.cn/kate522/CrossRelay/internal/chatcmpl"
+)
+
+// handleMessages serves POST /v1/messages in both streaming and
+// non-streaming modes.
+func (s *Server) handleMessages(w http.ResponseWriter, r *http.Request) {
+	var req anthropic.MessagesRequest
+	if err := decodeJSON(r, &req, 64<<20); err != nil {
+		writeAnthropicError(w, http.StatusBadRequest, "invalid_request_error", "invalid request body: "+err.Error())
+		return
+	}
+	provider := s.store.ActiveClaude()
+	if provider == nil {
+		writeAnthropicError(w, http.StatusBadRequest, "invalid_request_error",
+			"no active provider: activate one in the CrossRelay app")
+		return
+	}
+	model := provider.ResolveModel(req.Model)
+
+	chatReq, err := anthropic.ConvertRequest(&req, model)
+	if err != nil {
+		writeAnthropicError(w, http.StatusBadRequest, "invalid_request_error", err.Error())
+		return
+	}
+
+	rec := recordFrom(r)
+	rec.update(func(e *LogEntry) {
+		e.Model = model
+		e.InputTokens = anthropic.EstimateTokens(&req)
+	})
+
+	client := chatcmpl.NewClient(provider.BaseURL, provider.APIKey)
+	if req.Stream {
+		s.handleStream(w, r, client, chatReq, &req, model, rec)
+		return
+	}
+
+	resp, err := client.Create(r.Context(), chatReq)
+	if err != nil {
+		s.failUpstream(w, rec, err)
+		return
+	}
+	out := anthropic.ConvertResponse(resp, req.Model)
+	rec.update(func(e *LogEntry) {
+		e.OutputTokens = out.Usage.OutputTokens
+	})
+	writeJSON(w, http.StatusOK, out)
+}
+
+// handleStream relays a Chat Completions SSE stream as Anthropic events.
+func (s *Server) handleStream(w http.ResponseWriter, r *http.Request, client *chatcmpl.Client,
+	chatReq *chatcmpl.Request, req *anthropic.MessagesRequest, model string, rec *record) {
+
+	resp, err := client.CreateStream(r.Context(), chatReq)
+	if err != nil {
+		s.failUpstream(w, rec, err)
+		return
+	}
+	defer resp.Body.Close()
+
+	conv := anthropic.NewStreamConverter(w, req.Model, anthropic.EstimateTokens(req))
+	if err := conv.WriteStart(); err != nil {
+		return
+	}
+	stream := chatcmpl.NewStream(resp.Body)
+	for {
+		chunk, err := stream.Next()
+		if errors.Is(err, io.EOF) {
+			break
+		}
+		if err != nil {
+			rec.update(func(e *LogEntry) { e.Error = err.Error() })
+			conv.WriteError("api_error", err.Error())
+			return
+		}
+		if err := conv.OnChunk(chunk); err != nil {
+			rec.update(func(e *LogEntry) { e.Error = err.Error() })
+			conv.WriteError("api_error", err.Error())
+			return
+		}
+	}
+	if err := conv.Finish(); err != nil {
+		rec.update(func(e *LogEntry) { e.Error = err.Error() })
+	}
+}
+
+// handleCountTokens answers POST /v1/messages/count_tokens with a
+// heuristic estimate so Claude Code's context meter keeps working.
+func (s *Server) handleCountTokens(w http.ResponseWriter, r *http.Request) {
+	var req anthropic.MessagesRequest
+	if err := decodeJSON(r, &req, 64<<20); err != nil {
+		writeAnthropicError(w, http.StatusBadRequest, "invalid_request_error", "invalid request body: "+err.Error())
+		return
+	}
+	writeJSON(w, http.StatusOK, anthropic.CountTokensResponse{
+		InputTokens: anthropic.EstimateTokens(&req),
+	})
+}
+
+// failUpstream maps an upstream failure onto an Anthropic error.
+func (s *Server) failUpstream(w http.ResponseWriter, rec *record, err error) {
+	rec.update(func(e *LogEntry) { e.Error = err.Error() })
+	var ue *chatcmpl.UpstreamError
+	if errors.As(err, &ue) {
+		switch {
+		case ue.StatusCode == http.StatusUnauthorized || ue.StatusCode == http.StatusForbidden:
+			writeAnthropicError(w, ue.StatusCode, "authentication_error", ue.Message)
+		case ue.StatusCode == http.StatusTooManyRequests:
+			writeAnthropicError(w, ue.StatusCode, "rate_limit_error", ue.Message)
+		case ue.StatusCode == http.StatusBadRequest:
+			writeAnthropicError(w, http.StatusBadRequest, "invalid_request_error", ue.Message)
+		default:
+			writeAnthropicError(w, http.StatusBadGateway, "api_error", ue.Message)
+		}
+		return
+	}
+	writeAnthropicError(w, http.StatusBadGateway, "api_error", fmt.Sprintf("upstream request failed: %v", err))
+}