diff --git a/AGENTS.md b/AGENTS.md index 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 source Memos 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.mod index 63a385724..a1b1d6bc6 100644 --- a/go.mod +++ b/go.mod @@ -18,7 +18,6 @@ require ( github.com/grpc-ecosystem/grpc-gateway/v2 v2.30.0 github.com/johannesboyne/gofakes3 v1.2.0 github.com/joho/godotenv v1.5.1 - github.com/labstack/echo/v5 v5.3.1 github.com/lib/pq v1.12.3 github.com/lithammer/shortuuid/v4 v4.2.0 github.com/moby/moby/api v1.55.0 diff --git a/go.sum b/go.sum index 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.md index 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.go index 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.go index 08024fb79..be4d17771 100644 --- a/internal/clientip/clientip_test.go +++ b/internal/clientip/clientip_test.go @@ -2,6 +2,7 @@ package clientip import ( "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.go new file mode 100644 index 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.go new file mode 100644 index 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.go index 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.go index 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 string diff --git a/server/api/attachment_upload_transport_test.go b/server/api/attachment_upload_transport_test.go index 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.go index 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.go index 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.go index 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.go index 1418d2381..722e744b7 100644 --- a/server/cors.go +++ b/server/cors.go @@ -1,41 +1,57 @@ package server import ( + "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) + } + } } - // Trusted origins additionally get credentialed (cookie) access. - if isAllowedCORSOrigin(profile, c.Request().Host, origin) { - c.Response().Header().Set(echo.HeaderAccessControlAllowCredentials, "true") + 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) + } + } } - // Reflect every origin; only trusted ones carry the credentials header. - return origin, true, nil - }, - }) + if preflight { + w.WriteHeader(http.StatusNoContent) + return + } + next.ServeHTTP(w, r) + }) + } } func isAllowedCORSOrigin(profile *profile.Profile, requestHost, origin string) bool { diff --git a/server/cors_test.go b/server/cors_test.go index 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.go index 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.go index 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 nil case 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 nil case 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.RangeNotSatisfiableError if 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.StatusOK if 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 *ec facts, 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, nil case 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.go index 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.Name rec := 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.Name rec := 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.go index 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) { - frontendFS := getFileSystem("dist") - skipper := func(c *echo.Context) bool { - requestPath := c.Request().URL.Path - if shouldSkipFrontendStatic(requestPath) { - return true - } - - 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 (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)) } -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(c, requestPath) - return c.FileFS("index.html", frontendFS) +// Handler serves static files and SPA routes, passing API namespaces to fallback. +func (*FrontendService) Handler(fallback http.Handler) http.Handler { + frontendFS := getFileSystem("dist") + return httphandler.Func(func(w http.ResponseWriter, r *http.Request) error { + requestPath := r.URL.Path + if shouldSkipFrontendStatic(requestPath) { + fallback.ServeHTTP(w, r) + return nil } - } + 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)} + } + 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.go index 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(), `https://demo.usememos.com/memos/publicmemo`) 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.go new file mode 100644 index 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), "") { + body = "" + } + 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), "") { + body = "" + } + 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.md index 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 is derived from an operation in the generated OpenAPI document (`proto/gen/openapi.yaml`, embedded via `proto.OpenAPIYAML()`), and a tool call is 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 single source 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.go index 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.go index 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.go index 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.go index 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[st request.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]any diff --git a/server/server.go b/server/server.go index 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.Profile Store *store.Store - echoServer *echo.Echo + handler http.Handler httpServer *http.Server apiService *api.APIService } @@ -55,17 +55,13 @@ func NewServer(ctx context.Context, profile *profile.Profile, store *store.Store Profile: 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 = echoServer instanceBasicSetting, 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.go index 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.md new file mode 100644 index 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.jsonl new file mode 100644 index 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":""}