package cabana import ( "encoding/json" "errors" "io" "net/http" "net/url" "strings" "time" "git.golem15.com/golem15/summercms/modules/bouncer" "git.golem15.com/golem15/summercms/modules/pact" ) // maxMCPConsentBody caps the POST /mcp/consent/{request} body. const maxMCPConsentBody = 16 << 10 // Messages of the consent endpoints (phrase keys under backend::lang). const ( mcpConsentNotFoundKey = "mcp_connect.request_not_found" mcpConsentNotFoundFallback = "This connection request has expired or does not exist." mcpConsentNoScopesKey = "mcp_connect.no_grantable_scopes" mcpConsentNoScopesFallback = "Choose at least one scope you can use." ) // mcpConsentProvider answers the published pact.MCPAdminConsent, nil when // no plugin publishes one. func (s *service) mcpConsentProvider() pact.MCPAdminConsent { if s == nil || s.app == nil { return nil } provider, ok := s.app.Lookup[pact.MCPAdminConsent]() if !ok || provider == nil { return nil } return provider } func (s *service) writeMCPConsentNotFound(w http.ResponseWriter, r *http.Request) { WriteError(w, http.StatusNotFound, "request_not_found", backendMessage(r.Context(), s.translator(), mcpConsentNotFoundKey, mcpConsentNotFoundFallback)) } func (s *service) writeMCPConsentNoScopes(w http.ResponseWriter, r *http.Request) { WriteError(w, http.StatusUnprocessableEntity, "no_grantable_scopes", backendMessage(r.Context(), s.translator(), mcpConsentNoScopesKey, mcpConsentNoScopesFallback)) } // grantableConsentScopes answers, in catalog order, the requested scope // names that are in the token-scope catalog and that the administrator can // grant (scopeOverlaps, the personal-token picker rule). Everything else is // hidden from the consent screen and dropped from a decision (D-11). func (s *service) grantableConsentScopes(principal *bouncer.Principal, requested []string) []*compiledTokenScope { if s.reg == nil || s.reg.tokenScopes == nil || principal == nil { return nil } want := make(map[string]bool, len(requested)) for _, name := range requested { want[strings.TrimSpace(name)] = true } var out []*compiledTokenScope for _, scope := range s.reg.tokenScopes.ordered { if want[scope.Name] && scopeOverlaps(s.reg, principal, scope.Name) { out = append(out, scope) } } return out } // mcpConsentRedirectHost is what the consent screen shows as the place the // browser returns to: the redirect URI's host (with its port), or, for a // URI without a host (a custom scheme), the URI without query and fragment. func mcpConsentRedirectHost(raw string) string { u, err := url.Parse(raw) if err != nil { return "" } if u.Host != "" { return u.Host } u.RawQuery, u.Fragment, u.RawFragment = "", "", "" return u.String() } // mcpConsentShow serves GET /mcp/consent/{request}: the pending MCP // authorization request of an administrator-only grant, as the published // pact.MCPAdminConsent resolves it for the signed-in administrator, with // only the requested scopes this administrator can grant. func (s *service) mcpConsentShow(w http.ResponseWriter, r *http.Request) { principal := accountPrincipal(w, r) if principal == nil { return } provider := s.mcpConsentProvider() if provider == nil { s.writeMCPConsentNotFound(w, r) return } ctx := r.Context() req, err := provider.MCPAdminConsentShow(ctx, principal.ID, r.PathValue("request")) if errors.Is(err, pact.ErrMCPConsentNotFound) { s.writeMCPConsentNotFound(w, r) return } if err != nil { moduleLog.ErrorContext(ctx, "cabana: mcp consent show failed", "admin_id", principal.ID, "error", err) WriteError(w, http.StatusInternalServerError, "error", msgServerError) return } db, err := s.db() if err != nil { moduleLog.ErrorContext(ctx, "cabana: mcp consent show without a database", "error", err) WriteError(w, http.StatusInternalServerError, "error", msgServerError) return } var admin BackendUser if err := db.WithContext(ctx).Select("id", "login", "first_name", "last_name", "email").Where("id = ?", principal.ID).Take(&admin).Error; err != nil { moduleLog.ErrorContext(ctx, "cabana: mcp consent show could not load the administrator", "admin_id", principal.ID, "error", err) WriteError(w, http.StatusInternalServerError, "error", msgServerError) return } tr := s.translator() scopes := []AdminAPITokenScope{} for _, scope := range s.grantableConsentScopes(principal, req.Scopes) { scopes = append(scopes, mapCompiledScope(ctx, tr, scope)) } expires := "" if !req.ExpiresAt.IsZero() { expires = req.ExpiresAt.UTC().Format(time.RFC3339) } WriteData(w, http.StatusOK, MCPConsentView{ RequestID: req.RequestID, Client: MCPConsentClientView{ ID: req.ClientID, Name: req.ClientName, RedirectHost: mcpConsentRedirectHost(req.RedirectURI), LogoURL: req.LogoURL, }, Admin: MCPConsentAdminView{ Login: admin.Login, Name: strings.TrimSpace(admin.FirstName + " " + admin.LastName), Email: admin.Email, }, Scopes: scopes, OfflineAccess: req.OfflineAccess, ConsentRequired: req.ConsentRequired, ExpiresAt: expires, }, nil) } // mcpConsentDecide serves POST /mcp/consent/{request}: the administrator's // allow or deny. An allow keeps the submitted scopes that were requested // and that the administrator can grant (others are dropped, not refused), // normalises them as personal-token creation does (* collapses to ["*"]) // and answers 422 no_grantable_scopes when nothing is left; offline access // is granted only when it was requested and the body asks for it. The // provider owns the transaction and the lock of the pending request. func (s *service) mcpConsentDecide(w http.ResponseWriter, r *http.Request) { principal := accountPrincipal(w, r) if principal == nil { return } provider := s.mcpConsentProvider() if provider == nil { s.writeMCPConsentNotFound(w, r) return } var body MCPConsentDecisionRequest dec := json.NewDecoder(http.MaxBytesReader(w, r.Body, maxMCPConsentBody)) dec.DisallowUnknownFields() if err := dec.Decode(&body); err != nil || dec.Decode(&struct{}{}) != io.EOF { WriteError(w, http.StatusBadRequest, "invalid_request", "Invalid request") return } ctx := r.Context() requestID := r.PathValue("request") var decision pact.MCPAdminConsentDecision switch body.Decision { case "deny": case "allow": req, err := provider.MCPAdminConsentShow(ctx, principal.ID, requestID) if errors.Is(err, pact.ErrMCPConsentNotFound) { s.writeMCPConsentNotFound(w, r) return } if err != nil { moduleLog.ErrorContext(ctx, "cabana: mcp consent decide could not load the request", "admin_id", principal.ID, "error", err) WriteError(w, http.StatusInternalServerError, "error", msgServerError) return } grantable := map[string]bool{} for _, scope := range s.grantableConsentScopes(principal, req.Scopes) { grantable[scope.Name] = true } kept := make([]string, 0, len(body.Scopes)) for _, name := range body.Scopes { if name = strings.TrimSpace(name); grantable[name] { kept = append(kept, name) } } if len(kept) == 0 { s.writeMCPConsentNoScopes(w, r) return } scopes, details := validateTokenScopes(s.reg, principal, kept) if details != nil || len(scopes) == 0 { s.writeMCPConsentNoScopes(w, r) return } decision = pact.MCPAdminConsentDecision{ Allow: true, Scopes: scopes, OfflineAccess: req.OfflineAccess && body.OfflineAccess, } default: WriteError(w, http.StatusBadRequest, "invalid_request", "Invalid request") return } redirect, err := provider.MCPAdminConsentDecide(ctx, principal.ID, requestID, decision) switch { case errors.Is(err, pact.ErrMCPConsentNotFound): s.writeMCPConsentNotFound(w, r) return case errors.Is(err, pact.ErrMCPConsentNoScopes): s.writeMCPConsentNoScopes(w, r) return case err != nil: moduleLog.ErrorContext(ctx, "cabana: mcp consent decide failed", "admin_id", principal.ID, "allow", decision.Allow, "error", err) WriteError(w, http.StatusInternalServerError, "error", msgServerError) return } moduleLog.InfoContext(ctx, "cabana: mcp consent decided", "admin_id", principal.ID, "allow", decision.Allow, "scopes", decision.Scopes) WriteData(w, http.StatusOK, MCPConsentDecisionView{RedirectURI: redirect}, nil) }