Memos is an open-source, self-hosted note-taking app that brings your everyday thoughts together in a personal timeline. Your data stays yours, and you choose what to keep private or share.
Go dockerfossgomarkdownmemomicroblognote-takingnotesopen-sourceown-your-datareactself-hostedsqlitetimeline
refactor(server): replace Echo with net/http (#6475)
Johnny1511fd125df0
diff --git a/AGENTS.md b/AGENTS.mdindex 94644eee1..558dfe477 100644--- a/AGENTS.md+++ b/AGENTS.md@@ -7,7 +7,7 @@ repo. If a fact here conflicts with source files or CI config, trust the sourceMemos is a self-hosted note-taking app.-- Backend: Go 1.27.2, Echo v5, Connect RPC, gRPC-Gateway, Protocol Buffers.+- Backend: Go 1.27.2, net/http, Connect RPC, gRPC-Gateway, Protocol Buffers.- Frontend: React 19, TypeScript 7, Vite 8, Tailwind CSS v4, React Query v5.- Storage: SQLite, MySQL, PostgreSQL.- Generated API outputs: `proto/gen/` for Go/OpenAPI, `web/src/types/proto/` for TypeScript.@@ -69,7 +69,7 @@ Every root folder is named for what it holds. Read the folder's `doc.go` or `REA| Path | Holds | May import || --- | --- | --- || `cmd/memos/` | Cobra/Viper CLI setup and server startup | anything |-| `server/` | The HTTP process: Echo bootstrap, graceful shutdown, every transport | core, store, provider, markdown, filter, internal |+| `server/` | The HTTP process: net/http bootstrap, graceful shutdown, every transport | core, store, provider, markdown, filter, internal || `server/api/` | Connect/gRPC-Gateway services, ACL config, SSE hub. Thin handlers; rules go to `core/` | || `server/fileserver/` | Native HTTP file serving, thumbnails, range requests | || `server/frontend/` | Static SPA serving; `dist/` is the built SPA baked in by `go:embed` | |diff --git a/go.mod b/go.modindex 63a385724..a1b1d6bc6 100644--- a/go.mod+++ b/go.mod@@ -18,7 +18,6 @@ require (github.com/grpc-ecosystem/grpc-gateway/v2 v2.30.0github.com/johannesboyne/gofakes3 v1.2.0github.com/joho/godotenv v1.5.1- github.com/labstack/echo/v5 v5.3.1github.com/lib/pq v1.12.3github.com/lithammer/shortuuid/v4 v4.2.0github.com/moby/moby/api v1.55.0diff --git a/go.sum b/go.sumindex 686ad6dfd..b56b475f0 100644--- a/go.sum+++ b/go.sum@@ -157,8 +157,6 @@ github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=-github.com/labstack/echo/v5 v5.3.1 h1:75maCxkQVGualckLc/5s/ihgpH1a1Dc6AuGWNVNs6bw=-github.com/labstack/echo/v5 v5.3.1/go.mod h1:4iEGNQiPPZnkfYpNR/L6fINd3NLiGWUD5+eBotFALas=github.com/lib/pq v1.12.3 h1:tTWxr2YLKwIvK90ZXEw8GP7UFHtcbTtty8zsI+YjrfQ=github.com/lib/pq v1.12.3/go.mod h1:/p+8NSbOcwzAEI7wiMXFlgydTwcgTr3OSKMsD2BitpA=github.com/lithammer/shortuuid/v4 v4.2.0 h1:LMFOzVB3996a7b8aBuEXxqOBflbfPQAiVzkIcHO0h8c=diff --git a/internal/README.md b/internal/README.mdindex 14dc16728..69470df36 100644--- a/internal/README.md+++ b/internal/README.md@@ -9,6 +9,7 @@ nothing from `store`, `core`, `server`, `provider`, `markdown`, `filter`, or| --- | --- || `clientip/` | trusted-proxy aware client IP resolution middleware || `email/` | SMTP client, config, and message types |+| `httphandler/` | HTTP response errors, panic recovery, and routing compatibility || `identifier/` | grammar of UIDs and usernames shared by parser, store, and API || `linkmeta/` | HTML metadata, oEmbed, and image fetching for link previews || `motionphoto/` | Live Photo and Motion Photo container parsing |diff --git a/internal/clientip/clientip.go b/internal/clientip/clientip.goindex 382862313..6afcd8fe4 100644--- a/internal/clientip/clientip.go+++ b/internal/clientip/clientip.go@@ -13,7 +13,6 @@ import ("slices""strings"- "github.com/labstack/echo/v5""github.com/pkg/errors")@@ -172,13 +171,11 @@ func FromContext(ctx context.Context) string {// Middleware resolves the client address once per request and stores it in// the request context, where both API transports and the file server read it.-func Middleware(resolver *Resolver) echo.MiddlewareFunc {- return func(next echo.HandlerFunc) echo.HandlerFunc {- return func(c *echo.Context) error {- request := c.Request()- ip := resolver.Resolve(request.RemoteAddr, request.Header)- c.SetRequest(request.WithContext(WithClientIP(request.Context(), ip)))- return next(c)- }+func Middleware(resolver *Resolver) func(http.Handler) http.Handler {+ return func(next http.Handler) http.Handler {+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ ip := resolver.Resolve(r.RemoteAddr, r.Header)+ next.ServeHTTP(w, r.WithContext(WithClientIP(r.Context(), ip)))+ })}}diff --git a/internal/clientip/clientip_test.go b/internal/clientip/clientip_test.goindex 08024fb79..be4d17771 100644--- a/internal/clientip/clientip_test.go+++ b/internal/clientip/clientip_test.go@@ -2,6 +2,7 @@ package clientipimport ("net/http"+ "net/http/httptest""testing""github.com/stretchr/testify/require"@@ -57,3 +58,26 @@ func TestParseTrustedProxiesRejectsGarbage(t *testing.T) {_, err := ParseTrustedProxies([]string{"proxy.internal"})require.Error(t, err)}++func TestMiddlewareCarriesResolvedAddress(t *testing.T) {+ resolver, err := ParseTrustedProxies([]string{"private"})+ require.NoError(t, err)+ for _, test := range []struct{ peer, want string }{+ {"127.0.0.1:1234", "198.51.100.9"},+ {"203.0.113.1:1234", "203.0.113.1"},+ } {+ t.Run(test.peer, func(t *testing.T) {+ handler := Middleware(resolver)(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ require.Equal(t, test.want, FromContext(r.Context()))+ w.WriteHeader(http.StatusNoContent)+ }))+ r := httptest.NewRequest(http.MethodGet, "/", nil)+ r.RemoteAddr = test.peer+ r.Header.Set("X-Forwarded-For", "198.51.100.9")+ rec := httptest.NewRecorder()+ handler.ServeHTTP(rec, r)+ require.Equal(t, http.StatusNoContent, rec.Code)+ require.Empty(t, FromContext(r.Context()), "the original request context must remain unchanged")+ })+ }+}diff --git a/internal/httphandler/httphandler.go b/internal/httphandler/httphandler.gonew file mode 100644index 000000000..71f9f5f57--- /dev/null+++ b/internal/httphandler/httphandler.go@@ -0,0 +1,189 @@+// Package httphandler implements shared HTTP response handling.+package httphandler++import (+ "context"+ "encoding/json"+ "io"+ "log/slog"+ "net/http"+ "net/url"+ "runtime/debug"++ "github.com/pkg/errors"+)++// Error carries a public HTTP error message and an optional underlying cause.+type Error struct {+ Code int+ Message string+ Cause error+}++func (e *Error) Error() string { return e.Message }+func (e *Error) Unwrap() error { return e.Cause }++// Func adapts an error-returning handler without exposing internal errors.+type Func func(http.ResponseWriter, *http.Request) error++func (f Func) ServeHTTP(w http.ResponseWriter, r *http.Request) {+ restoreURL(r)+ response := &responseWriter{ResponseWriter: w}+ if err := f(response, r); err != nil && !response.committed {+ WriteError(w, r, err)+ }+}++// WriteError preserves the public JSON error envelope, including bodyless HEAD errors.+func WriteError(w http.ResponseWriter, r *http.Request, err error) {+ code, message := http.StatusInternalServerError, http.StatusText(http.StatusInternalServerError)+ var publicError *Error+ if errors.As(err, &publicError) {+ code, message = publicError.Code, publicError.Message+ }+ if r.Method == http.MethodHead {+ w.WriteHeader(code)+ return+ }+ _ = JSON(w, code, map[string]string{"message": message})+}++// JSON sends a JSON response.+func JSON(w http.ResponseWriter, code int, value any) error {+ body, err := json.Marshal(value)+ if err != nil {+ return err+ }+ return Blob(w, code, "application/json", append(body, '\n'))+}++// Blob sends bytes with the given content type.+func Blob(w http.ResponseWriter, code int, contentType string, body []byte) error {+ if w.Header().Get("Content-Type") == "" {+ w.Header().Set("Content-Type", contentType)+ }+ w.WriteHeader(code)+ _, err := w.Write(body)+ return err+}++// Text sends a UTF-8 plain text response.+func Text(w http.ResponseWriter, code int, body string) error {+ if w.Header().Get("Content-Type") == "" {+ w.Header().Set("Content-Type", "text/plain; charset=UTF-8")+ }+ w.WriteHeader(code)+ _, err := io.WriteString(w, body)+ return err+}++// NotFound sends the application's router-level 404 response.+func NotFound(w http.ResponseWriter, r *http.Request) {+ WriteError(w, r, &Error{Code: http.StatusNotFound, Message: http.StatusText(http.StatusNotFound)})+}++// GET preserves explicit GET-only routes, without implicitly accepting HEAD.+// Other methods go to fallback when a broader route exists.+func GET(handler, fallback http.Handler) http.Handler {+ return getHandler{handler: handler, fallback: fallback}+}++type getHandler struct {+ handler, fallback http.Handler+}++// AllowedMethods returns the Allow header for a route without a broader fallback.+func (h getHandler) AllowedMethods() string {+ if h.fallback != nil {+ return ""+ }+ return "OPTIONS, GET"+}++func (h getHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {+ restoreURL(r)+ if r.Method == http.MethodGet {+ h.handler.ServeHTTP(w, r)+ return+ }+ if h.fallback != nil {+ h.fallback.ServeHTTP(w, r)+ return+ }+ w.Header().Set("Allow", h.AllowedMethods())+ if r.Method == http.MethodOptions {+ w.WriteHeader(http.StatusNoContent)+ return+ }+ WriteError(w, r, &Error{Code: http.StatusMethodNotAllowed, Message: http.StatusText(http.StatusMethodNotAllowed)})+}++type originalURLKey struct{}++// RoutingRequest preserves literal escaped segments during ServeMux matching.+// The previous router matched RawPath without unescaping parameters. Handlers+// still receive the original URL, with PathValue populated by ServeMux.+func RoutingRequest(r *http.Request) *http.Request {+ if r.URL.RawPath == "" {+ return r+ }+ request := r.WithContext(context.WithValue(r.Context(), originalURLKey{}, r.URL))+ requestURL := *r.URL+ requestURL.Path, requestURL.RawPath = r.URL.RawPath, ""+ request.URL = &requestURL+ return request+}++func restoreURL(r *http.Request) {+ if original, ok := r.Context().Value(originalURLKey{}).(*url.URL); ok {+ r.URL = original+ }+}++// Recover turns panics before a response into JSON 500s, leaving started streams intact.+func Recover(next http.Handler) http.Handler {+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ response := &responseWriter{ResponseWriter: w}+ defer func() {+ if recovered := recover(); recovered != nil {+ if recovered == http.ErrAbortHandler {+ panic(recovered)+ }+ slog.Error("HTTP handler panic", "panic", recovered, "stack", string(debug.Stack()))+ if !response.committed {+ WriteError(w, r, errors.New("handler panic"))+ }+ }+ }()+ next.ServeHTTP(response, r)+ })+}++type responseWriter struct {+ http.ResponseWriter+ committed bool+}++func (w *responseWriter) WriteHeader(code int) {+ if code >= 200 {+ w.committed = true+ }+ w.ResponseWriter.WriteHeader(code)+}++func (w *responseWriter) Write(body []byte) (int, error) {+ w.committed = true+ return w.ResponseWriter.Write(body)+}++func (w *responseWriter) Unwrap() http.ResponseWriter { return w.ResponseWriter }++func (w *responseWriter) Flush() {+ _ = w.FlushError()+}++// FlushError propagates flush errors to http.ResponseController callers.+func (w *responseWriter) FlushError() error {+ w.committed = true+ return http.NewResponseController(w.ResponseWriter).Flush()+}diff --git a/internal/httphandler/httphandler_test.go b/internal/httphandler/httphandler_test.gonew file mode 100644index 000000000..2b1fdb7f1--- /dev/null+++ b/internal/httphandler/httphandler_test.go@@ -0,0 +1,146 @@+package httphandler++import (+ "io"+ "net/http"+ "net/http/httptest"+ "testing"++ "github.com/pkg/errors"+ "github.com/stretchr/testify/require"+)++func TestErrorResponses(t *testing.T) {+ for _, test := range []struct {+ name string+ err error+ method string+ status int+ body string+ }{+ {"internal error is hidden", errors.New("database password"), http.MethodGet, 500, "{\"message\":\"Internal Server Error\"}\n"},+ {"wrapped public error", errors.Wrap(&Error{Code: 403, Message: "forbidden", Cause: errors.New("private detail")}, "context"), http.MethodGet, 403, "{\"message\":\"forbidden\"}\n"},+ {"HEAD has no error body", &Error{Code: 404, Message: "missing"}, http.MethodHead, 404, ""},+ } {+ t.Run(test.name, func(t *testing.T) {+ rec := httptest.NewRecorder()+ Func(func(http.ResponseWriter, *http.Request) error { return test.err }).ServeHTTP(rec, httptest.NewRequest(test.method, "/", nil))+ require.Equal(t, test.status, rec.Code)+ require.Equal(t, test.body, rec.Body.String())+ if test.method == http.MethodHead {+ require.Empty(t, rec.Header().Get("Content-Type"))+ } else {+ require.Equal(t, "application/json", rec.Header().Get("Content-Type"))+ }+ })+ }+}++func TestStartedResponseIsNotReplaced(t *testing.T) {+ for _, test := range []struct {+ name string+ panic bool+ }{+ {"write error", false},+ {"panic", true},+ } {+ t.Run(test.name, func(t *testing.T) {+ handler := Recover(Func(func(w http.ResponseWriter, _ *http.Request) error {+ w.Header().Set("Content-Type", "text/event-stream")+ _, err := io.WriteString(w, ": connected\n\n")+ require.NoError(t, err)+ require.NoError(t, http.NewResponseController(w).Flush())+ if test.panic {+ panic("stream failed")+ }+ return errors.New("client disconnected")+ }))+ rec := httptest.NewRecorder()+ handler.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/", nil))+ require.Equal(t, http.StatusOK, rec.Code)+ require.True(t, rec.Flushed)+ require.Equal(t, "text/event-stream", rec.Header().Get("Content-Type"))+ require.Equal(t, ": connected\n\n", rec.Body.String())+ })+ }+}++type flushErrorWriter struct {+ http.ResponseWriter+ err error+}++func (w flushErrorWriter) FlushError() error { return w.err }++func TestFlushErrorPropagation(t *testing.T) {+ failure := errors.New("flush failed")+ for _, test := range []struct {+ name string+ writer func(http.ResponseWriter) http.ResponseWriter+ wantErr error+ }{+ {"underlying failure", func(w http.ResponseWriter) http.ResponseWriter { return flushErrorWriter{w, failure} }, failure},+ {"unsupported flush", func(w http.ResponseWriter) http.ResponseWriter { return struct{ http.ResponseWriter }{w} }, http.ErrNotSupported},+ } {+ t.Run(test.name, func(t *testing.T) {+ handler := Recover(Func(func(w http.ResponseWriter, _ *http.Request) error {+ require.ErrorIs(t, http.NewResponseController(w).Flush(), test.wantErr)+ return errors.New("error after flush")+ }))+ rec := httptest.NewRecorder()+ handler.ServeHTTP(test.writer(rec), httptest.NewRequest(http.MethodGet, "/", nil))+ require.Empty(t, rec.Body.String(), "a flush must prevent appending an error response")+ })+ }+}++func TestRecoverBeforeResponse(t *testing.T) {+ handler := Recover(http.HandlerFunc(func(http.ResponseWriter, *http.Request) { panic("private detail") }))+ rec := httptest.NewRecorder()+ handler.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/", nil))+ require.Equal(t, http.StatusInternalServerError, rec.Code)+ require.JSONEq(t, `{"message":"Internal Server Error"}`, rec.Body.String())++ abort := Recover(http.HandlerFunc(func(http.ResponseWriter, *http.Request) { panic(http.ErrAbortHandler) }))+ require.PanicsWithValue(t, http.ErrAbortHandler, func() {+ abort.ServeHTTP(httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/", nil))+ })+}++func TestJSONFailureBeforeCommit(t *testing.T) {+ rec := httptest.NewRecorder()+ Func(func(w http.ResponseWriter, _ *http.Request) error {+ return JSON(w, http.StatusCreated, make(chan int))+ }).ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/", nil))+ require.Equal(t, http.StatusInternalServerError, rec.Code)+ require.JSONEq(t, `{"message":"Internal Server Error"}`, rec.Body.String())+}++func TestErrorPreservesExistingContentType(t *testing.T) {+ rec := httptest.NewRecorder()+ Func(func(w http.ResponseWriter, _ *http.Request) error {+ w.Header().Set("Content-Type", "video/mp4")+ return &Error{Code: http.StatusRequestedRangeNotSatisfiable, Message: "requested range not satisfiable"}+ }).ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/", nil))+ require.Equal(t, http.StatusRequestedRangeNotSatisfiable, rec.Code)+ require.Equal(t, "video/mp4", rec.Header().Get("Content-Type"))+ require.JSONEq(t, `{"message":"requested range not satisfiable"}`, rec.Body.String())+}++func TestRoutingPreservesEscapedParametersAndOriginalURL(t *testing.T) {+ mux := http.NewServeMux()+ mux.Handle("/file/{uid}/{filename}", GET(Func(func(w http.ResponseWriter, r *http.Request) error {+ require.Equal(t, "abc%31", r.PathValue("uid"))+ require.Equal(t, "a%2Fb.txt", r.PathValue("filename"))+ require.Equal(t, "/file/abc1/a/b.txt", r.URL.Path)+ require.Equal(t, "/file/abc%31/a%2Fb.txt", r.URL.RawPath)+ require.Equal(t, "true", r.URL.Query().Get("thumbnail"))+ return Text(w, http.StatusOK, "ok")+ }), nil))+ r := httptest.NewRequest(http.MethodGet, "/file/abc%31/a%2Fb.txt?thumbnail=true", nil)+ rec := httptest.NewRecorder()+ mux.ServeHTTP(rec, RoutingRequest(r))+ require.Equal(t, http.StatusOK, rec.Code)+ require.Equal(t, "ok", rec.Body.String())+ require.Equal(t, "/file/abc1/a/b.txt", r.URL.Path, "routing must not mutate the caller's URL")+}diff --git a/server/api/api.go b/server/api/api.goindex b46e9de6e..63664e827 100644--- a/server/api/api.go+++ b/server/api/api.go@@ -4,6 +4,7 @@ import ("context""log/slog""net/http"+ "strings""google.golang.org/grpc/codes""google.golang.org/grpc/status"@@ -11,11 +12,11 @@ import ("connectrpc.com/connect""github.com/grpc-ecosystem/grpc-gateway/v2/runtime"- "github.com/labstack/echo/v5""github.com/pkg/errors""golang.org/x/sync/semaphore""github.com/usememos/memos/core/notification"+ "github.com/usememos/memos/internal/httphandler""github.com/usememos/memos/internal/linkmeta""github.com/usememos/memos/internal/profile""github.com/usememos/memos/internal/ratelimit"@@ -134,8 +135,8 @@ func newGatewayMarshaler() *runtime.HTTPBodyMarshaler {}}-// RegisterGateway registers the gRPC-Gateway and Connect handlers with the given Echo instance.-func (s *APIService) RegisterGateway(ctx context.Context, echoServer *echo.Echo) error {+// NewHandler serves REST, Connect, and SSE with shared authentication policies.+func (s *APIService) NewHandler(ctx context.Context) (http.Handler, error) {// Shared authorizer: one source of truth for authentication and anonymous-access// policy, used by both the gRPC-Gateway middleware and the Connect interceptor.authorizer := NewAuthorizer(s.Store, s.Secret).WithRateLimiter(s.RateLimiter)@@ -146,7 +147,7 @@ func (s *APIService) RegisterGateway(ctx context.Context, echoServer *echo.Echo)// instead so the policy check actually runs on this transport.routeResolver, err := newGatewayRouteResolver()if err != nil {- return errors.Wrap(err, "failed to build gateway route resolver")+ return nil, errors.Wrap(err, "failed to build gateway route resolver")}gatewayAuthMiddleware := func(next runtime.HandlerFunc) runtime.HandlerFunc {@@ -192,37 +193,29 @@ func (s *APIService) RegisterGateway(ctx context.Context, echoServer *echo.Echo)runtime.WithIncomingHeaderMatcher(gatewayIncomingHeaderMatcher),)if err := apipb.RegisterInstanceServiceHandlerServer(ctx, gwMux, s); err != nil {- return err+ return nil, err}if err := apipb.RegisterAuthServiceHandlerServer(ctx, gwMux, s); err != nil {- return err+ return nil, err}if err := apipb.RegisterUserServiceHandlerServer(ctx, gwMux, s); err != nil {- return err+ return nil, err}if err := apipb.RegisterMemoServiceHandlerServer(ctx, gwMux, s); err != nil {- return err+ return nil, err}if err := apipb.RegisterSpaceServiceHandlerServer(ctx, gwMux, s); err != nil {- return err+ return nil, err}if err := apipb.RegisterAttachmentServiceHandlerServer(ctx, gwMux, s); err != nil {- return err+ return nil, err}if err := apipb.RegisterAIServiceHandlerServer(ctx, gwMux, s); err != nil {- return err+ return nil, err}if err := apipb.RegisterIdentityProviderServiceHandlerServer(ctx, gwMux, s); err != nil {- return err+ return nil, err}- gwGroup := echoServer.Group("")- // Register SSE endpoint with same CORS as rest of /api.- RegisterSSERoutes(gwGroup, s.SSEHub, s.Store, s.Secret)- handler := echo.WrapHandler(gwMux)-- gwGroup.Any("/api/*", handler)- gwGroup.Any("/file/*", handler)- gwGroup.Any("/api/v1/*", removedAPIVersionHandler(false))// Connect handlers for browser clients (replaces grpc-web).logStacktraces := s.Profile.Demo@@ -240,14 +233,31 @@ func (s *APIService) RegisterGateway(ctx context.Context, echoServer *echo.Echo)return []connect.HandlerOption{connect.WithReadMaxBytes(int(requestBodyLimit(spec.Procedure)))}}))- connectGroup := echoServer.Group("")- connectGroup.Any("/memos.api.*", echo.WrapHandler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {- r.Body = http.MaxBytesReader(w, r.Body, requestBodyLimit(r.URL.Path))- connectMux.ServeHTTP(w, r)- })))- connectGroup.Any("/memos.api.v1.*", removedAPIVersionHandler(true))-- return nil+ // Prefixes within a path segment (memos.api.*) are dispatched explicitly;+ // ServeMux wildcards match complete segments only.+ sseMux := http.NewServeMux()+ RegisterSSERoutes(sseMux, s.SSEHub, s.Store, s.Secret)+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ requestPath := r.URL.Path+ if r.URL.RawPath != "" {+ requestPath = r.URL.RawPath+ }+ switch {+ case requestPath == "/api/sse" && r.Method == http.MethodGet:+ sseMux.ServeHTTP(w, r)+ case strings.HasPrefix(requestPath, "/api/v1/"):+ removedAPIVersionHandler(false).ServeHTTP(w, r)+ case strings.HasPrefix(requestPath, "/memos.api.v1."):+ removedAPIVersionHandler(true).ServeHTTP(w, r)+ case strings.HasPrefix(requestPath, "/memos.api."):+ r.Body = http.MaxBytesReader(w, r.Body, requestBodyLimit(r.URL.Path))+ connectMux.ServeHTTP(w, r)+ case strings.HasPrefix(requestPath, "/api/") || strings.HasPrefix(requestPath, "/file/"):+ gwMux.ServeHTTP(w, r)+ default:+ httphandler.NotFound(w, r)+ }+ }), nil}// removedAPIMessage tells clients of the removed v1 API where it went.@@ -258,13 +268,13 @@ const removedAPIMessage = "API v1 has been removed. Use /api/... for REST and /m// memos.api.v1 routes with 410 Gone, in the error body shape each transport's// clients decode. It exists for one release so old clients fail with a// pointer to the migration; delete it in the release after.-func removedAPIVersionHandler(connectProtocol bool) echo.HandlerFunc {- return func(c *echo.Context) error {+func removedAPIVersionHandler(connectProtocol bool) http.Handler {+ return httphandler.Func(func(w http.ResponseWriter, _ *http.Request) error {if connectProtocol {- return c.JSON(http.StatusGone, map[string]string{"code": connect.CodeUnimplemented.String(), "message": removedAPIMessage})+ return httphandler.JSON(w, http.StatusGone, map[string]string{"code": connect.CodeUnimplemented.String(), "message": removedAPIMessage})}- return c.JSON(http.StatusGone, map[string]any{"code": int(codes.Unimplemented), "message": removedAPIMessage})- }+ return httphandler.JSON(w, http.StatusGone, map[string]any{"code": int(codes.Unimplemented), "message": removedAPIMessage})+ })}func setAPIResponseNoStoreHeaders(header http.Header) {diff --git a/server/api/api_test.go b/server/api/api_test.goindex 1b03cc6de..f10e505d6 100644--- a/server/api/api_test.go+++ b/server/api/api_test.go@@ -8,14 +8,15 @@ import ("strings""testing"- "github.com/labstack/echo/v5""github.com/stretchr/testify/require")func TestRemovedAPIVersionRoutesReturnGone(t *testing.T) {svc, _ := newUploadTestService(t)- e := echo.New()- require.NoError(t, svc.RegisterGateway(context.Background(), e))+ e := http.NewServeMux()+ apiHandler, handlerErr := svc.NewHandler(context.Background())+ require.NoError(t, handlerErr)+ e.Handle("/", apiHandler)tests := []struct {method stringdiff --git a/server/api/attachment_upload_transport_test.go b/server/api/attachment_upload_transport_test.goindex d8144a2cb..5be8b70b7 100644--- a/server/api/attachment_upload_transport_test.go+++ b/server/api/attachment_upload_transport_test.go@@ -10,7 +10,6 @@ import ("testing""connectrpc.com/connect"- "github.com/labstack/echo/v5""github.com/stretchr/testify/require""google.golang.org/protobuf/encoding/protojson""google.golang.org/protobuf/proto"@@ -37,8 +36,10 @@ func TestUploadAttachmentTransports(t *testing.T) {require.NoError(t, err)token, _, err := auth.GenerateAccessTokenV2(user.ID, user.Username, string(user.Role), string(user.RowStatus), user.PasswordHash, []byte(svc.Secret))require.NoError(t, err)- e := echo.New()- require.NoError(t, svc.RegisterGateway(context.Background(), e))+ e := http.NewServeMux()+ apiHandler, handlerErr := svc.NewHandler(context.Background())+ require.NoError(t, handlerErr)+ e.Handle("/", apiHandler)for _, path := range []string{"/api/attachments:upload", attachmentUploadProcedure} {t.Run(path, func(t *testing.T) {diff --git a/server/api/sse_handler.go b/server/api/sse_handler.goindex 80125014d..f756edf8f 100644--- a/server/api/sse_handler.go+++ b/server/api/sse_handler.go@@ -6,8 +6,7 @@ import ("net/http""time"- "github.com/labstack/echo/v5"-+ "github.com/usememos/memos/internal/httphandler""github.com/usememos/memos/server/auth""github.com/usememos/memos/store")@@ -19,34 +18,29 @@ const (sseHeartbeatComment = ": heartbeat\n\n")-type sseRouteRegistrar interface {- GET(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) echo.RouteInfo-}--// RegisterSSERoutes registers the SSE endpoint on the given Echo router.-func RegisterSSERoutes(router sseRouteRegistrar, hub *SSEHub, storeInstance *store.Store, secret string) {+// RegisterSSERoutes registers the SSE endpoint.+func RegisterSSERoutes(mux *http.ServeMux, hub *SSEHub, storeInstance *store.Store, secret string) {authenticator := auth.NewAuthenticator(storeInstance, secret)- router.GET("/api/sse", func(c *echo.Context) error {- return handleSSE(c, hub, authenticator)- })+ mux.Handle("/api/sse", httphandler.GET(httphandler.Func(func(w http.ResponseWriter, r *http.Request) error {+ return handleSSE(w, r, hub, authenticator)+ }), nil))}// handleSSE handles the SSE connection for live memo refresh.// Authentication is done via Bearer token in the Authorization header.-func handleSSE(c *echo.Context, hub *SSEHub, authenticator *auth.Authenticator) error {+func handleSSE(w http.ResponseWriter, r *http.Request, hub *SSEHub, authenticator *auth.Authenticator) error {// Authenticate the request.- authHeader := c.Request().Header.Get("Authorization")- result := authenticator.Authenticate(c.Request().Context(), authHeader)+ authHeader := r.Header.Get("Authorization")+ result := authenticator.Authenticate(r.Context(), authHeader)if result == nil {- return c.JSON(http.StatusUnauthorized, map[string]string{"error": "authentication required"})+ return httphandler.JSON(w, http.StatusUnauthorized, map[string]string{"error": "authentication required"})}userID := getSSEClientUserID(result)if userID == 0 {- return c.JSON(http.StatusUnauthorized, map[string]string{"error": "authentication required"})+ return httphandler.JSON(w, http.StatusUnauthorized, map[string]string{"error": "authentication required"})}// Set SSE headers.- w := c.Response()w.Header().Set("Content-Type", "text/event-stream")w.Header().Set("Cache-Control", "no-cache")w.Header().Set("Connection", "keep-alive")@@ -67,7 +61,7 @@ func handleSSE(c *echo.Context, hub *SSEHub, authenticator *auth.Authenticator)client := hub.Subscribe()defer hub.Unsubscribe(client)- ctx := c.Request().Context()+ ctx := r.Context()slog.Debug("SSE client connected", "userID", userID)diff --git a/server/api/test/sse_handler_test.go b/server/api/test/sse_handler_test.goindex a05a3d81f..d7b5fa01a 100644--- a/server/api/test/sse_handler_test.go+++ b/server/api/test/sse_handler_test.go@@ -9,7 +9,6 @@ import ("testing""time"- "github.com/labstack/echo/v5""github.com/stretchr/testify/require"apipb "github.com/usememos/memos/proto/gen/api"@@ -35,7 +34,7 @@ func TestSSEHandler_Authentication(t *testing.T) {)require.NoError(t, err)- e := echo.New()+ e := http.NewServeMux()api.RegisterSSERoutes(e, ts.Service.SSEHub, ts.Store, ts.Secret)t.Run("no token returns 401", func(t *testing.T) {diff --git a/server/api/test/user_service_password_test.go b/server/api/test/user_service_password_test.goindex 45186bfd1..0035114de 100644--- a/server/api/test/user_service_password_test.go+++ b/server/api/test/user_service_password_test.go@@ -7,7 +7,6 @@ import ("strings""testing"- "github.com/labstack/echo/v5""github.com/stretchr/testify/require""golang.org/x/crypto/bcrypt""google.golang.org/grpc/codes"@@ -70,8 +69,10 @@ func TestPasswordChangeRejectsOldAccessToken(t *testing.T) {authenticator := auth.NewAuthenticator(ts.Store, ts.Secret)require.NotNil(t, authenticator.Authenticate(ctx, "Bearer "+oldAccess))- e := echo.New()- require.NoError(t, ts.Service.RegisterGateway(ctx, e))+ e := http.NewServeMux()+ apiHandler, handlerErr := ts.Service.NewHandler(ctx)+ require.NoError(t, handlerErr)+ e.Handle("/", apiHandler)updatePassword := func(password, cookie string) *httptest.ResponseRecorder {t.Helper()method, path := http.MethodPatch, "/api/users/password-victim?updateMask=password"diff --git a/server/cors.go b/server/cors.goindex 1418d2381..722e744b7 100644--- a/server/cors.go+++ b/server/cors.go@@ -1,41 +1,57 @@package serverimport (+ "net/http""net/url""strings"- "github.com/labstack/echo/v5"- "github.com/labstack/echo/v5/middleware"-+ "github.com/usememos/memos/internal/httphandler""github.com/usememos/memos/internal/profile")-func newCORSMiddleware(profile *profile.Profile) echo.MiddlewareFunc {- return middleware.CORSWithConfig(middleware.CORSConfig{- // The API is open to any origin so that token-authenticated clients- // (Access Token V2 / PAT in the Authorization header) can call it from- // anywhere. Credentials — i.e. the SameSite=Lax refresh-token cookie — are- // granted only to trusted origins (same host or the configured InstanceURL).- //- // AllowCredentials stays false here on purpose: the per-origin- // Access-Control-Allow-Credentials header is set inside the func below.- // Do NOT switch this to AllowCredentials:true — emitting that header for- // every reflected origin would let a malicious same-site subdomain read the- // cookie-authenticated /auth/refresh response and steal an access token.- AllowCredentials: false,- UnsafeAllowOriginFunc: func(c *echo.Context, origin string) (string, bool, error) {- // Never reflect the opaque "null" origin (sandboxed iframes, file://).- if origin == "null" {- return "", false, nil+func newCORSMiddleware(profile *profile.Profile, mux *http.ServeMux) func(http.Handler) http.Handler {+ return func(next http.Handler) http.Handler {+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ h := w.Header()+ h.Add("Vary", "Origin")+ origin := r.Header.Get("Origin")+ preflight := r.Method == http.MethodOptions+ allowMethods := ""+ if preflight {+ handler, _ := mux.Handler(httphandler.RoutingRequest(r))+ if route, ok := handler.(interface{ AllowedMethods() string }); ok {+ allowMethods = route.AllowedMethods()+ if allowMethods != "" {+ h.Set("Allow", allowMethods)+ }+ }+ }+ if origin != "" && origin != "null" {+ h.Set("Access-Control-Allow-Origin", origin)+ // Cookie access remains restricted to trusted origins. Other origins+ // may use Authorization tokens, but must not read credentialed responses.+ if isAllowedCORSOrigin(profile, r.Host, origin) {+ h.Set("Access-Control-Allow-Credentials", "true")+ }+ if preflight {+ h.Add("Vary", "Access-Control-Request-Method")+ h.Add("Vary", "Access-Control-Request-Headers")+ if allowMethods == "" {+ allowMethods = "GET,HEAD,PUT,PATCH,POST,DELETE"+ }+ h.Set("Access-Control-Allow-Methods", allowMethods)+ if headers := r.Header.Get("Access-Control-Request-Headers"); headers != "" {+ h.Set("Access-Control-Allow-Headers", headers)+ }+ }}- // Trusted origins additionally get credentialed (cookie) access.- if isAllowedCORSOrigin(profile, c.Request().Host, origin) {- c.Response().Header().Set(echo.HeaderAccessControlAllowCredentials, "true")+ if preflight {+ w.WriteHeader(http.StatusNoContent)+ return}- // Reflect every origin; only trusted ones carry the credentials header.- return origin, true, nil- },- })+ next.ServeHTTP(w, r)+ })+ }}func isAllowedCORSOrigin(profile *profile.Profile, requestHost, origin string) bool {diff --git a/server/cors_test.go b/server/cors_test.goindex a13a4851d..a229e7917 100644--- a/server/cors_test.go+++ b/server/cors_test.go@@ -6,8 +6,7 @@ import ("strings""testing"- "github.com/labstack/echo/v5"-+ "github.com/usememos/memos/internal/httphandler""github.com/usememos/memos/internal/profile")@@ -80,11 +79,12 @@ func TestAllowedCORSOrigin(t *testing.T) {}func TestCORSMiddleware(t *testing.T) {- e := echo.New()- e.Use(newCORSMiddleware(&profile.Profile{InstanceURL: "https://memos.example"}))- e.POST("/api/test", func(c *echo.Context) error {- return c.NoContent(http.StatusOK)- })+ e := http.NewServeMux()+ handler := newCORSMiddleware(&profile.Profile{InstanceURL: "https://memos.example"}, e)(e)+ e.Handle("POST /api/test", httphandler.Func(func(w http.ResponseWriter, _ *http.Request) error {+ w.WriteHeader(http.StatusOK)+ return nil+ }))t.Run("trusted origin gets credentialed access", func(t *testing.T) {req := httptest.NewRequest(http.MethodOptions, "/api/test", nil)@@ -92,7 +92,7 @@ func TestCORSMiddleware(t *testing.T) {req.Header.Set("Access-Control-Request-Method", http.MethodPost)rec := httptest.NewRecorder()- e.ServeHTTP(rec, req)+ handler.ServeHTTP(rec, req)if rec.Code != http.StatusNoContent {t.Fatalf("expected status %d, got %d", http.StatusNoContent, rec.Code)@@ -111,7 +111,7 @@ func TestCORSMiddleware(t *testing.T) {req.Header.Set("Access-Control-Request-Method", http.MethodPost)rec := httptest.NewRecorder()- e.ServeHTTP(rec, req)+ handler.ServeHTTP(rec, req)if rec.Code != http.StatusNoContent {t.Fatalf("expected status %d, got %d", http.StatusNoContent, rec.Code)@@ -133,7 +133,7 @@ func TestCORSMiddleware(t *testing.T) {req.Header.Set("Access-Control-Request-Headers", "Authorization")rec := httptest.NewRecorder()- e.ServeHTTP(rec, req)+ handler.ServeHTTP(rec, req)if got := rec.Header().Get("Access-Control-Allow-Headers"); !strings.Contains(strings.ToLower(got), "authorization") {t.Fatalf("expected Authorization to be allowed for a cross-origin token client, got %q", got)@@ -146,7 +146,7 @@ func TestCORSMiddleware(t *testing.T) {req.Header.Set("Access-Control-Request-Method", http.MethodPost)rec := httptest.NewRecorder()- e.ServeHTTP(rec, req)+ handler.ServeHTTP(rec, req)if got := rec.Header().Get("Access-Control-Allow-Origin"); got != "" {t.Fatalf("expected null origin not to be reflected, got %q", got)diff --git a/server/doc.go b/server/doc.goindex ad5316308..b5642f638 100644--- a/server/doc.go+++ b/server/doc.go@@ -1,4 +1,4 @@-// Package server is the HTTP process: it boots the Echo server, mounts every+// Package server is the HTTP process: it boots the net/http server, mounts every// transport (server/api, server/fileserver, server/frontend, server/mcp),// and owns HTTP-only concerns such as auth tokens and process configuration.//diff --git a/server/fileserver/fileserver.go b/server/fileserver/fileserver.goindex 849250a67..d211ed0b9 100644--- a/server/fileserver/fileserver.go+++ b/server/fileserver/fileserver.go@@ -16,11 +16,11 @@ import ("time""github.com/disintegration/imaging"- "github.com/labstack/echo/v5""github.com/pkg/errors""golang.org/x/sync/semaphore""github.com/usememos/memos/core/access"+ "github.com/usememos/memos/internal/httphandler""github.com/usememos/memos/internal/imagelimit""github.com/usememos/memos/internal/motionphoto""github.com/usememos/memos/internal/profile"@@ -125,11 +125,10 @@ func NewFileServerService(profile *profile.Profile, store *store.Store, secret s}// RegisterRoutes registers HTTP file serving routes.-func (s *FileServerService) RegisterRoutes(echoServer *echo.Echo) {- fileGroup := echoServer.Group("/file")- fileGroup.GET("/attachments/:uid", s.serveAttachmentFile)- fileGroup.GET("/attachments/:uid/:filename", s.serveAttachmentFile)- fileGroup.GET("/users/:identifier/avatar", s.serveUserAvatar)+func (s *FileServerService) RegisterRoutes(mux *http.ServeMux, fallback http.Handler) {+ mux.Handle("/file/attachments/{uid}", httphandler.GET(httphandler.Func(s.serveAttachmentFile), fallback))+ mux.Handle("/file/attachments/{uid}/{filename}", httphandler.GET(httphandler.Func(s.serveAttachmentFile), fallback))+ mux.Handle("/file/users/{identifier}/avatar", httphandler.GET(httphandler.Func(s.serveUserAvatar), fallback))}// =============================================================================@@ -137,103 +136,103 @@ func (s *FileServerService) RegisterRoutes(echoServer *echo.Echo) {// =============================================================================// serveAttachmentFile serves attachment binary content using native HTTP.-func (s *FileServerService) serveAttachmentFile(c *echo.Context) error {- ctx := c.Request().Context()- c.Response().Header().Set(echo.HeaderCacheControl, privateAttachmentCacheControl)- uid := c.Param("uid")- wantThumbnail := c.QueryParam("thumbnail") == "true"- wantMotion := c.QueryParam("motion") == "true"+func (s *FileServerService) serveAttachmentFile(w http.ResponseWriter, r *http.Request) error {+ ctx := r.Context()+ w.Header().Set("Cache-Control", privateAttachmentCacheControl)+ uid := r.PathValue("uid")+ wantThumbnail := r.URL.Query().Get("thumbnail") == "true"+ wantMotion := r.URL.Query().Get("motion") == "true"// Authorize on metadata alone. Database-stored bytes are loaded only// after the read is permitted, so an unauthorized request never pulls a// blob out of the database.attachment, err := s.Store.GetAttachment(ctx, &store.FindAttachment{UID: &uid})if err != nil {- return echo.NewHTTPError(http.StatusInternalServerError, "failed to get attachment").Wrap(err)+ return &httphandler.Error{Code: http.StatusInternalServerError, Message: "failed to get attachment", Cause: err}}if attachment == nil {- return echo.NewHTTPError(http.StatusNotFound, "attachment not found")+ return &httphandler.Error{Code: http.StatusNotFound, Message: "attachment not found"}}- readClass, err := s.checkAttachmentPermission(ctx, c, attachment)+ readClass, err := s.checkAttachmentPermission(ctx, r, attachment)if err != nil {return err}if readClass == access.MemoReadClassPublic {- c.Response().Header().Set(echo.HeaderCacheControl, publicAttachmentCacheControl)+ w.Header().Set("Cache-Control", publicAttachmentCacheControl)}if attachment.StorageType != storepb.AttachmentStorageType_LOCAL && attachment.StorageType != storepb.AttachmentStorageType_S3 {attachment, err = s.Store.GetAttachment(ctx, &store.FindAttachment{ID: &attachment.ID, GetBlob: true})if err != nil {- return echo.NewHTTPError(http.StatusInternalServerError, "failed to get attachment").Wrap(err)+ return &httphandler.Error{Code: http.StatusInternalServerError, Message: "failed to get attachment", Cause: err}}if attachment == nil {- return echo.NewHTTPError(http.StatusNotFound, "attachment not found")+ return &httphandler.Error{Code: http.StatusNotFound, Message: "attachment not found"}}}if wantMotion {- return s.serveMotionClip(c, attachment)+ return s.serveMotionClip(w, r, attachment)}contentType := sanitizeContentType(attachment.Type)// Stream video/audio to avoid loading entire file into memory.if isMediaType(attachment.Type) {- return s.serveMediaStream(c, attachment, contentType)+ return s.serveMediaStream(w, r, attachment, contentType)}- return s.serveStaticFile(c, attachment, contentType, wantThumbnail)+ return s.serveStaticFile(w, r, attachment, contentType, wantThumbnail)}// serveUserAvatar serves user avatar images.-func (s *FileServerService) serveUserAvatar(c *echo.Context) error {- ctx := c.Request().Context()+func (s *FileServerService) serveUserAvatar(w http.ResponseWriter, r *http.Request) error {+ ctx := r.Context()allowAnonymous, err := s.Store.AllowsAnonymousAccess(ctx)if err != nil {- return echo.NewHTTPError(http.StatusInternalServerError, "failed to get instance access policy").Wrap(err)+ return &httphandler.Error{Code: http.StatusInternalServerError, Message: "failed to get instance access policy", Cause: err}}cacheControl := cacheMaxAge// On a private instance, avatars are not exposed to anonymous visitors; a// valid session, access token, or PAT is required.if !allowAnonymous {cacheControl = privateAttachmentCacheControl- viewer, err := s.getCurrentUser(ctx, c)+ viewer, err := s.getCurrentUser(ctx, r)if err != nil {- return echo.NewHTTPError(http.StatusInternalServerError, "failed to get current user").Wrap(err)+ return &httphandler.Error{Code: http.StatusInternalServerError, Message: "failed to get current user", Cause: err}}if viewer == nil {- return echo.NewHTTPError(http.StatusUnauthorized, "unauthorized access")+ return &httphandler.Error{Code: http.StatusUnauthorized, Message: "unauthorized access"}}}- identifier := c.Param("identifier")+ identifier := r.PathValue("identifier")user, err := s.Store.GetUser(ctx, &store.FindUser{Username: &identifier})if err != nil {- return echo.NewHTTPError(http.StatusInternalServerError, "failed to get user").Wrap(err)+ return &httphandler.Error{Code: http.StatusInternalServerError, Message: "failed to get user", Cause: err}}if user == nil {- return echo.NewHTTPError(http.StatusNotFound, "user not found")+ return &httphandler.Error{Code: http.StatusNotFound, Message: "user not found"}}if user.AvatarURL == "" {- return echo.NewHTTPError(http.StatusNotFound, "avatar not found")+ return &httphandler.Error{Code: http.StatusNotFound, Message: "avatar not found"}}imageType, imageData, err := parseDataURI(user.AvatarURL)if err != nil {- return echo.NewHTTPError(http.StatusInternalServerError, "failed to parse avatar data").Wrap(err)+ return &httphandler.Error{Code: http.StatusInternalServerError, Message: "failed to parse avatar data", Cause: err}}if !avatarAllowedTypes[imageType] {- return echo.NewHTTPError(http.StatusBadRequest, "invalid avatar image type")+ return &httphandler.Error{Code: http.StatusBadRequest, Message: "invalid avatar image type"}}- setSecurityHeaders(c)- c.Response().Header().Set(echo.HeaderCacheControl, cacheControl)+ setSecurityHeaders(w)+ w.Header().Set("Cache-Control", cacheControl)- return c.Blob(http.StatusOK, imageType, imageData)+ return httphandler.Blob(w, http.StatusOK, imageType, imageData)}// =============================================================================@@ -241,57 +240,57 @@ func (s *FileServerService) serveUserAvatar(c *echo.Context) error {// =============================================================================// serveMediaStream serves video/audio files using streaming to avoid memory exhaustion.-func (s *FileServerService) serveMediaStream(c *echo.Context, attachment *store.Attachment, contentType string) error {- setSecurityHeaders(c)- setMediaHeaders(c, contentType, attachment.Type)+func (s *FileServerService) serveMediaStream(w http.ResponseWriter, r *http.Request, attachment *store.Attachment, contentType string) error {+ setSecurityHeaders(w)+ setMediaHeaders(w, contentType, attachment.Type)switch attachment.StorageType {case storepb.AttachmentStorageType_LOCAL:- http.ServeFile(c.Response(), c.Request(), s.resolveLocalPath(attachment.Reference))+ http.ServeFile(w, r, s.resolveLocalPath(attachment.Reference))return nilcase storepb.AttachmentStorageType_S3:- return s.streamS3Object(c, attachment, contentType)+ return s.streamS3Object(w, r, attachment, contentType)default:// Database storage fallback.modTime := time.Unix(attachment.UpdatedTs, 0)- http.ServeContent(c.Response(), c.Request(), attachment.Filename, modTime, bytes.NewReader(attachment.Blob))+ http.ServeContent(w, r, attachment.Filename, modTime, bytes.NewReader(attachment.Blob))return nil}}// serveStaticFile serves non-streaming files (images, documents, etc.).-func (s *FileServerService) serveStaticFile(c *echo.Context, attachment *store.Attachment, contentType string, wantThumbnail bool) error {+func (s *FileServerService) serveStaticFile(w http.ResponseWriter, r *http.Request, attachment *store.Attachment, contentType string, wantThumbnail bool) error {// Generate thumbnail for supported image types.if wantThumbnail && thumbnailSupportedTypes[attachment.Type] {- if thumbnailBlob, err := s.getOrGenerateThumbnail(c.Request().Context(), attachment); err != nil {+ if thumbnailBlob, err := s.getOrGenerateThumbnail(r.Context(), attachment); err != nil {if !errors.Is(err, errUseOriginalForThumbnail) {slog.Warn("failed to get thumbnail", "error", err)}} else {- setSecurityHeaders(c)- setMediaHeaders(c, "image/jpeg", attachment.Type)- return c.Blob(http.StatusOK, "image/jpeg", thumbnailBlob)+ setSecurityHeaders(w)+ setMediaHeaders(w, "image/jpeg", attachment.Type)+ return httphandler.Blob(w, http.StatusOK, "image/jpeg", thumbnailBlob)}}- setSecurityHeaders(c)- setMediaHeaders(c, contentType, attachment.Type)+ setSecurityHeaders(w)+ setMediaHeaders(w, contentType, attachment.Type)// Force download for non-media files to prevent XSS execution.if !strings.HasPrefix(contentType, "image/") && contentType != "application/pdf" {- c.Response().Header().Set(echo.HeaderContentDisposition, fmt.Sprintf("attachment; filename=%q", attachment.Filename))+ w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%q", attachment.Filename))}switch attachment.StorageType {case storepb.AttachmentStorageType_LOCAL:- http.ServeFile(c.Response(), c.Request(), s.resolveLocalPath(attachment.Reference))+ http.ServeFile(w, r, s.resolveLocalPath(attachment.Reference))return nilcase storepb.AttachmentStorageType_S3:- return s.streamS3Object(c, attachment, contentType)+ return s.streamS3Object(w, r, attachment, contentType)default:- return c.Blob(http.StatusOK, contentType, attachment.Blob)+ return httphandler.Blob(w, http.StatusOK, contentType, attachment.Blob)}}@@ -356,39 +355,42 @@ func (s *FileServerService) resolveLocalPath(reference string) string {// single Range so media players and document viewers can seek without a direct// S3 URL. Multipart ranges are ignored and served as a complete response// because S3 does not support multipart range responses.-func (s *FileServerService) streamS3Object(c *echo.Context, attachment *store.Attachment, contentType string) error {- ctx := c.Request().Context()+func (s *FileServerService) streamS3Object(w http.ResponseWriter, r *http.Request, attachment *store.Attachment, contentType string) error {+ ctx := r.Context()driver, s3Object, err := s.Store.ResolveAttachmentS3Driver(ctx, attachment)if err != nil {- return echo.NewHTTPError(http.StatusInternalServerError, "failed to resolve S3 attachment driver").Wrap(err)+ return &httphandler.Error{Code: http.StatusInternalServerError, Message: "failed to resolve S3 attachment driver", Cause: err}}- object, err := driver.GetObjectStream(ctx, s3Object.Key, singleRangeHeader(c.Request().Header))+ object, err := driver.GetObjectStream(ctx, s3Object.Key, singleRangeHeader(r.Header))if err != nil {if errors.Is(err, storage.ErrRangeNotSatisfiable) {- h := c.Response().Header()+ h := w.Header()h.Set("Accept-Ranges", "bytes")var rangeErr *storage.RangeNotSatisfiableErrorif errors.As(err, &rangeErr) && rangeErr.ContentRange != "" {h.Set("Content-Range", rangeErr.ContentRange)}- return echo.NewHTTPError(http.StatusRequestedRangeNotSatisfiable, "requested range not satisfiable")+ return &httphandler.Error{Code: http.StatusRequestedRangeNotSatisfiable, Message: "requested range not satisfiable"}}- return echo.NewHTTPError(http.StatusInternalServerError, "failed to stream from S3").Wrap(err)+ return &httphandler.Error{Code: http.StatusInternalServerError, Message: "failed to stream from S3", Cause: err}}defer object.Body.Close()- h := c.Response().Header()+ h := w.Header()h.Set("Accept-Ranges", "bytes")if object.ContentLength >= 0 {- h.Set(echo.HeaderContentLength, strconv.FormatInt(object.ContentLength, 10))+ h.Set("Content-Length", strconv.FormatInt(object.ContentLength, 10))}status := http.StatusOKif object.ContentRange != "" {h.Set("Content-Range", object.ContentRange)status = http.StatusPartialContent}- return c.Stream(status, contentType, object.Body)+ w.Header().Set("Content-Type", contentType)+ w.WriteHeader(status)+ _, err = io.Copy(w, object.Body)+ return err}// singleRangeHeader returns a Range value only when it contains one range.@@ -597,21 +599,21 @@ func calculateThumbnailDimensions(width, height int) (int, int) {return 0, thumbnailMaxSize // Portrait: constrain height.}-func (s *FileServerService) serveMotionClip(c *echo.Context, attachment *store.Attachment) error {+func (s *FileServerService) serveMotionClip(w http.ResponseWriter, r *http.Request, attachment *store.Attachment) error {motionMedia := attachment.Payload.GetMotionMedia()if motionMedia == nil || motionMedia.Family != storepb.MotionMediaFamily_ANDROID_MOTION_PHOTO || !motionMedia.HasEmbeddedVideo {- return echo.NewHTTPError(http.StatusBadRequest, "attachment does not have motion clip")+ return &httphandler.Error{Code: http.StatusBadRequest, Message: "attachment does not have motion clip"}}- clipBlob, err := s.getOrExtractMotionClip(c.Request().Context(), attachment)+ clipBlob, err := s.getOrExtractMotionClip(r.Context(), attachment)if err != nil {- return echo.NewHTTPError(http.StatusInternalServerError, "failed to get motion clip").Wrap(err)+ return &httphandler.Error{Code: http.StatusInternalServerError, Message: "failed to get motion clip", Cause: err}}- setSecurityHeaders(c)- setMediaHeaders(c, "video/mp4", "video/mp4")+ setSecurityHeaders(w)+ setMediaHeaders(w, "video/mp4", "video/mp4")modTime := time.Unix(attachment.UpdatedTs, 0)- http.ServeContent(c.Response(), c.Request(), attachment.UID+".mp4", modTime, bytes.NewReader(clipBlob))+ http.ServeContent(w, r, attachment.UID+".mp4", modTime, bytes.NewReader(clipBlob))return nil}@@ -656,40 +658,40 @@ func (s *FileServerService) getMotionPath(attachment *store.Attachment) (string,// =============================================================================// checkAttachmentPermission verifies the user has permission to access the attachment.-func (s *FileServerService) checkAttachmentPermission(ctx context.Context, c *echo.Context, attachment *store.Attachment) (access.MemoReadClass, error) {+func (s *FileServerService) checkAttachmentPermission(ctx context.Context, r *http.Request, attachment *store.Attachment) (access.MemoReadClass, error) {// For unlinked attachments, only the creator or an admin can access, as in// the API's GetAttachment.if attachment.MemoID == nil {- user, err := s.getCurrentUser(ctx, c)+ user, err := s.getCurrentUser(ctx, r)if err != nil {- return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusInternalServerError, "failed to get current user").Wrap(err)+ return access.MemoReadClassPrivate, &httphandler.Error{Code: http.StatusInternalServerError, Message: "failed to get current user", Cause: err}}if user == nil {- return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusUnauthorized, "unauthorized access")+ return access.MemoReadClassPrivate, &httphandler.Error{Code: http.StatusUnauthorized, Message: "unauthorized access"}}if !access.CanManageAttachment(user, attachment) {- return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusForbidden, "forbidden access")+ return access.MemoReadClassPrivate, &httphandler.Error{Code: http.StatusForbidden, Message: "forbidden access"}}return access.MemoReadClassPrivate, nil}memo, err := s.Store.GetMemo(ctx, &store.FindMemo{ID: attachment.MemoID})if err != nil {- return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusInternalServerError, "failed to find memo").Wrap(err)+ return access.MemoReadClassPrivate, &httphandler.Error{Code: http.StatusInternalServerError, Message: "failed to find memo", Cause: err}}if memo == nil {- return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusNotFound, "memo not found")+ return access.MemoReadClassPrivate, &httphandler.Error{Code: http.StatusNotFound, Message: "memo not found"}}allowAnonymous, err := s.Store.AllowsAnonymousAccess(ctx)if err != nil {- return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusInternalServerError, "failed to get instance access policy").Wrap(err)+ return access.MemoReadClassPrivate, &httphandler.Error{Code: http.StatusInternalServerError, Message: "failed to get instance access policy", Cause: err}}var sharedMemoID *int32- if shareToken := (*c).QueryParam("share_token"); shareToken != "" {+ if shareToken := r.URL.Query().Get("share_token"); shareToken != "" {ms, err := s.Store.GetMemoShare(ctx, &store.FindMemoShare{UID: &shareToken})if err != nil {- return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusInternalServerError, "failed to get memo share").Wrap(err)+ return access.MemoReadClassPrivate, &httphandler.Error{Code: http.StatusInternalServerError, Message: "failed to get memo share", Cause: err}}if ms != nil && !isMemoShareExpired(ms) {sharedMemoID = &ms.MemoID@@ -698,45 +700,45 @@ func (s *FileServerService) checkAttachmentPermission(ctx context.Context, c *ecfacts, err := access.ResolveMemoReadFacts(ctx, s.Store, memo)if err != nil {- return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusInternalServerError, "failed to resolve memo access").Wrap(err)+ return access.MemoReadClassPrivate, &httphandler.Error{Code: http.StatusInternalServerError, Message: "failed to resolve memo access", Cause: err}}// Public and exact share-token reads do not depend on browser credentials.// Decide those first so an expired cookie cannot turn an otherwise valid// anonymous file request into a server error.anonymousContext, err := facts.WithViewer(ctx, s.Store, nil, allowAnonymous, sharedMemoID)if err != nil {- return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusInternalServerError, "failed to resolve memo access").Wrap(err)+ return access.MemoReadClassPrivate, &httphandler.Error{Code: http.StatusInternalServerError, Message: "failed to resolve memo access", Cause: err}}if anonymousDecision := access.CheckMemoReadContext(anonymousContext); anonymousDecision.Allowed() {return anonymousDecision.Class, nil}- user, err := s.getCurrentUser(ctx, c)+ user, err := s.getCurrentUser(ctx, r)if err != nil {- return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusInternalServerError, "failed to get current user").Wrap(err)+ return access.MemoReadClassPrivate, &httphandler.Error{Code: http.StatusInternalServerError, Message: "failed to get current user", Cause: err}}readContext, err := facts.WithViewer(ctx, s.Store, user, allowAnonymous, sharedMemoID)if err != nil {- return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusInternalServerError, "failed to find space membership").Wrap(err)+ return access.MemoReadClassPrivate, &httphandler.Error{Code: http.StatusInternalServerError, Message: "failed to find space membership", Cause: err}}decision := access.CheckMemoReadContext(readContext)switch decision.Denial {case access.MemoReadDenialNone:return decision.Class, nilcase access.MemoReadDenialNotFound:- return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusNotFound, "memo not found")+ return access.MemoReadClassPrivate, &httphandler.Error{Code: http.StatusNotFound, Message: "memo not found"}case access.MemoReadDenialUnauthenticated:- return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusUnauthorized, "unauthorized access")+ return access.MemoReadClassPrivate, &httphandler.Error{Code: http.StatusUnauthorized, Message: "unauthorized access"}default:- return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusForbidden, "forbidden access")+ return access.MemoReadClassPrivate, &httphandler.Error{Code: http.StatusForbidden, Message: "forbidden access"}}}// getCurrentUser retrieves the current authenticated user from the request.// Authentication priority: Bearer token (Access Token V2 or PAT) > Refresh token cookie.-func (s *FileServerService) getCurrentUser(ctx context.Context, c *echo.Context) (*store.User, error) {- authHeader := c.Request().Header.Get(echo.HeaderAuthorization)- cookieHeader := c.Request().Header.Get("Cookie")+func (s *FileServerService) getCurrentUser(ctx context.Context, r *http.Request) (*store.User, error) {+ authHeader := r.Header.Get("Authorization")+ cookieHeader := r.Header.Get("Cookie")return s.authenticator.AuthenticateToUser(ctx, authHeader, cookieHeader)}@@ -779,19 +781,19 @@ func isMediaType(mimeType string) bool {}// setSecurityHeaders sets common security headers for all responses.-func setSecurityHeaders(c *echo.Context) {- h := c.Response().Header()+func setSecurityHeaders(w http.ResponseWriter) {+ h := w.Header()h.Set("X-Content-Type-Options", "nosniff")h.Set("X-Frame-Options", "DENY")h.Set("Content-Security-Policy", "default-src 'none'; style-src 'unsafe-inline';")}// setMediaHeaders sets headers for media file responses.-func setMediaHeaders(c *echo.Context, contentType, originalType string) {- h := c.Response().Header()- h.Set(echo.HeaderContentType, contentType)- if h.Get(echo.HeaderCacheControl) == "" {- h.Set(echo.HeaderCacheControl, cacheMaxAge)+func setMediaHeaders(w http.ResponseWriter, contentType, originalType string) {+ h := w.Header()+ h.Set("Content-Type", contentType)+ if h.Get("Cache-Control") == "" {+ h.Set("Cache-Control", cacheMaxAge)}// Support HDR/wide color gamut for images and videos.diff --git a/server/fileserver/fileserver_test.go b/server/fileserver/fileserver_test.goindex dc584643e..b4e121888 100644--- a/server/fileserver/fileserver_test.go+++ b/server/fileserver/fileserver_test.go@@ -18,11 +18,11 @@ import ("testing""time"- "github.com/labstack/echo/v5""github.com/stretchr/testify/require""google.golang.org/protobuf/types/known/fieldmaskpb""google.golang.org/protobuf/types/known/timestamppb"+ "github.com/usememos/memos/internal/httphandler""github.com/usememos/memos/internal/profile""github.com/usememos/memos/internal/random""github.com/usememos/memos/internal/testutil"@@ -80,14 +80,14 @@ func TestServeAttachmentFile_S3(t *testing.T) {}})require.NoError(t, err)- e := echo.New()- fs.RegisterRoutes(e)+ e := http.NewServeMux()+ fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))recorder := httptest.NewRecorder()e.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/%s", attachment.Name, attachment.Filename), nil))require.Equal(t, http.StatusOK, recorder.Code)require.Equal(t, content, recorder.Body.Bytes())- require.Equal(t, "text/plain; charset=utf-8", recorder.Header().Get(echo.HeaderContentType))+ require.Equal(t, "text/plain; charset=utf-8", recorder.Header().Get("Content-Type"))// S3 cannot produce multipart range responses. The fileserver may ignore a// Range request and send the complete representation instead of forwarding@@ -142,8 +142,8 @@ func TestServeAttachmentFile_ShareTokenAllowsDirectMemoAttachment(t *testing.T)require.NoError(t, err)shareToken := share.Name[strings.LastIndex(share.Name, "/")+1:]- e := echo.New()- fs.RegisterRoutes(e)+ e := http.NewServeMux()+ fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/%s?share_token=%s", attachment.Name, attachment.Filename, shareToken), nil)req.AddCookie(newExpiredRefreshTokenCookie(ctx, t, stores, creator.ID, svc.Secret))@@ -179,14 +179,14 @@ func TestServeAttachmentFile_CanonicalRouteAndVisibilityAwareCache(t *testing.T)}})require.NoError(t, err)- e := echo.New()- fs.RegisterRoutes(e)+ e := http.NewServeMux()+ fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))url := "/file/" + attachment.Namerec := httptest.NewRecorder()e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, url, nil))require.Equal(t, http.StatusOK, rec.Code)require.Equal(t, "canonical image", rec.Body.String())- require.Equal(t, publicAttachmentCacheControl, rec.Header().Get(echo.HeaderCacheControl))+ require.Equal(t, publicAttachmentCacheControl, rec.Header().Get("Cache-Control"))_, err = svc.UpdateMemo(creatorCtx, &apipb.UpdateMemoRequest{Memo: &apipb.Memo{Name: memo.Name, Visibility: apipb.Visibility_PROTECTED},@@ -196,7 +196,7 @@ func TestServeAttachmentFile_CanonicalRouteAndVisibilityAwareCache(t *testing.T)rec = httptest.NewRecorder()e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, url, nil))require.Equal(t, http.StatusUnauthorized, rec.Code)- require.Equal(t, privateAttachmentCacheControl, rec.Header().Get(echo.HeaderCacheControl))+ require.Equal(t, privateAttachmentCacheControl, rec.Header().Get("Cache-Control"))}func TestServeAttachmentFileMemoCreatorLifecycle(t *testing.T) {@@ -218,8 +218,8 @@ func TestServeAttachmentFileMemoCreatorLifecycle(t *testing.T) {}})require.NoError(t, err)- e := echo.New()- fs.RegisterRoutes(e)+ e := http.NewServeMux()+ fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))url := fmt.Sprintf("/file/%s/%s", attachment.Name, attachment.Filename)archived := store.Archived_, err = stores.UpdateUser(ctx, &store.UpdateUser{ID: creator.ID, RowStatus: &archived})@@ -269,8 +269,8 @@ func TestServeAttachmentFile_CommentUsesOwnVisibility(t *testing.T) {})require.NoError(t, err)- e := echo.New()- fs.RegisterRoutes(e)+ e := http.NewServeMux()+ fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))url := "/file/" + attachment.Namerec := httptest.NewRecorder()e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, url, nil))@@ -284,7 +284,7 @@ func TestServeAttachmentFile_CommentUsesOwnVisibility(t *testing.T) {rec = httptest.NewRecorder()e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, url, nil))require.Equal(t, http.StatusOK, rec.Code, "changing the context memo must not change attachment access")- require.Equal(t, publicAttachmentCacheControl, rec.Header().Get(echo.HeaderCacheControl))+ require.Equal(t, publicAttachmentCacheControl, rec.Header().Get("Cache-Control"))_, err = svc.UpdateMemo(commenterCtx, &apipb.UpdateMemoRequest{Memo: &apipb.Memo{Name: comment.Name, Visibility: apipb.Visibility_PROTECTED},@@ -294,7 +294,7 @@ func TestServeAttachmentFile_CommentUsesOwnVisibility(t *testing.T) {rec = httptest.NewRecorder()e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, url, nil))require.Equal(t, http.StatusUnauthorized, rec.Code)- require.Equal(t, privateAttachmentCacheControl, rec.Header().Get(echo.HeaderCacheControl))+ require.Equal(t, privateAttachmentCacheControl, rec.Header().Get("Cache-Control"))}func TestServeAttachmentFile_LocalStaticFileSupportsRangeRequests(t *testing.T) {@@ -330,8 +330,8 @@ func TestServeAttachmentFile_LocalStaticFileSupportsRangeRequests(t *testing.T)})require.NoError(t, err)- e := echo.New()- fs.RegisterRoutes(e)+ e := http.NewServeMux()+ fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/%s", attachment.Name, attachment.Filename), nil)req.Header.Set("Range", "bytes=2-5")@@ -400,8 +400,8 @@ func TestServeAttachmentFile_ShareTokenRejectsCommentAttachment(t *testing.T) {require.NoError(t, err)shareToken := share.Name[strings.LastIndex(share.Name, "/")+1:]- e := echo.New()- fs.RegisterRoutes(e)+ e := http.NewServeMux()+ fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/%s?share_token=%s", commentAttachment.Name, commentAttachment.Filename, shareToken), nil)rec := httptest.NewRecorder()@@ -443,8 +443,8 @@ func TestServeAttachmentFile_MotionClip(t *testing.T) {})require.NoError(t, err)- e := echo.New()- fs.RegisterRoutes(e)+ e := http.NewServeMux()+ fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/%s?motion=true", attachment.Name, attachment.Filename), nil)rec := httptest.NewRecorder()@@ -489,8 +489,8 @@ func TestServeAttachmentFile_SVGThumbnailServedAsImageWithSecurityHeaders(t *tes})require.NoError(t, err)- e := echo.New()- fs.RegisterRoutes(e)+ e := http.NewServeMux()+ fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/%s?thumbnail=true", attachment.Name, attachment.Filename), nil)rec := httptest.NewRecorder()@@ -538,8 +538,8 @@ func TestServeAttachmentFile_ThumbnailWithSensitiveMetadataServesOriginal(t *tes})require.NoError(t, err)- e := echo.New()- fs.RegisterRoutes(e)+ e := http.NewServeMux()+ fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/%s?thumbnail=true", attachment.Name, attachment.Filename), nil)rec := httptest.NewRecorder()@@ -698,8 +698,8 @@ func TestServeAttachmentFile_PrivateInstanceDeniesAnonymous(t *testing.T) {})require.NoError(t, err)- e := echo.New()- fs.RegisterRoutes(e)+ e := http.NewServeMux()+ fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))url := fmt.Sprintf("/file/%s/%s", attachment.Name, attachment.Filename)anonymousGet := func() int {@@ -742,8 +742,8 @@ func TestServeUserAvatar_PrivateInstanceRequiresAuth(t *testing.T) {})require.NoError(t, err)- e := echo.New()- fs.RegisterRoutes(e)+ e := http.NewServeMux()+ fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))anonymousGet := func() *httptest.ResponseRecorder {rec := httptest.NewRecorder()@@ -755,7 +755,7 @@ func TestServeUserAvatar_PrivateInstanceRequiresAuth(t *testing.T) {setInstanceAccessMode(ctx, t, stores, storepb.InstanceAccessMode_INSTANCE_ACCESS_MODE_PUBLIC)publicRec := anonymousGet()require.Equal(t, http.StatusOK, publicRec.Code)- require.Equal(t, cacheMaxAge, publicRec.Header().Get(echo.HeaderCacheControl))+ require.Equal(t, cacheMaxAge, publicRec.Header().Get("Cache-Control"))// A stale browser session must not turn a public avatar request into an// authentication error.@@ -764,7 +764,7 @@ func TestServeUserAvatar_PrivateInstanceRequiresAuth(t *testing.T) {rec := httptest.NewRecorder()e.ServeHTTP(rec, req)require.Equal(t, http.StatusOK, rec.Code)- require.Equal(t, "image/png", rec.Header().Get(echo.HeaderContentType))+ require.Equal(t, "image/png", rec.Header().Get("Content-Type"))// Private instance: anonymous avatar access is denied.setInstanceAccessMode(ctx, t, stores, storepb.InstanceAccessMode_INSTANCE_ACCESS_MODE_PRIVATE)@@ -785,7 +785,7 @@ func TestServeUserAvatar_PrivateInstanceRequiresAuth(t *testing.T) {privateRec := httptest.NewRecorder()e.ServeHTTP(privateRec, privateReq)require.Equal(t, http.StatusOK, privateRec.Code)- require.Equal(t, privateAttachmentCacheControl, privateRec.Header().Get(echo.HeaderCacheControl))+ require.Equal(t, privateAttachmentCacheControl, privateRec.Header().Get("Cache-Control"))}// TestServeAttachmentFile_RefreshCookieAuthenticatesOwner verifies that the file@@ -833,8 +833,8 @@ func TestServeAttachmentFile_RefreshCookieAuthenticatesOwner(t *testing.T) {refreshToken, _, err := auth.GenerateRefreshToken(owner.ID, tokenID, []byte(svc.Secret))require.NoError(t, err)- e := echo.New()- fs.RegisterRoutes(e)+ e := http.NewServeMux()+ fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))url := fmt.Sprintf("/file/%s/%s", attachment.Name, attachment.Filename)// Without credentials, the private attachment is denied.@@ -877,8 +877,8 @@ func TestServeAttachmentFile_UnlinkedAttachmentOwnerOrAdmin(t *testing.T) {})require.NoError(t, err)- e := echo.New()- fs.RegisterRoutes(e)+ e := http.NewServeMux()+ fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))url := fmt.Sprintf("/file/%s/%s", attachment.Name, attachment.Filename)getAs := func(user *store.User) int {req := httptest.NewRequest(http.MethodGet, url, nil)@@ -968,13 +968,13 @@ func TestServeAttachmentFile_ThumbnailRefusesOversizedImage(t *testing.T) {bomb := oversizedPNGHeader(100_000, 100_000)attachment := createPublicImageMemo(ctx, t, svc, "bomb-owner", "bomb.png", "image/png", bomb)- e := echo.New()- fs.RegisterRoutes(e)+ e := http.NewServeMux()+ fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))for range 2 {rec := httptest.NewRecorder()e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/bomb.png?thumbnail=true", attachment.Name), nil))require.Equal(t, http.StatusOK, rec.Code)- require.Equal(t, "image/png", rec.Header().Get(echo.HeaderContentType))+ require.Equal(t, "image/png", rec.Header().Get("Content-Type"))require.Equal(t, bomb, rec.Body.Bytes(), "original is served instead of a thumbnail")}uid := strings.TrimPrefix(attachment.Name, "attachments/")@@ -1024,12 +1024,12 @@ func TestDeleteAttachmentRemovesCachedThumbnail(t *testing.T) {owner, err := svc.Store.GetUser(ctx, &store.FindUser{Username: func() *string { s := "thumb-owner"; return &s }()})require.NoError(t, err)- e := echo.New()- fs.RegisterRoutes(e)+ e := http.NewServeMux()+ fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))rec := httptest.NewRecorder()e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/small.png?thumbnail=true", attachment.Name), nil))require.Equal(t, http.StatusOK, rec.Code)- require.Equal(t, "image/jpeg", rec.Header().Get(echo.HeaderContentType))+ require.Equal(t, "image/jpeg", rec.Header().Get("Content-Type"))uid := strings.TrimPrefix(attachment.Name, "attachments/")thumbnailPath := filepath.Join(fs.Profile.Data, thumbnailCacheFolder, uid+".v2.jpeg")require.FileExists(t, thumbnailPath)@@ -1065,8 +1065,8 @@ func TestThumbnailFailureMarkerOnlyForUnsupportedImages(t *testing.T) {localPath := fs.resolveLocalPath(stored.Reference)require.NoError(t, os.Rename(localPath, localPath+".away"))- e := echo.New()- fs.RegisterRoutes(e)+ e := http.NewServeMux()+ fs.RegisterRoutes(e, http.HandlerFunc(httphandler.NotFound))rec := httptest.NewRecorder()e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/gone.png?thumbnail=true", attachment.Name), nil))marker := filepath.Join(fs.Profile.Data, thumbnailCacheFolder, uid+".v2.jpeg"+thumbnailFailedMarkerSuffix)@@ -1077,5 +1077,5 @@ func TestThumbnailFailureMarkerOnlyForUnsupportedImages(t *testing.T) {rec = httptest.NewRecorder()e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, fmt.Sprintf("/file/%s/gone.png?thumbnail=true", attachment.Name), nil))require.Equal(t, http.StatusOK, rec.Code)- require.Equal(t, "image/jpeg", rec.Header().Get(echo.HeaderContentType))+ require.Equal(t, "image/jpeg", rec.Header().Get("Content-Type"))}diff --git a/server/frontend/frontend.go b/server/frontend/frontend.goindex 19cca0ae0..1efc05326 100644--- a/server/frontend/frontend.go+++ b/server/frontend/frontend.go@@ -4,15 +4,15 @@ import ("context""embed""encoding/xml"+ "io""io/fs""net/http""path""strings"- "github.com/labstack/echo/v5"- "github.com/labstack/echo/v5/middleware""github.com/pkg/errors"+ "github.com/usememos/memos/internal/httphandler""github.com/usememos/memos/internal/profile""github.com/usememos/memos/store")@@ -38,45 +38,54 @@ func NewFrontendService(profile *profile.Profile, store *store.Store) *FrontendS}}-func (s *FrontendService) Serve(_ context.Context, e *echo.Echo) {+func (s *FrontendService) Serve(_ context.Context, mux *http.ServeMux, fallback http.Handler) {+ mux.Handle("/robots.txt", httphandler.GET(httphandler.Func(s.getRobotsTXT), nil))+ mux.Handle("/sitemap.xml", httphandler.GET(httphandler.Func(s.getSitemapXML), nil))+ mux.Handle("/", s.Handler(fallback))+}++// Handler serves static files and SPA routes, passing API namespaces to fallback.+func (*FrontendService) Handler(fallback http.Handler) http.Handler {frontendFS := getFileSystem("dist")- skipper := func(c *echo.Context) bool {- requestPath := c.Request().URL.Path+ return httphandler.Func(func(w http.ResponseWriter, r *http.Request) error {+ requestPath := r.URL.Pathif shouldSkipFrontendStatic(requestPath) {- return true+ fallback.ServeHTTP(w, r)+ return nil}-- setFrontendCacheHeaders(c, requestPath)- return false- }-- // Route to serve the frontend static assets.- e.Use(middleware.StaticWithConfig(middleware.StaticConfig{- Filesystem: frontendFS,- Skipper: skipper,- }))-- e.Use(spaFallbackMiddleware(frontendFS))- s.registerRoutes(e)-}--func spaFallbackMiddleware(frontendFS fs.FS) echo.MiddlewareFunc {- return func(next echo.HandlerFunc) echo.HandlerFunc {- return func(c *echo.Context) error {- err := next(c)- if err == nil {- return nil- }-- requestPath := c.Request().URL.Path- if shouldSkipFrontendStatic(requestPath) || !shouldServeFrontendHTML(requestPath) || echo.StatusCode(err) != http.StatusNotFound {- return err+ setFrontendCacheHeaders(w, requestPath)+ filename := strings.TrimPrefix(path.Clean("/"+requestPath), "/")+ if filename == "" {+ filename = "index.html"+ }+ info, err := fs.Stat(frontendFS, filename)+ if err == nil && info.IsDir() {+ filename = path.Join(filename, "index.html")+ _, err = fs.Stat(frontendFS, filename)+ }+ if err != nil {+ if !shouldServeFrontendHTML(requestPath) {+ return &httphandler.Error{Code: http.StatusNotFound, Message: http.StatusText(http.StatusNotFound)}}-- setFrontendCacheHeaders(c, requestPath)- return c.FileFS("index.html", frontendFS)+ filename = "index.html"}- }+ // ServeContent avoids FileServer's /index.html and directory redirects.+ file, err := frontendFS.Open(filename)+ if err != nil {+ return err+ }+ defer file.Close()+ info, err = file.Stat()+ if err != nil {+ return err+ }+ content, ok := file.(io.ReadSeeker)+ if !ok {+ return errors.New("frontend file does not support seeking")+ }+ http.ServeContent(w, r, info.Name(), info.ModTime(), content)+ return nil+ })}func shouldSkipFrontendStatic(requestPath string) bool {@@ -89,11 +98,19 @@ func shouldSkipFrontendStatic(requestPath string) bool {strings.HasPrefix(requestPath, "/memos.api.")}-func setFrontendCacheHeaders(c *echo.Context, requestPath string) {+// SetCacheHeaders applies the frontend cache policy before route dispatch.+// Dynamic namespaces and discovery routes manage their own cache headers.+func SetCacheHeaders(w http.ResponseWriter, r *http.Request) {+ if !shouldSkipFrontendStatic(r.URL.Path) {+ setFrontendCacheHeaders(w, r.URL.Path)+ }+}++func setFrontendCacheHeaders(w http.ResponseWriter, requestPath string) {if shouldServeFrontendHTML(requestPath) {- c.Response().Header().Set(echo.HeaderCacheControl, frontendHTMLCacheControl)- c.Response().Header().Set("Pragma", "no-cache")- c.Response().Header().Set("Expires", "0")+ w.Header().Set("Cache-Control", frontendHTMLCacheControl)+ w.Header().Set("Pragma", "no-cache")+ w.Header().Set("Expires", "0")return}@@ -101,7 +118,7 @@ func setFrontendCacheHeaders(c *echo.Context, requestPath string) {if strings.HasPrefix(requestPath, "/assets/") {cacheControl = frontendHashedAssetCacheControl}- c.Response().Header().Set(echo.HeaderCacheControl, cacheControl)+ w.Header().Set("Cache-Control", cacheControl)}func shouldServeFrontendHTML(requestPath string) bool {@@ -120,13 +137,8 @@ func getFileSystem(path string) fs.FS {return sub}-func (s *FrontendService) registerRoutes(e *echo.Echo) {- e.GET("/robots.txt", s.getRobotsTXT)- e.GET("/sitemap.xml", s.getSitemapXML)-}--func (s *FrontendService) getRobotsTXT(c *echo.Context) error {- if err := s.requirePublicAccess(c.Request().Context()); err != nil {+func (s *FrontendService) getRobotsTXT(w http.ResponseWriter, r *http.Request) error {+ if err := s.requirePublicAccess(r.Context()); err != nil {return err}instanceURL, err := normalizeInstanceURL(s.Profile.InstanceURL)@@ -140,11 +152,11 @@ func (s *FrontendService) getRobotsTXT(c *echo.Context) error {"Host: " + instanceURL,"Sitemap: " + instanceURL + "/sitemap.xml",}, "\n")- return c.String(http.StatusOK, robotsTXT)+ return httphandler.Text(w, http.StatusOK, robotsTXT)}-func (s *FrontendService) getSitemapXML(c *echo.Context) error {- if err := s.requirePublicAccess(c.Request().Context()); err != nil {+func (s *FrontendService) getSitemapXML(w http.ResponseWriter, r *http.Request) error {+ if err := s.requirePublicAccess(r.Context()); err != nil {return err}instanceURL, err := normalizeInstanceURL(s.Profile.InstanceURL)@@ -153,7 +165,7 @@ func (s *FrontendService) getSitemapXML(c *echo.Context) error {}normal := store.Normal- memos, err := s.Store.ListMemos(c.Request().Context(), &store.FindMemo{+ memos, err := s.Store.ListMemos(r.Context(), &store.FindMemo{RowStatus: &normal,VisibilityList: []store.Visibility{store.Public},Access: &store.MemoAccessScope{AllowPublic: true},@@ -164,7 +176,7 @@ func (s *FrontendService) getSitemapXML(c *echo.Context) error {}// The set of public memo URLs changes with audience updates. Require// revalidation so a revoked URL is not retained by an intermediary cache.- c.Response().Header().Set(echo.HeaderCacheControl, "public, no-cache")+ w.Header().Set("Cache-Control", "public, no-cache")urls := make([]sitemapURL, 0, len(memos))for _, memo := range memos {@@ -173,7 +185,12 @@ func (s *FrontendService) getSitemapXML(c *echo.Context) error {})}- return c.XML(http.StatusOK, sitemapURLSet{+ w.Header().Set("Content-Type", "application/xml; charset=UTF-8")+ w.WriteHeader(http.StatusOK)+ if _, err := io.WriteString(w, xml.Header); err != nil {+ return err+ }+ return xml.NewEncoder(w).Encode(sitemapURLSet{XMLNS: sitemapXMLNamespace,URLs: urls,})@@ -182,10 +199,10 @@ func (s *FrontendService) getSitemapXML(c *echo.Context) error {func (s *FrontendService) requirePublicAccess(ctx context.Context) error {allowsAnonymous, err := s.Store.AllowsAnonymousAccess(ctx)if err != nil {- return echo.NewHTTPError(http.StatusInternalServerError, "failed to get instance access policy").Wrap(err)+ return &httphandler.Error{Code: http.StatusInternalServerError, Message: "failed to get instance access policy", Cause: err}}if !allowsAnonymous {- return echo.NewHTTPError(http.StatusNotFound, "public instance discovery is unavailable")+ return &httphandler.Error{Code: http.StatusNotFound, Message: "public instance discovery is unavailable"}}return nil}@@ -193,7 +210,7 @@ func (s *FrontendService) requirePublicAccess(ctx context.Context) error {func normalizeInstanceURL(instanceURL string) (string, error) {instanceURL = strings.TrimRight(instanceURL, "/")if instanceURL == "" {- return "", echo.NewHTTPError(http.StatusNotFound, "instance URL is not configured")+ return "", &httphandler.Error{Code: http.StatusNotFound, Message: "instance URL is not configured"}}return instanceURL, nil}diff --git a/server/frontend/frontend_test.go b/server/frontend/frontend_test.goindex 593a11683..652717fbf 100644--- a/server/frontend/frontend_test.go+++ b/server/frontend/frontend_test.go@@ -6,9 +6,9 @@ import ("net/http/httptest""testing"- "github.com/labstack/echo/v5""github.com/stretchr/testify/require"+ "github.com/usememos/memos/internal/httphandler""github.com/usememos/memos/internal/profile"storepb "github.com/usememos/memos/proto/gen/store""github.com/usememos/memos/store"@@ -56,16 +56,13 @@ func TestFrontendService_CacheHeaderRules(t *testing.T) {},}- e := echo.New()for _, tt := range tests {t.Run(tt.name, func(t *testing.T) {- req := httptest.NewRequest(http.MethodGet, tt.path, nil)rec := httptest.NewRecorder()- c := e.NewContext(req, rec)- setFrontendCacheHeaders(c, tt.path)+ setFrontendCacheHeaders(rec, tt.path)- require.Equal(t, tt.cacheControl, rec.Header().Get(echo.HeaderCacheControl))+ require.Equal(t, tt.cacheControl, rec.Header().Get("Cache-Control"))require.Equal(t, tt.pragma, rec.Header().Get("Pragma"))require.Equal(t, tt.expires, rec.Header().Get("Expires"))})@@ -76,8 +73,8 @@ func TestFrontendService_StaticCacheHeaders(t *testing.T) {ctx := context.Background()testStore := teststore.NewTestingStore(ctx, t)- e := echo.New()- NewFrontendService(&profile.Profile{}, testStore).Serve(ctx, e)+ e := http.NewServeMux()+ NewFrontendService(&profile.Profile{}, testStore).Serve(ctx, e, http.HandlerFunc(httphandler.NotFound))tests := []struct {name string@@ -116,7 +113,7 @@ func TestFrontendService_StaticCacheHeaders(t *testing.T) {e.ServeHTTP(rec, req)require.Equal(t, http.StatusOK, rec.Code)- require.Equal(t, tt.cacheControl, rec.Header().Get(echo.HeaderCacheControl))+ require.Equal(t, tt.cacheControl, rec.Header().Get("Cache-Control"))require.Equal(t, tt.pragma, rec.Header().Get("Pragma"))require.Equal(t, tt.expires, rec.Header().Get("Expires"))})@@ -127,8 +124,8 @@ func TestFrontendService_MissingAssetDoesNotFallbackToIndex(t *testing.T) {ctx := context.Background()testStore := teststore.NewTestingStore(ctx, t)- e := echo.New()- NewFrontendService(&profile.Profile{}, testStore).Serve(ctx, e)+ e := http.NewServeMux()+ NewFrontendService(&profile.Profile{}, testStore).Serve(ctx, e, http.HandlerFunc(httphandler.NotFound))req := httptest.NewRequest(http.MethodGet, "/assets/missing.js", nil)rec := httptest.NewRecorder()@@ -141,18 +138,18 @@ func TestFrontendService_SkipsDynamicRoutes(t *testing.T) {ctx := context.Background()testStore := teststore.NewTestingStore(ctx, t)- e := echo.New()- NewFrontendService(&profile.Profile{}, testStore).Serve(ctx, e)- e.GET("/api/test", func(c *echo.Context) error {- return c.String(http.StatusOK, "ok")- })+ e := http.NewServeMux()+ NewFrontendService(&profile.Profile{}, testStore).Serve(ctx, e, http.HandlerFunc(httphandler.NotFound))+ e.Handle("GET /api/test", httphandler.Func(func(w http.ResponseWriter, _ *http.Request) error {+ return httphandler.Text(w, http.StatusOK, "ok")+ }))req := httptest.NewRequest(http.MethodGet, "/api/test", nil)rec := httptest.NewRecorder()e.ServeHTTP(rec, req)require.Equal(t, http.StatusOK, rec.Code)- require.Empty(t, rec.Header().Get(echo.HeaderCacheControl))+ require.Empty(t, rec.Header().Get("Cache-Control"))}func TestFrontendService_RobotsTXT(t *testing.T) {@@ -163,8 +160,8 @@ func TestFrontendService_RobotsTXT(t *testing.T) {InstanceURL: "https://demo.usememos.com/",}- e := echo.New()- NewFrontendService(profile, testStore).Serve(ctx, e)+ e := http.NewServeMux()+ NewFrontendService(profile, testStore).Serve(ctx, e, http.HandlerFunc(httphandler.NotFound))req := httptest.NewRequest(http.MethodGet, "/robots.txt", nil)rec := httptest.NewRecorder()@@ -206,8 +203,8 @@ func TestFrontendService_SitemapXML(t *testing.T) {})require.NoError(t, err)- e := echo.New()- NewFrontendService(profile, testStore).Serve(ctx, e)+ e := http.NewServeMux()+ NewFrontendService(profile, testStore).Serve(ctx, e, http.HandlerFunc(httphandler.NotFound))req := httptest.NewRequest(http.MethodGet, "/sitemap.xml", nil)rec := httptest.NewRecorder()@@ -215,7 +212,7 @@ func TestFrontendService_SitemapXML(t *testing.T) {require.Equal(t, http.StatusOK, rec.Code)require.Contains(t, rec.Header().Get("Content-Type"), "application/xml")- require.Equal(t, "public, no-cache", rec.Header().Get(echo.HeaderCacheControl))+ require.Equal(t, "public, no-cache", rec.Header().Get("Cache-Control"))require.Contains(t, rec.Body.String(), `<loc>https://demo.usememos.com/memos/publicmemo</loc>`)require.NotContains(t, rec.Body.String(), "privatememo")}@@ -225,8 +222,8 @@ func TestFrontendService_SitemapRoutesRequireInstanceURL(t *testing.T) {testStore := teststore.NewTestingStore(ctx, t)setFrontendAccessMode(ctx, t, testStore, storepb.InstanceAccessMode_INSTANCE_ACCESS_MODE_PUBLIC)- e := echo.New()- NewFrontendService(&profile.Profile{}, testStore).Serve(ctx, e)+ e := http.NewServeMux()+ NewFrontendService(&profile.Profile{}, testStore).Serve(ctx, e, http.HandlerFunc(httphandler.NotFound))for _, path := range []string{"/robots.txt", "/sitemap.xml"} {req := httptest.NewRequest(http.MethodGet, path, nil)@@ -242,8 +239,8 @@ func TestFrontendService_SitemapRoutesRequirePublicAccess(t *testing.T) {testStore := teststore.NewTestingStore(ctx, t)setFrontendAccessMode(ctx, t, testStore, storepb.InstanceAccessMode_INSTANCE_ACCESS_MODE_PRIVATE)- e := echo.New()- NewFrontendService(&profile.Profile{InstanceURL: "https://private.example.com"}, testStore).Serve(ctx, e)+ e := http.NewServeMux()+ NewFrontendService(&profile.Profile{InstanceURL: "https://private.example.com"}, testStore).Serve(ctx, e, http.HandlerFunc(httphandler.NotFound))for _, path := range []string{"/robots.txt", "/sitemap.xml"} {req := httptest.NewRequest(http.MethodGet, path, nil)diff --git a/server/http_compat_test.go b/server/http_compat_test.gonew file mode 100644index 000000000..396782d12--- /dev/null+++ b/server/http_compat_test.go@@ -0,0 +1,148 @@+package server++import (+ "bufio"+ "context"+ "encoding/json"+ "io"+ "net/http"+ "net/http/httptest"+ "os"+ "strings"+ "testing"+ "time"++ "github.com/stretchr/testify/require"++ "github.com/usememos/memos/internal/profile"+ "github.com/usememos/memos/server/auth"+ "github.com/usememos/memos/store"+ teststore "github.com/usememos/memos/store/test"+)++type httpSnapshot struct {+ Method string+ Path string+ RequestHeader http.Header+ Status int+ Header http.Header+ Body string+}++// These responses were captured from the Echo implementation before replacing+// the router. Keep the transport boundaries and HTTP error contracts unchanged.+func TestHTTPCompatibility(t *testing.T) {+ ctx := context.Background()+ stores := teststore.NewTestingStore(ctx, t)+ s, err := NewServer(ctx, &profile.Profile{Data: t.TempDir(), InstanceURL: "https://memos.example"}, stores)+ require.NoError(t, err)+ t.Cleanup(func() { s.apiService.CloseUploads(); s.apiService.SSEHub.Close() })+ var snapshots []httpSnapshot+ for _, path := range []string{+ "/healthz", "/healthz/", "/health%7A", "/api", "/api/", "/api/missing", "/api/sse", "/api/sse/",+ "/api/v1", "/api/v1/", "/api/v1/memos", "/file", "/file/", "/file/attachments/missing", "/file/attachments/missing/",+ "/file/attachments/missing/a%2Fb.txt", "/file/attachments/%6dissing/file.txt", "/file/%61ttachments/missing/file.txt",+ "/memos.api", "/memos.api.", "/memos.api.UnknownService/Unknown", "/memos.api.v1.MemoService/ListMemos",+ "/memos/x", "/assets/missing.js", "/index.html", "/robots.txt", "/sitemap.xml",+ "/api//instance/profile", "/api/../healthz", "/api/instance/profile/", "/mcp/",+ } {+ for _, method := range []string{http.MethodGet, http.MethodHead, http.MethodPost, http.MethodOptions} {+ rec := httptest.NewRecorder()+ s.handler.ServeHTTP(rec, httptest.NewRequest(method, path, nil))+ body := rec.Body.String()+ if strings.Contains(strings.ToLower(body), "<!doctype html>") {+ body = "<frontend HTML>"+ }+ header := rec.Header().Clone()+ // The bundled SPA may be rebuilt independently of server code.+ header.Del("Content-Length")+ header.Del("Last-Modified")+ snapshots = append(snapshots, httpSnapshot{Method: method, Path: path, Status: rec.Code, Header: header, Body: body})+ }+ }+ for _, path := range []string{"/healthz", "/api/missing", "/memos/x"} {+ for _, origin := range []string{"https://memos.example", "https://evil.example", "null"} {+ for _, method := range []string{http.MethodGet, http.MethodOptions} {+ req := httptest.NewRequest(method, path, nil)+ req.Header.Set("Origin", origin)+ req.Header.Set("Access-Control-Request-Method", "POST")+ req.Header.Set("Access-Control-Request-Headers", "Authorization,Content-Type")+ rec := httptest.NewRecorder()+ s.handler.ServeHTTP(rec, req)+ body := rec.Body.String()+ if strings.Contains(strings.ToLower(body), "<!doctype html>") {+ body = "<frontend HTML>"+ }+ header := rec.Header().Clone()+ header.Del("Content-Length")+ header.Del("Last-Modified")+ snapshots = append(snapshots, httpSnapshot{Method: method, Path: path, RequestHeader: req.Header, Status: rec.Code, Header: header, Body: body})+ }+ }+ }++ f, err := os.Open("testdata/http_compat.jsonl")+ require.NoError(t, err)+ defer f.Close()+ decoder := json.NewDecoder(f)+ for _, got := range snapshots {+ t.Run(got.Method+" "+got.Path+" "+got.RequestHeader.Get("Origin"), func(t *testing.T) {+ var want httpSnapshot+ require.NoError(t, decoder.Decode(&want))+ if strings.HasPrefix(want.Header.Get("Content-Type"), "application/json") && want.Body != "" {+ require.JSONEq(t, want.Body, got.Body)+ want.Body, got.Body = "", ""+ }+ require.Equal(t, want, got)+ })+ }+ var extra httpSnapshot+ require.ErrorIs(t, decoder.Decode(&extra), io.EOF)+}++func TestHTTPStreaming(t *testing.T) {+ ctx := context.Background()+ stores := teststore.NewTestingStore(ctx, t)+ s, err := NewServer(ctx, &profile.Profile{Data: t.TempDir()}, stores)+ require.NoError(t, err)+ t.Cleanup(func() { s.apiService.CloseUploads(); s.apiService.SSEHub.Close() })+ user, err := stores.CreateUser(ctx, &store.User{Username: "stream-owner", Role: store.RoleUser})+ require.NoError(t, err)+ token, _, err := auth.GenerateAccessTokenV2(user.ID, user.Username, string(user.Role), string(user.RowStatus), user.PasswordHash, []byte(s.Secret))+ require.NoError(t, err)+ server := httptest.NewTestServer(t, s.handler)+ client := server.Client()+ streamCtx, cancel := context.WithTimeout(ctx, 5*time.Second)+ defer cancel()+ req, err := http.NewRequestWithContext(streamCtx, http.MethodGet, server.URL+"/api/sse", nil)+ require.NoError(t, err)+ req.Header.Set("Authorization", "Bearer "+token)+ response, err := client.Do(req)+ require.NoError(t, err)+ defer response.Body.Close()+ require.Equal(t, http.StatusOK, response.StatusCode)+ require.Equal(t, "text/event-stream", response.Header.Get("Content-Type"))+ reader := bufio.NewReader(response.Body)+ line, err := reader.ReadString('\n')+ require.NoError(t, err)+ require.Equal(t, ": connected\n", line)+ line, err = reader.ReadString('\n')+ require.NoError(t, err)+ require.Equal(t, "\n", line)++ create, err := http.NewRequestWithContext(streamCtx, http.MethodPost, server.URL+"/api/memos", strings.NewReader(`{"memoId":"streamed","content":"streamed memo"}`))+ require.NoError(t, err)+ create.Header.Set("Authorization", "Bearer "+token)+ create.Header.Set("Content-Type", "application/json")+ created, err := client.Do(create)+ require.NoError(t, err)+ defer created.Body.Close()+ require.Equal(t, http.StatusOK, created.StatusCode)+ line, err = reader.ReadString('\n')+ require.NoError(t, err)+ require.Equal(t, "data: {\"type\":\"memo.changed\"}\n", line)++ s.apiService.SSEHub.Close()+ _, err = io.ReadAll(reader)+ require.NoError(t, err, "closing the hub must terminate the HTTP stream")+}diff --git a/server/mcp/README.md b/server/mcp/README.mdindex f52196672..0e76ac09f 100644--- a/server/mcp/README.md+++ b/server/mcp/README.md@@ -10,19 +10,19 @@ REST API.** The package owns no store or service logic of its own. Each tool isderived from an operation in the generated OpenAPI document(`proto/gen/openapi.yaml`, embedded via `proto.OpenAPIYAML()`), and a tool callis translated into the matching `/api/...` HTTP request and run against the-same Echo server that serves the public API. This keeps OpenAPI as the single+same HTTP handler that serves the public API. This keeps OpenAPI as the singlesource of truth and reuses the API's authentication and authorization as-is.## Integration-`server.NewServer` calls `mcp.NewMCPService` after registering the API, file, and gRPC-gateway routes, passing the same Echo server:+`server.NewServer` calls `mcp.NewMCPService` after registering the API, file, and gRPC-gateway routes, passing the same HTTP handler:```go-mcpService, err := mcp.NewMCPService(profile, echoServer)+mcpService, err := mcp.NewMCPService(profile, handler)if err != nil {return nil, errors.Wrap(err, "failed to create MCP service")}-mcpService.RegisterRoutes(echoServer)+mcpService.RegisterRoutes(mux)```The service advertises the **tools** capability only — no prompts, no resources.@@ -50,7 +50,7 @@ fast on any inconsistency:## Request flow-`RegisterRoutes` binds `echoServer.Any("/mcp", ...)`. Each request:+`RegisterRoutes` binds `mux.HandleFunc("/mcp", ...)`. Each request:1. `isAllowedMCPOrigin` (`origin.go`) rejects disallowed cross-origin browser requests with `403`.2. The request body is capped at 256 MiB before the SDK reads it.@@ -63,7 +63,7 @@ fast on any inconsistency:7. `apiAdapter.execute` (`adapter.go`) builds the API request(`buildAPIRequest`: path-parameter substitution, query encoding, JSON body),forwards the bearer token, presents the caller's resolved client address as- the request peer, and runs it against the Echo server through an+ the request peer, and runs it against the HTTP handler through an`httptest.ResponseRecorder`.8. The recorder body is decoded; a non-2xx status becomes a tool error(`newToolErrorResult`), otherwise the value is wrapped by@@ -272,7 +272,7 @@ validate an error payload against the tool's success-only output schema:| --- | --- || `service.go` | Constructs the MCP server, registers tools, builds the streamable HTTP handler, and binds the `/mcp` route. || `catalog.go` | The curated operation allowlist, tool naming, input/output schema assembly, and method-derived annotations. |-| `adapter.go` | Translates a tool call into an `/api/...` request and runs it in-process against the Echo server. |+| `adapter.go` | Translates a tool call into an `/api/...` request and runs it in-process against the HTTP handler. || `openapi.go` | Parses the OpenAPI spec, builds the operation registry, and resolves `$ref` schemas into self-contained JSON Schema. || `validation.go` | Validates tool-call arguments against the tool's input schema. || `origin.go` | `Origin`-header check for browser DNS-rebinding safety. |diff --git a/server/mcp/adapter.go b/server/mcp/adapter.goindex 86035d3d7..6a9e0bc39 100644--- a/server/mcp/adapter.go+++ b/server/mcp/adapter.go@@ -12,7 +12,6 @@ import ("strconv""strings"- "github.com/labstack/echo/v5"sdkmcp "github.com/modelcontextprotocol/go-sdk/mcp""github.com/pkg/errors"@@ -20,11 +19,11 @@ import ()type apiAdapter struct {- echoServer *echo.Echo+ handler http.Handler}-func newAPIAdapter(echoServer *echo.Echo) *apiAdapter {- return &apiAdapter{echoServer: echoServer}+func newAPIAdapter(handler http.Handler) *apiAdapter {+ return &apiAdapter{handler: handler}}func (a *apiAdapter) execute(ctx context.Context, operation *openAPIOperation, arguments map[string]any, authorization string) (*sdkmcp.CallToolResult, error) {@@ -34,7 +33,7 @@ func (a *apiAdapter) execute(ctx context.Context, operation *openAPIOperation, a}recorder := httptest.NewRecorder()- a.echoServer.ServeHTTP(recorder, req)+ a.handler.ServeHTTP(recorder, req)value, err := decodeJSONValue(recorder.Body.Bytes())if err != nil {diff --git a/server/mcp/adapter_test.go b/server/mcp/adapter_test.goindex fbf943858..62053493b 100644--- a/server/mcp/adapter_test.go+++ b/server/mcp/adapter_test.go@@ -9,11 +9,11 @@ import ("strings""testing"- "github.com/labstack/echo/v5"sdkmcp "github.com/modelcontextprotocol/go-sdk/mcp""github.com/stretchr/testify/require""github.com/usememos/memos/internal/clientip"+ "github.com/usememos/memos/internal/httphandler")func TestNormalizeStructuredContentKeepsObjects(t *testing.T) {@@ -336,19 +336,19 @@ func TestBuildAPIRequestEscapesPathAndStringifiesPrimitiveQueryParameters(t *tes}func TestExecuteOperationReturnsObjectStructuredContent(t *testing.T) {- echoServer := echo.New()- echoServer.GET("/api/memos", func(c *echo.Context) error {- require.Equal(t, "Bearer token", c.Request().Header.Get("Authorization"))- return c.JSON(http.StatusOK, map[string]any{+ mux := http.NewServeMux()+ mux.Handle("GET /api/memos", httphandler.Func(func(w http.ResponseWriter, r *http.Request) error {+ require.Equal(t, "Bearer token", r.Header.Get("Authorization"))+ return httphandler.JSON(w, http.StatusOK, map[string]any{"memos": []any{map[string]any{"name": "memos/abc123"}},})- })+ }))operation := &openAPIOperation{Method: "GET",Path: "/api/memos",}- adapter := newAPIAdapter(echoServer)+ adapter := newAPIAdapter(mux)result, err := adapter.execute(context.Background(), operation, map[string]any{}, "Bearer token")require.NoError(t, err)@@ -359,17 +359,17 @@ func TestExecuteOperationReturnsObjectStructuredContent(t *testing.T) {}func TestExecuteOperationConvertsAPIErrorsToToolErrors(t *testing.T) {- echoServer := echo.New()- echoServer.GET("/api/memos/:memo", func(c *echo.Context) error {- return c.JSON(http.StatusNotFound, map[string]any{"message": "missing memo"})- })+ mux := http.NewServeMux()+ mux.Handle("GET /api/memos/{memo}", httphandler.Func(func(w http.ResponseWriter, _ *http.Request) error {+ return httphandler.JSON(w, http.StatusNotFound, map[string]any{"message": "missing memo"})+ }))operation := &openAPIOperation{Method: "GET",Path: "/api/memos/{memo}",Parameters: []openAPIParameter{{Name: "memo", In: "path", Required: true}},}- adapter := newAPIAdapter(echoServer)+ adapter := newAPIAdapter(mux)result, err := adapter.execute(context.Background(), operation, map[string]any{"memo": "missing"}, "")require.NoError(t, err)diff --git a/server/mcp/service.go b/server/mcp/service.goindex 415780d5c..4134db36d 100644--- a/server/mcp/service.go+++ b/server/mcp/service.go@@ -6,12 +6,11 @@ import ("net/http""time"- "github.com/labstack/echo/v5"- "github.com/labstack/echo/v5/middleware"sdkmcp "github.com/modelcontextprotocol/go-sdk/mcp""github.com/pkg/errors""gopkg.in/yaml.v3"+ "github.com/usememos/memos/internal/httphandler""github.com/usememos/memos/internal/profile"memosproto "github.com/usememos/memos/proto""github.com/usememos/memos/server/api"@@ -20,7 +19,7 @@ import (// maxMCPRequestBytes caps the /mcp request body. It tracks the API limit because// every tool call is forwarded in-process through the API routes. The SDK// enforces its own 4 MiB default, so the value is passed to the transport as-// well; otherwise attachment uploads over MCP fail with 413 before Echo sees them.+// well; otherwise attachment uploads over MCP fail with 413 before the API sees them.const maxMCPRequestBytes int64 = api.MaxAPIRequestBytes// toolCatalogTTL is the freshness hint advertised on tools/list and@@ -37,7 +36,7 @@ type MCPService struct {}// NewMCPService creates an MCP service backed by the in-process API routes.-func NewMCPService(profile *profile.Profile, echoServer *echo.Echo) (*MCPService, error) {+func NewMCPService(profile *profile.Profile, handler http.Handler) (*MCPService, error) {spec, err := loadMCPServiceOpenAPISpec()if err != nil {return nil, err@@ -69,7 +68,7 @@ func NewMCPService(profile *profile.Profile, echoServer *echo.Echo) (*MCPService})server.AddReceivingMiddleware(catalogCacheMiddleware)- adapter := newAPIAdapter(echoServer)+ adapter := newAPIAdapter(handler)for _, tool := range tools {operation := operationsByTool[tool.Name]server.AddTool(tool, newMCPToolHandler(adapter, operation))@@ -150,13 +149,17 @@ func newMCPToolHandler(adapter *apiAdapter, operation *registeredOperation) sdkm}// RegisterRoutes registers the streamable HTTP MCP endpoint.-func (s *MCPService) RegisterRoutes(echoServer *echo.Echo) {- echoServer.Any("/mcp", func(c *echo.Context) error {- request := c.Request()- if !isAllowedMCPOrigin(request.Host, request.Header.Get("Origin"), s.profile) {- return c.NoContent(http.StatusForbidden)+func (s *MCPService) RegisterRoutes(mux *http.ServeMux) {+ mux.HandleFunc("/mcp", func(w http.ResponseWriter, r *http.Request) {+ if r.ContentLength > maxMCPRequestBytes {+ httphandler.WriteError(w, r, &httphandler.Error{Code: http.StatusRequestEntityTooLarge, Message: http.StatusText(http.StatusRequestEntityTooLarge)})+ return}- s.handler.ServeHTTP(c.Response(), request)- return nil- }, middleware.BodyLimit(maxMCPRequestBytes))+ if !isAllowedMCPOrigin(r.Host, r.Header.Get("Origin"), s.profile) {+ w.WriteHeader(http.StatusForbidden)+ return+ }+ r.Body = http.MaxBytesReader(w, r.Body, maxMCPRequestBytes)+ s.handler.ServeHTTP(w, r)+ })}diff --git a/server/mcp/service_test.go b/server/mcp/service_test.goindex facc16f50..3897335f5 100644--- a/server/mcp/service_test.go+++ b/server/mcp/service_test.go@@ -11,11 +11,11 @@ import ("strings""testing"- "github.com/labstack/echo/v5"sdkmcp "github.com/modelcontextprotocol/go-sdk/mcp""github.com/stretchr/testify/require""github.com/usememos/memos/internal/clientip"+ "github.com/usememos/memos/internal/httphandler""github.com/usememos/memos/internal/profile"memosproto "github.com/usememos/memos/proto")@@ -46,9 +46,9 @@ func TestIsAllowedMCPOrigin(t *testing.T) {}func TestNewMCPServiceRegistersCuratedTools(t *testing.T) {- echoServer := echo.New()+ mux := http.NewServeMux()- service, err := NewMCPService(&profile.Profile{Version: "test-version"}, echoServer)+ service, err := NewMCPService(&profile.Profile{Version: "test-version"}, mux)require.NoError(t, err)require.NotNil(t, service.handler)require.Len(t, service.operationsByTool, len(curatedOperationIDs))@@ -63,7 +63,7 @@ func TestNewMCPServiceRegistersCuratedTools(t *testing.T) {func TestNewMCPServiceUsesEmbeddedOpenAPISpec(t *testing.T) {t.Chdir(t.TempDir())- service, err := NewMCPService(&profile.Profile{Version: "test-version"}, echo.New())+ service, err := NewMCPService(&profile.Profile{Version: "test-version"}, http.NewServeMux())require.NoError(t, err)require.NotNil(t, service.handler)require.Len(t, service.operationsByTool, len(curatedOperationIDs))@@ -76,14 +76,14 @@ func TestEmbeddedOpenAPISpecMatchesGeneratedFile(t *testing.T) {}func TestMCPToolHandlerForwardsArgumentsAndAuthorization(t *testing.T) {- echoServer := echo.New()- echoServer.GET("/api/memos", func(c *echo.Context) error {- require.Equal(t, "Bearer token", c.Request().Header.Get("Authorization"))- require.Equal(t, "7", c.QueryParam("pageSize"))- return c.JSON(http.StatusOK, map[string]any{+ mux := http.NewServeMux()+ mux.Handle("GET /api/memos", httphandler.Func(func(w http.ResponseWriter, r *http.Request) error {+ require.Equal(t, "Bearer token", r.Header.Get("Authorization"))+ require.Equal(t, "7", r.URL.Query().Get("pageSize"))+ return httphandler.JSON(w, http.StatusOK, map[string]any{"memos": []any{map[string]any{"name": "memos/test"}},})- })+ }))operation := ®isteredOperation{Operation: &openAPIOperation{@@ -92,7 +92,7 @@ func TestMCPToolHandlerForwardsArgumentsAndAuthorization(t *testing.T) {Parameters: []openAPIParameter{{Name: "pageSize", In: "query", Schema: jsonSchema{"type": "integer"}}},},}- handler := newMCPToolHandler(newAPIAdapter(echoServer), operation)+ handler := newMCPToolHandler(newAPIAdapter(mux), operation)arguments, err := json.Marshal(map[string]any{"pageSize": 7})require.NoError(t, err)@@ -153,20 +153,20 @@ func TestMCPToolCallForwardsClientAddress(t *testing.T) {for _, test := range tests {t.Run(test.name, func(t *testing.T) {- echoServer := echo.New()+ mux := http.NewServeMux()resolver, err := clientip.ParseTrustedProxies(nil)require.NoError(t, err)- echoServer.Use(clientip.Middleware(resolver))+ handler := clientip.Middleware(resolver)(mux)seen := ""- echoServer.GET("/api/memos", func(c *echo.Context) error {- seen = clientip.FromContext(c.Request().Context())- return c.JSON(http.StatusOK, map[string]any{"memos": []any{}})- })- service, err := NewMCPService(&profile.Profile{Version: "test-version"}, echoServer)+ mux.Handle("GET /api/memos", httphandler.Func(func(w http.ResponseWriter, r *http.Request) error {+ seen = clientip.FromContext(r.Context())+ return httphandler.JSON(w, http.StatusOK, map[string]any{"memos": []any{}})+ }))+ service, err := NewMCPService(&profile.Profile{Version: "test-version"}, handler)require.NoError(t, err)- service.RegisterRoutes(echoServer)- initializeMCP(t, echoServer)+ service.RegisterRoutes(mux)+ initializeMCP(t, handler)payload, err := json.Marshal(map[string]any{"jsonrpc": "2.0",@@ -183,7 +183,7 @@ func TestMCPToolCallForwardsClientAddress(t *testing.T) {request.Header.Set("Content-Type", "application/json")request.Header.Set("Accept", "application/json, text/event-stream")recorder := httptest.NewRecorder()- echoServer.ServeHTTP(recorder, request)+ handler.ServeHTTP(recorder, request)require.Equal(t, http.StatusOK, recorder.Code, recorder.Body.String())require.Equal(t, test.expectedIP, seen)})@@ -289,31 +289,31 @@ func TestMCPToolCallBindsSpaceResourcesFromPath(t *testing.T) {for _, test := range tests {t.Run(test.name, func(t *testing.T) {- echoServer := echo.New()+ mux := http.NewServeMux()routeHits := 0- echoServer.Any("/api/spaces/*", func(c *echo.Context) error {+ mux.Handle("/api/spaces/{rest...}", httphandler.Func(func(w http.ResponseWriter, r *http.Request) error {routeHits++- require.Equal(t, test.method, c.Request().Method)- require.Equal(t, test.path, c.Request().URL.Path)- require.Empty(t, c.QueryParam("updateMask"))+ require.Equal(t, test.method, r.Method)+ require.Equal(t, test.path, r.URL.Path)+ require.Empty(t, r.URL.Query().Get("updateMask"))if test.body != nil {body := map[string]any{}- require.NoError(t, json.NewDecoder(c.Request().Body).Decode(&body))+ require.NoError(t, json.NewDecoder(r.Body).Decode(&body))require.Equal(t, test.body, body)require.NotContains(t, body, "name")require.NotContains(t, body, "user")} else {- require.Empty(t, c.Request().Header.Get("Content-Type"))+ require.Empty(t, r.Header.Get("Content-Type"))}- return c.JSON(http.StatusOK, test.response)- })+ return httphandler.JSON(w, http.StatusOK, test.response)+ }))- service, err := NewMCPService(&profile.Profile{Version: "test-version"}, echoServer)+ service, err := NewMCPService(&profile.Profile{Version: "test-version"}, mux)require.NoError(t, err)- service.RegisterRoutes(echoServer)+ service.RegisterRoutes(mux)- initializeMCP(t, echoServer)- response := postMCP(t, echoServer, map[string]any{+ initializeMCP(t, mux)+ response := postMCP(t, mux, map[string]any{"jsonrpc": "2.0","id": 2,"method": "tools/call",@@ -333,14 +333,14 @@ func TestMCPToolCallBindsSpaceResourcesFromPath(t *testing.T) {}func TestMCPProtocolListsCuratedToolsOnly(t *testing.T) {- echoServer := echo.New()+ mux := http.NewServeMux()- service, err := NewMCPService(&profile.Profile{Version: "test-version"}, echoServer)+ service, err := NewMCPService(&profile.Profile{Version: "test-version"}, mux)require.NoError(t, err)- service.RegisterRoutes(echoServer)+ service.RegisterRoutes(mux)- initializeMCP(t, echoServer)- response := postMCP(t, echoServer, map[string]any{+ initializeMCP(t, mux)+ response := postMCP(t, mux, map[string]any{"jsonrpc": "2.0","id": 2,"method": "tools/list",@@ -369,19 +369,19 @@ func TestMCPProtocolListsCuratedToolsOnly(t *testing.T) {}func TestMCPToolCallReturnsObjectStructuredContent(t *testing.T) {- echoServer := echo.New()- echoServer.GET("/api/memos", func(c *echo.Context) error {- return c.JSON(http.StatusOK, map[string]any{+ mux := http.NewServeMux()+ mux.Handle("GET /api/memos", httphandler.Func(func(w http.ResponseWriter, _ *http.Request) error {+ return httphandler.JSON(w, http.StatusOK, map[string]any{"memos": []any{map[string]any{"name": "memos/abc123"}},})- })+ }))- service, err := NewMCPService(&profile.Profile{Version: "test-version"}, echoServer)+ service, err := NewMCPService(&profile.Profile{Version: "test-version"}, mux)require.NoError(t, err)- service.RegisterRoutes(echoServer)+ service.RegisterRoutes(mux)- initializeMCP(t, echoServer)- response := postMCP(t, echoServer, map[string]any{+ initializeMCP(t, mux)+ response := postMCP(t, mux, map[string]any{"jsonrpc": "2.0","id": 2,"method": "tools/call",@@ -401,28 +401,28 @@ func TestMCPToolCallReturnsObjectStructuredContent(t *testing.T) {}func TestMCPToolCallAllowsGatewayToInferMemoUpdateMask(t *testing.T) {- echoServer := echo.New()+ mux := http.NewServeMux()routeHits := 0- echoServer.PATCH("/api/memos/:memo", func(c *echo.Context) error {+ mux.Handle("PATCH /api/memos/{memo}", httphandler.Func(func(w http.ResponseWriter, r *http.Request) error {routeHits++- require.Equal(t, "abc123", c.Param("memo"))- require.Empty(t, c.QueryParam("updateMask"))+ require.Equal(t, "abc123", r.PathValue("memo"))+ require.Empty(t, r.URL.Query().Get("updateMask"))body := map[string]any{}- require.NoError(t, json.NewDecoder(c.Request().Body).Decode(&body))+ require.NoError(t, json.NewDecoder(r.Body).Decode(&body))require.Equal(t, map[string]any{"content": "updated"}, body)- return c.JSON(http.StatusOK, map[string]any{+ return httphandler.JSON(w, http.StatusOK, map[string]any{"name": "memos/abc123","content": "updated",})- })+ }))- service, err := NewMCPService(&profile.Profile{Version: "test-version"}, echoServer)+ service, err := NewMCPService(&profile.Profile{Version: "test-version"}, mux)require.NoError(t, err)- service.RegisterRoutes(echoServer)+ service.RegisterRoutes(mux)- initializeMCP(t, echoServer)- response := postMCP(t, echoServer, map[string]any{+ initializeMCP(t, mux)+ response := postMCP(t, mux, map[string]any{"jsonrpc": "2.0","id": 2,"method": "tools/call",@@ -446,15 +446,8 @@ func TestMCPToolCallAllowsGatewayToInferMemoUpdateMask(t *testing.T) {}func TestMCPToolCallBindsMemoFromPathForBodyStarOperations(t *testing.T) {- register := func(e *echo.Echo, method, path string, handler func(*echo.Context) error) {- switch method {- case http.MethodPatch:- e.PATCH(path, handler)- case http.MethodPost:- e.POST(path, handler)- default:- t.Fatalf("unsupported method %q", method)- }+ register := func(mux *http.ServeMux, method, path string, handler httphandler.Func) {+ mux.Handle(method+" "+strings.ReplaceAll(path, ":memo", "{memo}"), handler)}tests := []struct {@@ -497,25 +490,25 @@ func TestMCPToolCallBindsMemoFromPathForBodyStarOperations(t *testing.T) {for _, test := range tests {t.Run(test.name, func(t *testing.T) {- echoServer := echo.New()+ mux := http.NewServeMux()routeHits := 0- register(echoServer, test.method, test.path, func(c *echo.Context) error {+ register(mux, test.method, test.path, func(w http.ResponseWriter, r *http.Request) error {routeHits++// The memo must be bound from the path, and the omitted "name"// property must not reappear in the forwarded body.- require.Equal(t, "abc123", c.Param("memo"))+ require.Equal(t, "abc123", r.PathValue("memo"))body := map[string]any{}- require.NoError(t, json.NewDecoder(c.Request().Body).Decode(&body))+ require.NoError(t, json.NewDecoder(r.Body).Decode(&body))require.NotContains(t, body, "name")- return c.JSON(http.StatusOK, test.response)+ return httphandler.JSON(w, http.StatusOK, test.response)})- service, err := NewMCPService(&profile.Profile{Version: "test-version"}, echoServer)+ service, err := NewMCPService(&profile.Profile{Version: "test-version"}, mux)require.NoError(t, err)- service.RegisterRoutes(echoServer)+ service.RegisterRoutes(mux)- initializeMCP(t, echoServer)- response := postMCP(t, echoServer, map[string]any{+ initializeMCP(t, mux)+ response := postMCP(t, mux, map[string]any{"jsonrpc": "2.0","id": 2,"method": "tools/call",@@ -537,22 +530,22 @@ func TestMCPToolCallBindsMemoFromPathForBodyStarOperations(t *testing.T) {}func TestMCPToolCallRejectsInvalidArguments(t *testing.T) {- echoServer := echo.New()+ mux := http.NewServeMux()routeHits := 0- echoServer.GET("/api/memos", func(c *echo.Context) error {+ mux.Handle("GET /api/memos", httphandler.Func(func(w http.ResponseWriter, _ *http.Request) error {routeHits++- return c.JSON(http.StatusOK, map[string]any{"memos": []any{}})- })- echoServer.GET("/api/memos/:memo", func(c *echo.Context) error {+ return httphandler.JSON(w, http.StatusOK, map[string]any{"memos": []any{}})+ }))+ mux.Handle("GET /api/memos/{memo}", httphandler.Func(func(w http.ResponseWriter, r *http.Request) error {routeHits++- return c.JSON(http.StatusOK, map[string]any{"name": c.Param("memo")})- })+ return httphandler.JSON(w, http.StatusOK, map[string]any{"name": r.PathValue("memo")})+ }))- service, err := NewMCPService(&profile.Profile{Version: "test-version"}, echoServer)+ service, err := NewMCPService(&profile.Profile{Version: "test-version"}, mux)require.NoError(t, err)- service.RegisterRoutes(echoServer)+ service.RegisterRoutes(mux)- initializeMCP(t, echoServer)+ initializeMCP(t, mux)tests := []struct {name string@@ -582,7 +575,7 @@ func TestMCPToolCallRejectsInvalidArguments(t *testing.T) {for index, test := range tests {t.Run(test.name, func(t *testing.T) {- response := postMCP(t, echoServer, map[string]any{+ response := postMCP(t, mux, map[string]any{"jsonrpc": "2.0","id": index + 2,"method": "tools/call",@@ -616,10 +609,10 @@ func TestMCPToolCallRejectsInvalidArguments(t *testing.T) {// longer rejected by the SDK's DNS-rebinding guard, while memos' own Origin// allowlist still rejects disallowed origins.func TestMCPLoopbackBehindReverseProxy(t *testing.T) {- echoServer := echo.New()- service, err := NewMCPService(&profile.Profile{Version: "test-version"}, echoServer)+ mux := http.NewServeMux()+ service, err := NewMCPService(&profile.Profile{Version: "test-version"}, mux)require.NoError(t, err)- service.RegisterRoutes(echoServer)+ service.RegisterRoutes(mux)initialize, err := json.Marshal(map[string]any{"jsonrpc": "2.0",@@ -647,7 +640,7 @@ func TestMCPLoopbackBehindReverseProxy(t *testing.T) {t.Run("allows non-loopback host with no origin", func(t *testing.T) {recorder := httptest.NewRecorder()- echoServer.ServeHTTP(recorder, newRequest())+ mux.ServeHTTP(recorder, newRequest())require.Equal(t, http.StatusOK, recorder.Code, recorder.Body.String())})@@ -655,14 +648,14 @@ func TestMCPLoopbackBehindReverseProxy(t *testing.T) {request := newRequest()request.Header.Set("Origin", "https://evil.example.com")recorder := httptest.NewRecorder()- echoServer.ServeHTTP(recorder, request)+ mux.ServeHTTP(recorder, request)require.Equal(t, http.StatusForbidden, recorder.Code)})}-func initializeMCP(t *testing.T, echoServer *echo.Echo) {+func initializeMCP(t *testing.T, mux http.Handler) {t.Helper()- response := postMCP(t, echoServer, map[string]any{+ response := postMCP(t, mux, map[string]any{"jsonrpc": "2.0","id": 1,"method": "initialize",@@ -678,7 +671,7 @@ func initializeMCP(t *testing.T, echoServer *echo.Echo) {require.NotNil(t, response["result"])}-func postMCP(t *testing.T, echoServer *echo.Echo, payload map[string]any) map[string]any {+func postMCP(t *testing.T, mux http.Handler, payload map[string]any) map[string]any {t.Helper()data, err := json.Marshal(payload)require.NoError(t, err)@@ -688,7 +681,7 @@ func postMCP(t *testing.T, echoServer *echo.Echo, payload map[string]any) map[strequest.Header.Set("Accept", "application/json, text/event-stream")recorder := httptest.NewRecorder()- echoServer.ServeHTTP(recorder, request)+ mux.ServeHTTP(recorder, request)require.Equal(t, http.StatusOK, recorder.Code, recorder.Body.String())var response map[string]any@@ -699,15 +692,15 @@ func postMCP(t *testing.T, echoServer *echo.Echo, payload map[string]any) map[st// TestMCPStatelessProtocol2026 drives the endpoint the way a 2026-07-28 client// does: no initialize handshake, per-request _meta, and the standard MCP headers.func TestMCPStatelessProtocol2026(t *testing.T) {- echoServer := echo.New()+ mux := http.NewServeMux()var forwardedAuthorization string- echoServer.GET("/api/memos", func(c *echo.Context) error {- forwardedAuthorization = c.Request().Header.Get("Authorization")- return c.JSON(http.StatusOK, map[string]any{"memos": []any{}})- })- service, err := NewMCPService(&profile.Profile{Version: "test-version"}, echoServer)+ mux.Handle("GET /api/memos", httphandler.Func(func(w http.ResponseWriter, r *http.Request) error {+ forwardedAuthorization = r.Header.Get("Authorization")+ return httphandler.JSON(w, http.StatusOK, map[string]any{"memos": []any{}})+ }))+ service, err := NewMCPService(&profile.Profile{Version: "test-version"}, mux)require.NoError(t, err)- service.RegisterRoutes(echoServer)+ service.RegisterRoutes(mux)meta := map[string]any{"io.modelcontextprotocol/protocolVersion": "2026-07-28",@@ -715,7 +708,7 @@ func TestMCPStatelessProtocol2026(t *testing.T) {"io.modelcontextprotocol/clientInfo": map[string]any{"name": "memos-test", "version": "1.0.0"},}- discover := postMCPWithHeaders(t, echoServer, map[string]any{+ discover := postMCPWithHeaders(t, mux, map[string]any{"jsonrpc": "2.0","id": 1,"method": "server/discover",@@ -731,7 +724,7 @@ func TestMCPStatelessProtocol2026(t *testing.T) {require.NotContains(t, capabilities, "logging", "logging is deprecated and unused")require.Positive(t, discoverResult["ttlMs"])- list := postMCPWithHeaders(t, echoServer, map[string]any{+ list := postMCPWithHeaders(t, mux, map[string]any{"jsonrpc": "2.0","id": 2,"method": "tools/list",@@ -743,7 +736,7 @@ func TestMCPStatelessProtocol2026(t *testing.T) {require.Equal(t, float64(toolCatalogTTL.Milliseconds()), listResult["ttlMs"])require.Equal(t, "public", listResult["cacheScope"])- call := postMCPWithHeaders(t, echoServer, map[string]any{+ call := postMCPWithHeaders(t, mux, map[string]any{"jsonrpc": "2.0","id": 3,"method": "tools/call",@@ -767,16 +760,16 @@ func TestMCPStatelessProtocol2026(t *testing.T) {// TestMCPStatelessRejectsSessionMethods confirms the stateless transport shape// required by 2026-07-28: no GET stream, no DELETE session teardown.func TestMCPStatelessRejectsSessionMethods(t *testing.T) {- echoServer := echo.New()- service, err := NewMCPService(&profile.Profile{Version: "test-version"}, echoServer)+ mux := http.NewServeMux()+ service, err := NewMCPService(&profile.Profile{Version: "test-version"}, mux)require.NoError(t, err)- service.RegisterRoutes(echoServer)+ service.RegisterRoutes(mux)for _, method := range []string{http.MethodGet, http.MethodDelete} {request := httptest.NewRequest(method, "/mcp", nil)request.Header.Set("Accept", "application/json, text/event-stream")recorder := httptest.NewRecorder()- echoServer.ServeHTTP(recorder, request)+ mux.ServeHTTP(recorder, request)require.Equal(t, http.StatusMethodNotAllowed, recorder.Code, method)}}@@ -784,22 +777,22 @@ func TestMCPStatelessRejectsSessionMethods(t *testing.T) {// TestMCPRequestBodyLimitMatchesAPI guards against the SDK's 4 MiB default// overriding the API-wide limit, which would break attachment uploads over MCP.func TestMCPRequestBodyLimitMatchesAPI(t *testing.T) {- echoServer := echo.New()+ mux := http.NewServeMux()var receivedBytes int- echoServer.POST("/api/attachments", func(c *echo.Context) error {+ mux.Handle("POST /api/attachments", httphandler.Func(func(w http.ResponseWriter, r *http.Request) error {body := map[string]any{}- require.NoError(t, json.NewDecoder(c.Request().Body).Decode(&body))+ require.NoError(t, json.NewDecoder(r.Body).Decode(&body))content, ok := body["content"].(string)require.True(t, ok)receivedBytes = len(content)- return c.JSON(http.StatusOK, map[string]any{"name": "attachments/1"})- })- service, err := NewMCPService(&profile.Profile{Version: "test-version"}, echoServer)+ return httphandler.JSON(w, http.StatusOK, map[string]any{"name": "attachments/1"})+ }))+ service, err := NewMCPService(&profile.Profile{Version: "test-version"}, mux)require.NoError(t, err)- service.RegisterRoutes(echoServer)+ service.RegisterRoutes(mux)content := strings.Repeat("A", 8<<20)- response := postMCPWithHeaders(t, echoServer, map[string]any{+ response := postMCPWithHeaders(t, mux, map[string]any{"jsonrpc": "2.0","id": 1,"method": "tools/call",@@ -823,11 +816,11 @@ func TestMCPRequestBodyLimitMatchesAPI(t *testing.T) {request.Header.Set("Content-Type", "application/json")request.Header.Set("Accept", "application/json, text/event-stream")recorder := httptest.NewRecorder()- echoServer.ServeHTTP(recorder, request)+ mux.ServeHTTP(recorder, request)require.Equal(t, http.StatusRequestEntityTooLarge, recorder.Code)}-func postMCPWithHeaders(t *testing.T, echoServer *echo.Echo, payload map[string]any, headers map[string]string) map[string]any {+func postMCPWithHeaders(t *testing.T, mux http.Handler, payload map[string]any, headers map[string]string) map[string]any {t.Helper()data, err := json.Marshal(payload)require.NoError(t, err)@@ -843,7 +836,7 @@ func postMCPWithHeaders(t *testing.T, echoServer *echo.Echo, payload map[string]}recorder := httptest.NewRecorder()- echoServer.ServeHTTP(recorder, request)+ mux.ServeHTTP(recorder, request)require.Equal(t, http.StatusOK, recorder.Code, recorder.Body.String())var response map[string]anydiff --git a/server/server.go b/server/server.goindex de06f9fb8..c9b1341f3 100644--- a/server/server.go+++ b/server/server.go@@ -7,14 +7,14 @@ import ("net""net/http""os"+ "path""time""uuid"- "github.com/labstack/echo/v5"- "github.com/labstack/echo/v5/middleware""github.com/pkg/errors""github.com/usememos/memos/internal/clientip"+ "github.com/usememos/memos/internal/httphandler""github.com/usememos/memos/internal/profile"storepb "github.com/usememos/memos/proto/gen/store""github.com/usememos/memos/server/api"@@ -44,7 +44,7 @@ type Server struct {Profile *profile.ProfileStore *store.Store- echoServer *echo.Echo+ handler http.HandlerhttpServer *http.ServerapiService *api.APIService}@@ -55,17 +55,13 @@ func NewServer(ctx context.Context, profile *profile.Profile, store *store.StoreProfile: profile,}- echoServer := echo.New()- echoServer.Use(middleware.Recover())- echoServer.Use(newCORSMiddleware(profile))+ mux := http.NewServeMux()// Resolve the client address once per request, before anything that keys// on it: rate limits, session records, and the file server.clientIPResolver, err := clientip.ParseTrustedProxies(profile.TrustedProxies)if err != nil {return nil, errors.Wrap(err, "invalid trusted proxies")}- echoServer.Use(clientip.Middleware(clientIPResolver))- s.echoServer = echoServerinstanceBasicSetting, err := s.getOrUpsertInstanceBasicSetting(ctx)if err != nil {@@ -80,37 +76,45 @@ func NewServer(ctx context.Context, profile *profile.Profile, store *store.Store// Register healthz endpoint. It reports ready only while the database// answers, so a load balancer stops routing to an instance that lost it.- echoServer.GET("/healthz", func(c *echo.Context) error {- pingCtx, cancel := context.WithTimeout(c.Request().Context(), healthzDatabaseTimeout)+ mux.Handle("/healthz", httphandler.GET(httphandler.Func(func(w http.ResponseWriter, r *http.Request) error {+ pingCtx, cancel := context.WithTimeout(r.Context(), healthzDatabaseTimeout)defer cancel()if err := s.Store.GetDriver().GetDB().PingContext(pingCtx); err != nil {slog.Warn("health check failed to reach the database", slog.String("error", err.Error()))- return c.String(http.StatusServiceUnavailable, "Database unavailable.")+ return httphandler.Text(w, http.StatusServiceUnavailable, "Database unavailable.")}- return c.String(http.StatusOK, "Service ready.")- })-- // Serve frontend static files.- frontend.NewFrontendService(profile, store).Serve(ctx, echoServer)+ return httphandler.Text(w, http.StatusOK, "Service ready.")+ }), nil))apiService := api.NewAPIService(s.Secret, profile, store)s.apiService = apiService- // Register HTTP file server routes BEFORE gRPC-Gateway to ensure proper range request handling for Safari.- // This uses native HTTP serving (http.ServeContent) instead of gRPC for video/audio files.- fileServerService := fileserver.NewFileServerService(s.Profile, s.Store, s.Secret)- fileServerService.RegisterRoutes(echoServer)-- // Register gRPC gateway as api v1 (includes SSE endpoint on CORS-enabled group).- if err := apiService.RegisterGateway(ctx, echoServer); err != nil {- return nil, errors.Wrap(err, "failed to register gRPC gateway")+ apiHandler, err := apiService.NewHandler(ctx)+ if err != nil {+ return nil, errors.Wrap(err, "failed to create API handler")}+ frontendService := frontend.NewFrontendService(profile, store)+ frontendService.Serve(ctx, mux, apiHandler)+ fileServerService := fileserver.NewFileServerService(s.Profile, s.Store, s.Secret)+ fileServerService.RegisterRoutes(mux, apiHandler)+ // Preserve unclean-path routing without ServeMux's automatic redirects.+ fallback := frontendService.Handler(apiHandler)+ router := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ frontend.SetCacheHeaders(w, r)+ routingRequest := httphandler.RoutingRequest(r)+ if path.Clean(routingRequest.URL.Path) != routingRequest.URL.Path && routingRequest.URL.Path != "/" {+ fallback.ServeHTTP(w, r)+ return+ }+ mux.ServeHTTP(w, routingRequest)+ })+ s.handler = httphandler.Recover(clientip.Middleware(clientIPResolver)(newCORSMiddleware(profile, mux)(router)))- mcpService, err := mcp.NewMCPService(profile, echoServer)+ mcpService, err := mcp.NewMCPService(profile, s.handler)if err != nil {return nil, errors.Wrap(err, "failed to create MCP service")}- mcpService.RegisterRoutes(echoServer)+ mcpService.RegisterRoutes(mux)return s, nil}@@ -136,15 +140,15 @@ func (s *Server) Start() error {}}- // Start Echo server directly (no cmux needed - all traffic is HTTP).+ // All transports share the standard HTTP server.s.httpServer = &http.Server{- Handler: s.echoServer,+ Handler: s.handler,ReadHeaderTimeout: readHeaderTimeout,IdleTimeout: idleTimeout,}go func() {if err := s.httpServer.Serve(listener); err != nil && err != http.ErrServerClosed {- slog.Error("failed to start echo server", "error", err)+ slog.Error("failed to start HTTP server", "error", err)}}()diff --git a/server/test/startup_test.go b/server/test/startup_test.goindex a23fab331..9c53d7321 100644--- a/server/test/startup_test.go+++ b/server/test/startup_test.go@@ -474,7 +474,7 @@ func TestStartupPrivateInstanceGatewayPolicy(t *testing.T) {// attachment; the schema types that field as an object, so clients validating// responses against it — MCP clients serve that schema as the tool outputSchema// — reject every memo carrying an attachment. The marshaler override lives in-// RegisterGateway, so only a booted server proves it is wired in.+// NewHandler, so only a booted server proves it is wired in.func TestStartupGatewayOmitsNullMessageFields(t *testing.T) {ctx := context.Background()inst := bootInstance(ctx, t, instanceOptions{instanceURL: "http://localhost"})diff --git a/server/testdata/README.md b/server/testdata/README.mdnew file mode 100644index 000000000..7194518eb--- /dev/null+++ b/server/testdata/README.md@@ -0,0 +1,14 @@+# HTTP compatibility responses++`http_compat.jsonl` records 142 responses from the Echo implementation at+`ed838e805`, before the migration to `net/http`. `TestHTTPCompatibility` boots+the complete server and checks the same requests against these responses.++The cases cover method handling, CORS, API namespace boundaries, removed API+versions, escaped paths, trailing slashes, and SPA fallback. JSON bodies are+compared structurally because protobuf serialization may vary whitespace.+HTML bodies are represented by a marker, and Content-Length and Last-Modified+are excluded because rebuilding the embedded frontend changes them.++Treat these as the compatibility baseline. Do not regenerate them from the+new implementation to make a failing test pass.diff --git a/server/testdata/http_compat.jsonl b/server/testdata/http_compat.jsonlnew file mode 100644index 000000000..95368f8e6--- /dev/null+++ b/server/testdata/http_compat.jsonl@@ -0,0 +1,142 @@+{"Method":"GET","Path":"/healthz","RequestHeader":null,"Status":200,"Header":{"Cache-Control":["no-cache, no-store, must-revalidate"],"Content-Type":["text/plain; charset=UTF-8"],"Expires":["0"],"Pragma":["no-cache"],"Vary":["Origin"]},"Body":"Service ready."}+{"Method":"HEAD","Path":"/healthz","RequestHeader":null,"Status":405,"Header":{"Allow":["OPTIONS, GET"],"Cache-Control":["no-cache, no-store, must-revalidate"],"Expires":["0"],"Pragma":["no-cache"],"Vary":["Origin"]},"Body":""}+{"Method":"POST","Path":"/healthz","RequestHeader":null,"Status":405,"Header":{"Allow":["OPTIONS, GET"],"Cache-Control":["no-cache, no-store, must-revalidate"],"Content-Type":["application/json"],"Expires":["0"],"Pragma":["no-cache"],"Vary":["Origin"]},"Body":"{\"message\":\"Method Not Allowed\"}\n"}+{"Method":"OPTIONS","Path":"/healthz","RequestHeader":null,"Status":204,"Header":{"Allow":["OPTIONS, GET"],"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/healthz/","RequestHeader":null,"Status":200,"Header":{"Accept-Ranges":["bytes"],"Cache-Control":["no-cache, no-store, must-revalidate"],"Content-Type":["text/html; charset=utf-8"],"Expires":["0"],"Pragma":["no-cache"],"Vary":["Origin"]},"Body":"\u003cfrontend HTML\u003e"}+{"Method":"HEAD","Path":"/healthz/","RequestHeader":null,"Status":200,"Header":{"Accept-Ranges":["bytes"],"Cache-Control":["no-cache, no-store, must-revalidate"],"Content-Type":["text/html; charset=utf-8"],"Expires":["0"],"Pragma":["no-cache"],"Vary":["Origin"]},"Body":""}+{"Method":"POST","Path":"/healthz/","RequestHeader":null,"Status":200,"Header":{"Accept-Ranges":["bytes"],"Cache-Control":["no-cache, no-store, must-revalidate"],"Content-Type":["text/html; charset=utf-8"],"Expires":["0"],"Pragma":["no-cache"],"Vary":["Origin"]},"Body":"\u003cfrontend HTML\u003e"}+{"Method":"OPTIONS","Path":"/healthz/","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/health%7A","RequestHeader":null,"Status":200,"Header":{"Accept-Ranges":["bytes"],"Cache-Control":["no-cache, no-store, must-revalidate"],"Content-Type":["text/html; charset=utf-8"],"Expires":["0"],"Pragma":["no-cache"],"Vary":["Origin"]},"Body":"\u003cfrontend HTML\u003e"}+{"Method":"HEAD","Path":"/health%7A","RequestHeader":null,"Status":200,"Header":{"Accept-Ranges":["bytes"],"Cache-Control":["no-cache, no-store, must-revalidate"],"Content-Type":["text/html; charset=utf-8"],"Expires":["0"],"Pragma":["no-cache"],"Vary":["Origin"]},"Body":""}+{"Method":"POST","Path":"/health%7A","RequestHeader":null,"Status":200,"Header":{"Accept-Ranges":["bytes"],"Cache-Control":["no-cache, no-store, must-revalidate"],"Content-Type":["text/html; charset=utf-8"],"Expires":["0"],"Pragma":["no-cache"],"Vary":["Origin"]},"Body":"\u003cfrontend HTML\u003e"}+{"Method":"OPTIONS","Path":"/health%7A","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/api","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"message\":\"Not Found\"}\n"}+{"Method":"HEAD","Path":"/api","RequestHeader":null,"Status":404,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"POST","Path":"/api","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"message\":\"Not Found\"}\n"}+{"Method":"OPTIONS","Path":"/api","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/api/","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"HEAD","Path":"/api/","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"POST","Path":"/api/","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"OPTIONS","Path":"/api/","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/api/missing","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"HEAD","Path":"/api/missing","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"POST","Path":"/api/missing","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"OPTIONS","Path":"/api/missing","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/api/sse","RequestHeader":null,"Status":401,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"error\":\"authentication required\"}\n"}+{"Method":"HEAD","Path":"/api/sse","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"POST","Path":"/api/sse","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"OPTIONS","Path":"/api/sse","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/api/sse/","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"HEAD","Path":"/api/sse/","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"POST","Path":"/api/sse/","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"OPTIONS","Path":"/api/sse/","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/api/v1","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"HEAD","Path":"/api/v1","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"POST","Path":"/api/v1","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"OPTIONS","Path":"/api/v1","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/api/v1/","RequestHeader":null,"Status":410,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":12,\"message\":\"API v1 has been removed. Use /api/... for REST and /memos.api.\\u003cService\\u003e/\\u003cMethod\\u003e for Connect. See https://github.com/usememos/memos/blob/main/proto/api/CHANGELOG.md\"}\n"}+{"Method":"HEAD","Path":"/api/v1/","RequestHeader":null,"Status":410,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":12,\"message\":\"API v1 has been removed. Use /api/... for REST and /memos.api.\\u003cService\\u003e/\\u003cMethod\\u003e for Connect. See https://github.com/usememos/memos/blob/main/proto/api/CHANGELOG.md\"}\n"}+{"Method":"POST","Path":"/api/v1/","RequestHeader":null,"Status":410,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":12,\"message\":\"API v1 has been removed. Use /api/... for REST and /memos.api.\\u003cService\\u003e/\\u003cMethod\\u003e for Connect. See https://github.com/usememos/memos/blob/main/proto/api/CHANGELOG.md\"}\n"}+{"Method":"OPTIONS","Path":"/api/v1/","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/api/v1/memos","RequestHeader":null,"Status":410,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":12,\"message\":\"API v1 has been removed. Use /api/... for REST and /memos.api.\\u003cService\\u003e/\\u003cMethod\\u003e for Connect. See https://github.com/usememos/memos/blob/main/proto/api/CHANGELOG.md\"}\n"}+{"Method":"HEAD","Path":"/api/v1/memos","RequestHeader":null,"Status":410,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":12,\"message\":\"API v1 has been removed. Use /api/... for REST and /memos.api.\\u003cService\\u003e/\\u003cMethod\\u003e for Connect. See https://github.com/usememos/memos/blob/main/proto/api/CHANGELOG.md\"}\n"}+{"Method":"POST","Path":"/api/v1/memos","RequestHeader":null,"Status":410,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":12,\"message\":\"API v1 has been removed. Use /api/... for REST and /memos.api.\\u003cService\\u003e/\\u003cMethod\\u003e for Connect. See https://github.com/usememos/memos/blob/main/proto/api/CHANGELOG.md\"}\n"}+{"Method":"OPTIONS","Path":"/api/v1/memos","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/file","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"message\":\"Not Found\"}\n"}+{"Method":"HEAD","Path":"/file","RequestHeader":null,"Status":404,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"POST","Path":"/file","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"message\":\"Not Found\"}\n"}+{"Method":"OPTIONS","Path":"/file","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/file/","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"HEAD","Path":"/file/","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"POST","Path":"/file/","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"OPTIONS","Path":"/file/","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/file/attachments/missing","RequestHeader":null,"Status":404,"Header":{"Cache-Control":["private, no-store"],"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"message\":\"attachment not found\"}\n"}+{"Method":"HEAD","Path":"/file/attachments/missing","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"POST","Path":"/file/attachments/missing","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"OPTIONS","Path":"/file/attachments/missing","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/file/attachments/missing/","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"HEAD","Path":"/file/attachments/missing/","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"POST","Path":"/file/attachments/missing/","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"OPTIONS","Path":"/file/attachments/missing/","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/file/attachments/missing/a%2Fb.txt","RequestHeader":null,"Status":404,"Header":{"Cache-Control":["private, no-store"],"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"message\":\"attachment not found\"}\n"}+{"Method":"HEAD","Path":"/file/attachments/missing/a%2Fb.txt","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"POST","Path":"/file/attachments/missing/a%2Fb.txt","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"OPTIONS","Path":"/file/attachments/missing/a%2Fb.txt","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/file/attachments/%6dissing/file.txt","RequestHeader":null,"Status":404,"Header":{"Cache-Control":["private, no-store"],"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"message\":\"attachment not found\"}\n"}+{"Method":"HEAD","Path":"/file/attachments/%6dissing/file.txt","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"POST","Path":"/file/attachments/%6dissing/file.txt","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"OPTIONS","Path":"/file/attachments/%6dissing/file.txt","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/file/%61ttachments/missing/file.txt","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"HEAD","Path":"/file/%61ttachments/missing/file.txt","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"POST","Path":"/file/%61ttachments/missing/file.txt","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"OPTIONS","Path":"/file/%61ttachments/missing/file.txt","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/memos.api","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"message\":\"Not Found\"}\n"}+{"Method":"HEAD","Path":"/memos.api","RequestHeader":null,"Status":404,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"POST","Path":"/memos.api","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"message\":\"Not Found\"}\n"}+{"Method":"OPTIONS","Path":"/memos.api","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/memos.api.","RequestHeader":null,"Status":404,"Header":{"Content-Type":["text/plain; charset=utf-8"],"Vary":["Origin"],"X-Content-Type-Options":["nosniff"]},"Body":"404 page not found\n"}+{"Method":"HEAD","Path":"/memos.api.","RequestHeader":null,"Status":404,"Header":{"Content-Type":["text/plain; charset=utf-8"],"Vary":["Origin"],"X-Content-Type-Options":["nosniff"]},"Body":"404 page not found\n"}+{"Method":"POST","Path":"/memos.api.","RequestHeader":null,"Status":404,"Header":{"Content-Type":["text/plain; charset=utf-8"],"Vary":["Origin"],"X-Content-Type-Options":["nosniff"]},"Body":"404 page not found\n"}+{"Method":"OPTIONS","Path":"/memos.api.","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/memos.api.UnknownService/Unknown","RequestHeader":null,"Status":404,"Header":{"Content-Type":["text/plain; charset=utf-8"],"Vary":["Origin"],"X-Content-Type-Options":["nosniff"]},"Body":"404 page not found\n"}+{"Method":"HEAD","Path":"/memos.api.UnknownService/Unknown","RequestHeader":null,"Status":404,"Header":{"Content-Type":["text/plain; charset=utf-8"],"Vary":["Origin"],"X-Content-Type-Options":["nosniff"]},"Body":"404 page not found\n"}+{"Method":"POST","Path":"/memos.api.UnknownService/Unknown","RequestHeader":null,"Status":404,"Header":{"Content-Type":["text/plain; charset=utf-8"],"Vary":["Origin"],"X-Content-Type-Options":["nosniff"]},"Body":"404 page not found\n"}+{"Method":"OPTIONS","Path":"/memos.api.UnknownService/Unknown","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/memos.api.v1.MemoService/ListMemos","RequestHeader":null,"Status":410,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":\"unimplemented\",\"message\":\"API v1 has been removed. Use /api/... for REST and /memos.api.\\u003cService\\u003e/\\u003cMethod\\u003e for Connect. See https://github.com/usememos/memos/blob/main/proto/api/CHANGELOG.md\"}\n"}+{"Method":"HEAD","Path":"/memos.api.v1.MemoService/ListMemos","RequestHeader":null,"Status":410,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":\"unimplemented\",\"message\":\"API v1 has been removed. Use /api/... for REST and /memos.api.\\u003cService\\u003e/\\u003cMethod\\u003e for Connect. See https://github.com/usememos/memos/blob/main/proto/api/CHANGELOG.md\"}\n"}+{"Method":"POST","Path":"/memos.api.v1.MemoService/ListMemos","RequestHeader":null,"Status":410,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":\"unimplemented\",\"message\":\"API v1 has been removed. Use /api/... for REST and /memos.api.\\u003cService\\u003e/\\u003cMethod\\u003e for Connect. See https://github.com/usememos/memos/blob/main/proto/api/CHANGELOG.md\"}\n"}+{"Method":"OPTIONS","Path":"/memos.api.v1.MemoService/ListMemos","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/memos/x","RequestHeader":null,"Status":200,"Header":{"Accept-Ranges":["bytes"],"Cache-Control":["no-cache, no-store, must-revalidate"],"Content-Type":["text/html; charset=utf-8"],"Expires":["0"],"Pragma":["no-cache"],"Vary":["Origin"]},"Body":"\u003cfrontend HTML\u003e"}+{"Method":"HEAD","Path":"/memos/x","RequestHeader":null,"Status":200,"Header":{"Accept-Ranges":["bytes"],"Cache-Control":["no-cache, no-store, must-revalidate"],"Content-Type":["text/html; charset=utf-8"],"Expires":["0"],"Pragma":["no-cache"],"Vary":["Origin"]},"Body":""}+{"Method":"POST","Path":"/memos/x","RequestHeader":null,"Status":200,"Header":{"Accept-Ranges":["bytes"],"Cache-Control":["no-cache, no-store, must-revalidate"],"Content-Type":["text/html; charset=utf-8"],"Expires":["0"],"Pragma":["no-cache"],"Vary":["Origin"]},"Body":"\u003cfrontend HTML\u003e"}+{"Method":"OPTIONS","Path":"/memos/x","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/assets/missing.js","RequestHeader":null,"Status":404,"Header":{"Cache-Control":["public, max-age=2592000, immutable"],"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"message\":\"Not Found\"}\n"}+{"Method":"HEAD","Path":"/assets/missing.js","RequestHeader":null,"Status":404,"Header":{"Cache-Control":["public, max-age=2592000, immutable"],"Vary":["Origin"]},"Body":""}+{"Method":"POST","Path":"/assets/missing.js","RequestHeader":null,"Status":404,"Header":{"Cache-Control":["public, max-age=2592000, immutable"],"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"message\":\"Not Found\"}\n"}+{"Method":"OPTIONS","Path":"/assets/missing.js","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/index.html","RequestHeader":null,"Status":200,"Header":{"Accept-Ranges":["bytes"],"Cache-Control":["no-cache, no-store, must-revalidate"],"Content-Type":["text/html; charset=utf-8"],"Expires":["0"],"Pragma":["no-cache"],"Vary":["Origin"]},"Body":"\u003cfrontend HTML\u003e"}+{"Method":"HEAD","Path":"/index.html","RequestHeader":null,"Status":200,"Header":{"Accept-Ranges":["bytes"],"Cache-Control":["no-cache, no-store, must-revalidate"],"Content-Type":["text/html; charset=utf-8"],"Expires":["0"],"Pragma":["no-cache"],"Vary":["Origin"]},"Body":""}+{"Method":"POST","Path":"/index.html","RequestHeader":null,"Status":200,"Header":{"Accept-Ranges":["bytes"],"Cache-Control":["no-cache, no-store, must-revalidate"],"Content-Type":["text/html; charset=utf-8"],"Expires":["0"],"Pragma":["no-cache"],"Vary":["Origin"]},"Body":"\u003cfrontend HTML\u003e"}+{"Method":"OPTIONS","Path":"/index.html","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/robots.txt","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"message\":\"public instance discovery is unavailable\"}\n"}+{"Method":"HEAD","Path":"/robots.txt","RequestHeader":null,"Status":405,"Header":{"Allow":["OPTIONS, GET"],"Vary":["Origin"]},"Body":""}+{"Method":"POST","Path":"/robots.txt","RequestHeader":null,"Status":405,"Header":{"Allow":["OPTIONS, GET"],"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"message\":\"Method Not Allowed\"}\n"}+{"Method":"OPTIONS","Path":"/robots.txt","RequestHeader":null,"Status":204,"Header":{"Allow":["OPTIONS, GET"],"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/sitemap.xml","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"message\":\"public instance discovery is unavailable\"}\n"}+{"Method":"HEAD","Path":"/sitemap.xml","RequestHeader":null,"Status":405,"Header":{"Allow":["OPTIONS, GET"],"Vary":["Origin"]},"Body":""}+{"Method":"POST","Path":"/sitemap.xml","RequestHeader":null,"Status":405,"Header":{"Allow":["OPTIONS, GET"],"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"message\":\"Method Not Allowed\"}\n"}+{"Method":"OPTIONS","Path":"/sitemap.xml","RequestHeader":null,"Status":204,"Header":{"Allow":["OPTIONS, GET"],"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/api//instance/profile","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"HEAD","Path":"/api//instance/profile","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"POST","Path":"/api//instance/profile","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"OPTIONS","Path":"/api//instance/profile","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/api/../healthz","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"HEAD","Path":"/api/../healthz","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"POST","Path":"/api/../healthz","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"OPTIONS","Path":"/api/../healthz","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/api/instance/profile/","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"HEAD","Path":"/api/instance/profile/","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"POST","Path":"/api/instance/profile/","RequestHeader":null,"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"OPTIONS","Path":"/api/instance/profile/","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/mcp/","RequestHeader":null,"Status":200,"Header":{"Accept-Ranges":["bytes"],"Cache-Control":["no-cache, no-store, must-revalidate"],"Content-Type":["text/html; charset=utf-8"],"Expires":["0"],"Pragma":["no-cache"],"Vary":["Origin"]},"Body":"\u003cfrontend HTML\u003e"}+{"Method":"HEAD","Path":"/mcp/","RequestHeader":null,"Status":200,"Header":{"Accept-Ranges":["bytes"],"Cache-Control":["no-cache, no-store, must-revalidate"],"Content-Type":["text/html; charset=utf-8"],"Expires":["0"],"Pragma":["no-cache"],"Vary":["Origin"]},"Body":""}+{"Method":"POST","Path":"/mcp/","RequestHeader":null,"Status":200,"Header":{"Accept-Ranges":["bytes"],"Cache-Control":["no-cache, no-store, must-revalidate"],"Content-Type":["text/html; charset=utf-8"],"Expires":["0"],"Pragma":["no-cache"],"Vary":["Origin"]},"Body":"\u003cfrontend HTML\u003e"}+{"Method":"OPTIONS","Path":"/mcp/","RequestHeader":null,"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/healthz","RequestHeader":{"Access-Control-Request-Headers":["Authorization,Content-Type"],"Access-Control-Request-Method":["POST"],"Origin":["https://memos.example"]},"Status":200,"Header":{"Access-Control-Allow-Credentials":["true"],"Access-Control-Allow-Origin":["https://memos.example"],"Cache-Control":["no-cache, no-store, must-revalidate"],"Content-Type":["text/plain; charset=UTF-8"],"Expires":["0"],"Pragma":["no-cache"],"Vary":["Origin"]},"Body":"Service ready."}+{"Method":"OPTIONS","Path":"/healthz","RequestHeader":{"Access-Control-Request-Headers":["Authorization,Content-Type"],"Access-Control-Request-Method":["POST"],"Origin":["https://memos.example"]},"Status":204,"Header":{"Access-Control-Allow-Credentials":["true"],"Access-Control-Allow-Headers":["Authorization,Content-Type"],"Access-Control-Allow-Methods":["OPTIONS, GET"],"Access-Control-Allow-Origin":["https://memos.example"],"Allow":["OPTIONS, GET"],"Vary":["Origin","Access-Control-Request-Method","Access-Control-Request-Headers"]},"Body":""}+{"Method":"GET","Path":"/healthz","RequestHeader":{"Access-Control-Request-Headers":["Authorization,Content-Type"],"Access-Control-Request-Method":["POST"],"Origin":["https://evil.example"]},"Status":200,"Header":{"Access-Control-Allow-Origin":["https://evil.example"],"Cache-Control":["no-cache, no-store, must-revalidate"],"Content-Type":["text/plain; charset=UTF-8"],"Expires":["0"],"Pragma":["no-cache"],"Vary":["Origin"]},"Body":"Service ready."}+{"Method":"OPTIONS","Path":"/healthz","RequestHeader":{"Access-Control-Request-Headers":["Authorization,Content-Type"],"Access-Control-Request-Method":["POST"],"Origin":["https://evil.example"]},"Status":204,"Header":{"Access-Control-Allow-Headers":["Authorization,Content-Type"],"Access-Control-Allow-Methods":["OPTIONS, GET"],"Access-Control-Allow-Origin":["https://evil.example"],"Allow":["OPTIONS, GET"],"Vary":["Origin","Access-Control-Request-Method","Access-Control-Request-Headers"]},"Body":""}+{"Method":"GET","Path":"/healthz","RequestHeader":{"Access-Control-Request-Headers":["Authorization,Content-Type"],"Access-Control-Request-Method":["POST"],"Origin":["null"]},"Status":200,"Header":{"Cache-Control":["no-cache, no-store, must-revalidate"],"Content-Type":["text/plain; charset=UTF-8"],"Expires":["0"],"Pragma":["no-cache"],"Vary":["Origin"]},"Body":"Service ready."}+{"Method":"OPTIONS","Path":"/healthz","RequestHeader":{"Access-Control-Request-Headers":["Authorization,Content-Type"],"Access-Control-Request-Method":["POST"],"Origin":["null"]},"Status":204,"Header":{"Allow":["OPTIONS, GET"],"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/api/missing","RequestHeader":{"Access-Control-Request-Headers":["Authorization,Content-Type"],"Access-Control-Request-Method":["POST"],"Origin":["https://memos.example"]},"Status":404,"Header":{"Access-Control-Allow-Credentials":["true"],"Access-Control-Allow-Origin":["https://memos.example"],"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"OPTIONS","Path":"/api/missing","RequestHeader":{"Access-Control-Request-Headers":["Authorization,Content-Type"],"Access-Control-Request-Method":["POST"],"Origin":["https://memos.example"]},"Status":204,"Header":{"Access-Control-Allow-Credentials":["true"],"Access-Control-Allow-Headers":["Authorization,Content-Type"],"Access-Control-Allow-Methods":["GET,HEAD,PUT,PATCH,POST,DELETE"],"Access-Control-Allow-Origin":["https://memos.example"],"Vary":["Origin","Access-Control-Request-Method","Access-Control-Request-Headers"]},"Body":""}+{"Method":"GET","Path":"/api/missing","RequestHeader":{"Access-Control-Request-Headers":["Authorization,Content-Type"],"Access-Control-Request-Method":["POST"],"Origin":["https://evil.example"]},"Status":404,"Header":{"Access-Control-Allow-Origin":["https://evil.example"],"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"OPTIONS","Path":"/api/missing","RequestHeader":{"Access-Control-Request-Headers":["Authorization,Content-Type"],"Access-Control-Request-Method":["POST"],"Origin":["https://evil.example"]},"Status":204,"Header":{"Access-Control-Allow-Headers":["Authorization,Content-Type"],"Access-Control-Allow-Methods":["GET,HEAD,PUT,PATCH,POST,DELETE"],"Access-Control-Allow-Origin":["https://evil.example"],"Vary":["Origin","Access-Control-Request-Method","Access-Control-Request-Headers"]},"Body":""}+{"Method":"GET","Path":"/api/missing","RequestHeader":{"Access-Control-Request-Headers":["Authorization,Content-Type"],"Access-Control-Request-Method":["POST"],"Origin":["null"]},"Status":404,"Header":{"Content-Type":["application/json"],"Vary":["Origin"]},"Body":"{\"code\":5, \"message\":\"Not Found\", \"details\":[]}"}+{"Method":"OPTIONS","Path":"/api/missing","RequestHeader":{"Access-Control-Request-Headers":["Authorization,Content-Type"],"Access-Control-Request-Method":["POST"],"Origin":["null"]},"Status":204,"Header":{"Vary":["Origin"]},"Body":""}+{"Method":"GET","Path":"/memos/x","RequestHeader":{"Access-Control-Request-Headers":["Authorization,Content-Type"],"Access-Control-Request-Method":["POST"],"Origin":["https://memos.example"]},"Status":200,"Header":{"Accept-Ranges":["bytes"],"Access-Control-Allow-Credentials":["true"],"Access-Control-Allow-Origin":["https://memos.example"],"Cache-Control":["no-cache, no-store, must-revalidate"],"Content-Type":["text/html; charset=utf-8"],"Expires":["0"],"Pragma":["no-cache"],"Vary":["Origin"]},"Body":"\u003cfrontend HTML\u003e"}+{"Method":"OPTIONS","Path":"/memos/x","RequestHeader":{"Access-Control-Request-Headers":["Authorization,Content-Type"],"Access-Control-Request-Method":["POST"],"Origin":["https://memos.example"]},"Status":204,"Header":{"Access-Control-Allow-Credentials":["true"],"Access-Control-Allow-Headers":["Authorization,Content-Type"],"Access-Control-Allow-Methods":["GET,HEAD,PUT,PATCH,POST,DELETE"],"Access-Control-Allow-Origin":["https://memos.example"],"Vary":["Origin","Access-Control-Request-Method","Access-Control-Request-Headers"]},"Body":""}+{"Method":"GET","Path":"/memos/x","RequestHeader":{"Access-Control-Request-Headers":["Authorization,Content-Type"],"Access-Control-Request-Method":["POST"],"Origin":["https://evil.example"]},"Status":200,"Header":{"Accept-Ranges":["bytes"],"Access-Control-Allow-Origin":["https://evil.example"],"Cache-Control":["no-cache, no-store, must-revalidate"],"Content-Type":["text/html; charset=utf-8"],"Expires":["0"],"Pragma":["no-cache"],"Vary":["Origin"]},"Body":"\u003cfrontend HTML\u003e"}+{"Method":"OPTIONS","Path":"/memos/x","RequestHeader":{"Access-Control-Request-Headers":["Authorization,Content-Type"],"Access-Control-Request-Method":["POST"],"Origin":["https://evil.example"]},"Status":204,"Header":{"Access-Control-Allow-Headers":["Authorization,Content-Type"],"Access-Control-Allow-Methods":["GET,HEAD,PUT,PATCH,POST,DELETE"],"Access-Control-Allow-Origin":["https://evil.example"],"Vary":["Origin","Access-Control-Request-Method","Access-Control-Request-Headers"]},"Body":""}+{"Method":"GET","Path":"/memos/x","RequestHeader":{"Access-Control-Request-Headers":["Authorization,Content-Type"],"Access-Control-Request-Method":["POST"],"Origin":["null"]},"Status":200,"Header":{"Accept-Ranges":["bytes"],"Cache-Control":["no-cache, no-store, must-revalidate"],"Content-Type":["text/html; charset=utf-8"],"Expires":["0"],"Pragma":["no-cache"],"Vary":["Origin"]},"Body":"\u003cfrontend HTML\u003e"}+{"Method":"OPTIONS","Path":"/memos/x","RequestHeader":{"Access-Control-Request-Headers":["Authorization,Content-Type"],"Access-Control-Request-Method":["POST"],"Origin":["null"]},"Status":204,"Header":{"Vary":["Origin"]},"Body":""}