mathias
c0be5c473c
Closes #155
Reviewed by pr-gatekeeper: #181 (comment) (block, round 1) and re-review at e05a13a (approve).
Co-authored-by: Mathias <mthbqv@gmail.com>
96 lines
3.9 KiB
Go
96 lines
3.9 KiB
Go
package main
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
|
|
chassisauth "git.d-ma.be/mathias/mcp-chassis/auth"
|
|
|
|
"github.com/mathiasbq/hyperguild/ingestion/internal/api"
|
|
)
|
|
|
|
// publicRoutes is the complete set of patterns allowed on the outer mux,
|
|
// outside the REST API's auth (hyperguild#149). Each authenticates itself or is
|
|
// meant to be open: /mcp (bearer/JWT), /capture (bearer/JWT), the webhook
|
|
// (HMAC), /oauth/token (client secret), OAuth metadata and /metrics (open).
|
|
// A REST pattern added here would beat the authenticated catch-all by
|
|
// specificity and ship open, which is why buildMux refuses anything else.
|
|
var publicRoutes = map[string]bool{
|
|
"/mcp": true,
|
|
"POST /capture": true,
|
|
"POST /webhooks/brain-sync": true,
|
|
"GET /.well-known/oauth-protected-resource": true,
|
|
"GET /.well-known/oauth-authorization-server": true,
|
|
"POST /oauth/token": true,
|
|
"GET /metrics": true,
|
|
}
|
|
|
|
// restAuth is the credential the REST API checks: the same as /mcp's.
|
|
type restAuth struct {
|
|
token string
|
|
validator *chassisauth.JWTValidator
|
|
realm string
|
|
resourceMetadataURL string
|
|
}
|
|
|
|
// buildMux is the server's whole router. The REST API is mounted at "/"
|
|
// behind bearer auth that buildMux constructs itself, so a caller cannot pass
|
|
// a no-op; public handlers are registered as given, and only for patterns on
|
|
// the publicRoutes allowlist. It returns an http.Handler, not the
|
|
// *ServeMux, so nothing can register a route on the result afterwards and
|
|
// bypass the allowlist.
|
|
func buildMux(auth restAuth, h *api.Handler, public map[string]http.Handler) (http.Handler, error) {
|
|
if auth.token == "" {
|
|
return nil, errors.New("buildMux: REST auth needs a token")
|
|
}
|
|
mux := http.NewServeMux()
|
|
for pattern, handler := range public {
|
|
if !publicRoutes[pattern] {
|
|
return nil, fmt.Errorf("buildMux: %q is not an allowed public route", pattern)
|
|
}
|
|
mux.Handle(pattern, handler)
|
|
}
|
|
mountREST(mux, h, func(next http.Handler) http.Handler {
|
|
return chassisauth.BearerMiddleware(auth.token, auth.validator, auth.realm, auth.resourceMetadataURL, next)
|
|
})
|
|
return mux, nil
|
|
}
|
|
|
|
// mountREST registers the REST API on its own mux and mounts it at "/" behind
|
|
// auth: anything not registered as public lands here and is authenticated,
|
|
// including routes added later.
|
|
func mountREST(mux *http.ServeMux, h *api.Handler, auth func(http.Handler) http.Handler) {
|
|
rest := http.NewServeMux()
|
|
rest.HandleFunc("POST /query", h.Query)
|
|
rest.HandleFunc("POST /write", h.Write)
|
|
rest.HandleFunc("POST /index", h.Index)
|
|
rest.HandleFunc("POST /ingest", h.Ingest)
|
|
rest.HandleFunc("POST /ingest-path", h.IngestPath)
|
|
rest.HandleFunc("POST /ingest-raw", h.IngestRaw)
|
|
rest.HandleFunc("POST /backfill-refs", h.BackfillRefs)
|
|
rest.HandleFunc("GET /pending", h.Pending)
|
|
rest.HandleFunc("POST /promote", h.Promote)
|
|
rest.HandleFunc("POST /backfill-embeddings", h.BackfillEmbeddings)
|
|
rest.HandleFunc("GET /pass-rate", h.PassRate)
|
|
mux.Handle("/", labelRESTPattern(rest, auth(rest)))
|
|
}
|
|
|
|
// labelRESTPattern sets the request's Pattern to the REST route it addresses
|
|
// before auth runs, so the metrics middleware (which reads Pattern from the
|
|
// same *http.Request) labels a refused request by its route rather than by
|
|
// the "/" mount (hyperguild#155). A refused request to a path no route
|
|
// matches keeps "/", so for refused requests the label set stays bounded by
|
|
// the registered routes. That bound does not hold for authenticated
|
|
// requests: an unregistered path reaches the REST mux, which 404s with an
|
|
// empty Pattern, and the metrics middleware falls back to the raw URL path
|
|
// (hyperguild#185).
|
|
func labelRESTPattern(rest *http.ServeMux, next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if _, pattern := rest.Handler(r); pattern != "" {
|
|
r.Pattern = pattern
|
|
}
|
|
next.ServeHTTP(w, r)
|
|
})
|
|
}
|