fix(rbac): address PR 2 review feedback

Middleware
- RequireOwnershipOrRole now skips the creator lookup entirely when
  EnableRBAC is off, eliminating a hidden per-request DB roundtrip in
  the rollout window.
- New ErrResourceNotFound sentinel lets lookups signal "not visible to
  this tenant"; the middleware passes the request through so handlers
  can return a real 404 instead of a misleading 403.
- Transient lookup failures now surface as 503 (was 403) so monitoring
  can tell denied-by-policy from cannot-verify-right-now.
- Cross-tenant superusers (CanAccessAllTenants) bypass tenant role gates,
  restoring DELETE /tenants/:id and ResetAPIKey for org operators that
  resolve to Admin in foreign tenants.
- Construction-time warning fires once when cfg is nil/incomplete, so a
  wiring bug that disables enforcement globally is visible at boot.

Route coverage
- Add role guards to FAQ, KnowledgeTag, WikiPage, Skill, WebSearch,
  WebSearchProvider, WeKnoraCloud, Session, Chat, and Message route
  groups so the matrix actually matches the PR description.

Service layer
- KB and agent creators are no longer recorded as the synthetic
  system-<tenantID> user used by the X-API-Key path; resources stay
  tenant-owned. New types.IsSyntheticUserID helper centralises the
  prefix check.
- KBCreatorLookup and AgentCreatorLookup re-check tenant scope so a
  same-ID resource in another tenant cannot piggyback through the
  ownership shortcut.

Docs
- CustomAgent.RunnableByViewer comment now matches enforcement: it only
  blocks Viewer-driven agent-mode runs, not plain RAG/Wiki QA.

Tests
- New cases for the 503/404 paths, lookup-skip behaviour, cross-tenant
  superuser bypass, the lookup helpers (not-found, cross-tenant,
  built-in agent, missing tenant context), and IsSyntheticUserID.
This commit is contained in:
wizardchen
2026-05-13 21:37:47 +08:00
committed by lyingbug
parent 9e3c92ca95
commit 8b71def60b
10 changed files with 621 additions and 162 deletions
+6 -4
View File
@@ -68,8 +68,9 @@ func (s *customAgentService) CreateAgent(ctx context.Context, agent *types.Custo
// Record the creator. Mirrors KnowledgeBase.CreatorID — needed by
// RBAC's RequireOwnershipOrRole so Contributors can edit their own
// agents. Synthetic system-{tenantID} users (X-API-Key path) leave
// the field empty, which makes the agent tenant-owned (Admin+ only).
if uid, ok := types.UserIDFromContext(ctx); ok {
// the field empty via IsSyntheticUserID, which makes the agent
// tenant-owned (Admin+ only).
if uid, ok := types.UserIDFromContext(ctx); ok && !types.IsSyntheticUserID(uid) {
agent.CreatedBy = uid
}
@@ -415,8 +416,9 @@ func (s *customAgentService) CopyAgent(ctx context.Context, id string) (*types.C
UpdatedAt: time.Now(),
}
// The clone is owned by whoever ran the copy, not the original
// creator — same reasoning as CopyKnowledgeBase.
if uid, ok := types.UserIDFromContext(ctx); ok {
// creator — same reasoning as CopyKnowledgeBase. Skip synthetic
// API-key users.
if uid, ok := types.UserIDFromContext(ctx); ok && !types.IsSyntheticUserID(uid) {
newAgent.CreatedBy = uid
}
+10 -7
View File
@@ -94,11 +94,13 @@ func (s *knowledgeBaseService) CreateKnowledgeBase(ctx context.Context,
kb.UpdatedAt = time.Now()
// Record the creator so RBAC's RequireOwnershipOrRole can let
// Contributors edit their own KBs without granting them tenant-wide
// edit rights. UserIDFromContext returns ("", false) for the
// synthetic system-{tenantID} user used by the X-API-Key auth path
// — leaving CreatorID empty there marks the KB as tenant-owned, which
// matches today's API-key semantics (any human Admin can manage it).
if uid, ok := types.UserIDFromContext(ctx); ok {
// edit rights. The X-API-Key auth path attaches a synthetic
// `system-<tenantID>` user; we deliberately skip those so the KB
// stays tenant-owned (CreatorID == ""), which matches the original
// API-key semantics (any human Admin can manage it) and prevents a
// later "list KBs by creator" feature from surfacing rows nobody can
// re-attribute.
if uid, ok := types.UserIDFromContext(ctx); ok && !types.IsSyntheticUserID(uid) {
kb.CreatorID = uid
}
kb.EnsureDefaults()
@@ -804,8 +806,9 @@ func (s *knowledgeBaseService) CopyKnowledgeBase(ctx context.Context,
}
// The clone is owned by the caller, not the original creator —
// otherwise a Contributor copying someone else's KB would still
// not be able to edit the result.
if uid, ok := types.UserIDFromContext(ctx); ok {
// not be able to edit the result. Skip synthetic API-key users
// (see CreateKnowledgeBase for the same reasoning).
if uid, ok := types.UserIDFromContext(ctx); ok && !types.IsSyntheticUserID(uid) {
targetKB.CreatorID = uid
}
targetKB.EnsureDefaults()
+53 -15
View File
@@ -4,37 +4,59 @@ import (
"errors"
apprepo "github.com/Tencent/WeKnora/internal/application/repository"
"github.com/Tencent/WeKnora/internal/application/service"
"github.com/Tencent/WeKnora/internal/middleware"
"github.com/Tencent/WeKnora/internal/types"
"github.com/gin-gonic/gin"
)
// Per-resource creator-id resolvers used by middleware.RequireOwnershipOrRole.
// The route registration wires these as closures so they capture the handler's
// service dependencies; the middleware just calls them with the gin.Context
// and gets back ("", nil) for legacy tenant-owned rows or (creatorID, nil)
// for resources we know how to attribute.
// and gets back one of:
//
// Lookup contract (mirrors middleware.CreatorLookup):
// - URL param missing -> error (the middleware will 403; better than
// letting an unauthenticated mutation through on a malformed route).
// - Resource not found -> error (downstream handler would 404 anyway,
// and middleware-level 403 is a fine signal to clients).
// - Resource found but creator_id == "" -> ("", nil); the middleware
// treats that as tenant-owned and falls back to pure role check.
// - (creatorID, nil) : ownership match check decides
// - ("", nil) : tenant-owned (legacy or built-in)
// - ("", ErrResourceNotFound) : :id doesn't resolve in this tenant;
// middleware passes through so the
// handler can issue a real 404
// - ("", <other err>) : transient/unexpected failure;
// middleware will 503 the request
//
// Tenant scoping is enforced INSIDE the lookup: even if the underlying
// `Get*ByID` repo call is unscoped, the lookup re-checks `tenant_id`
// against the caller's context. This stops a creator-match shortcut
// from leaking access to a same-ID resource in a different tenant.
// KBCreatorLookup resolves :id -> KnowledgeBase.CreatorID. Used by all
// per-KB mutating routes.
// KBCreatorLookup resolves :id -> KnowledgeBase.CreatorID, scoped to
// the caller's tenant. Used by all per-KB mutating routes.
func (h *KnowledgeBaseHandler) KBCreatorLookup(c *gin.Context) (string, error) {
id := c.Param("id")
if id == "" {
return "", errors.New("missing :id param for KB creator lookup")
}
kb, err := h.service.GetKnowledgeBaseByID(c.Request.Context(), id)
ctx := c.Request.Context()
tenantID, ok := types.TenantIDFromContext(ctx)
if !ok {
// 没有租户上下文意味着 auth 中间件未完成;当作 lookup 失败让上层 503,
// 而不是 silently 走 fail-open 给一个不该有的访问。
return "", errors.New("tenant context missing")
}
kb, err := h.service.GetKnowledgeBaseByID(ctx, id)
if err != nil {
if errors.Is(err, apprepo.ErrKnowledgeBaseNotFound) {
return "", middleware.ErrResourceNotFound
}
return "", err
}
if kb == nil {
return "", apprepo.ErrKnowledgeBaseNotFound
return "", middleware.ErrResourceNotFound
}
// 显式重校验租户:repo.GetKnowledgeBaseByID 不带 tenant 过滤,
// 万一未来 :id 被攻击者从他人租户 UUID 试探到,也不会借由
// "ownership match" 通过中间件。
if kb.TenantID != tenantID {
return "", middleware.ErrResourceNotFound
}
return kb.CreatorID, nil
}
@@ -44,17 +66,33 @@ func (h *KnowledgeBaseHandler) KBCreatorLookup(c *gin.Context) (string, error) {
// belong to the tenant rather than to any one user, so we return
// ("", nil) and let the role check decide. The same holds for legacy
// rows whose CreatedBy was never populated.
//
// The underlying GetAgentByID already scopes to the caller's tenant,
// but we keep an explicit defence-in-depth check here in case future
// refactors loosen the service-layer scope.
func (h *CustomAgentHandler) AgentCreatorLookup(c *gin.Context) (string, error) {
id := c.Param("id")
if id == "" {
return "", errors.New("missing :id param for agent creator lookup")
}
agent, err := h.service.GetAgentByID(c.Request.Context(), id)
ctx := c.Request.Context()
tenantID, ok := types.TenantIDFromContext(ctx)
if !ok {
return "", errors.New("tenant context missing")
}
agent, err := h.service.GetAgentByID(ctx, id)
if err != nil {
if errors.Is(err, service.ErrAgentNotFound) ||
errors.Is(err, apprepo.ErrCustomAgentNotFound) {
return "", middleware.ErrResourceNotFound
}
return "", err
}
if agent == nil {
return "", errors.New("agent not found")
return "", middleware.ErrResourceNotFound
}
if agent.TenantID != tenantID {
return "", middleware.ErrResourceNotFound
}
if agent.IsBuiltin {
return "", nil
+150
View File
@@ -0,0 +1,150 @@
package handler
import (
"context"
"errors"
"net/http"
"net/http/httptest"
"testing"
apprepo "github.com/Tencent/WeKnora/internal/application/repository"
"github.com/Tencent/WeKnora/internal/application/service"
"github.com/Tencent/WeKnora/internal/middleware"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
"github.com/gin-gonic/gin"
)
// The lookup helpers translate handler/service errors into the
// middleware sentinel set; that translation is where bugs hide (404
// becoming 403, cross-tenant leaks, etc.), so we test those edges
// directly rather than via end-to-end HTTP.
// stubKBService implements just enough of interfaces.KnowledgeBaseService
// to drive KBCreatorLookup. Any other method panics so the test fails
// loudly if a future lookup refactor reaches outside the contract.
type stubKBService struct {
interfaces.KnowledgeBaseService
get func(ctx context.Context, id string) (*types.KnowledgeBase, error)
}
func (s *stubKBService) GetKnowledgeBaseByID(ctx context.Context, id string) (*types.KnowledgeBase, error) {
return s.get(ctx, id)
}
func newKBLookupCtx(t *testing.T, tenantID uint64, paramID string) *gin.Context {
t.Helper()
gin.SetMode(gin.TestMode)
c, _ := gin.CreateTestContext(httptest.NewRecorder())
c.Request = httptest.NewRequest(http.MethodGet, "/x", nil)
ctx := context.WithValue(c.Request.Context(), types.TenantIDContextKey, tenantID)
c.Request = c.Request.WithContext(ctx)
c.Params = gin.Params{{Key: "id", Value: paramID}}
return c
}
func TestKBCreatorLookup_NotFoundMapsToSentinel(t *testing.T) {
h := &KnowledgeBaseHandler{service: &stubKBService{
get: func(_ context.Context, _ string) (*types.KnowledgeBase, error) {
return nil, apprepo.ErrKnowledgeBaseNotFound
},
}}
_, err := h.KBCreatorLookup(newKBLookupCtx(t, 1, "kb-1"))
if !errors.Is(err, middleware.ErrResourceNotFound) {
t.Fatalf("expected ErrResourceNotFound, got %v", err)
}
}
func TestKBCreatorLookup_CrossTenantIsHiddenAsNotFound(t *testing.T) {
// A foreign-tenant KB must NEVER leak via the ownership shortcut.
// Returning the row's CreatorID would let a user-id collision pass
// the middleware's "creator == uid" branch; hiding it as not-found
// keeps the lookup strictly tenant-scoped.
h := &KnowledgeBaseHandler{service: &stubKBService{
get: func(_ context.Context, _ string) (*types.KnowledgeBase, error) {
return &types.KnowledgeBase{ID: "kb-1", TenantID: 999, CreatorID: "u1"}, nil
},
}}
_, err := h.KBCreatorLookup(newKBLookupCtx(t, 1, "kb-1"))
if !errors.Is(err, middleware.ErrResourceNotFound) {
t.Fatalf("cross-tenant KB must surface as not-found, got %v", err)
}
}
func TestKBCreatorLookup_OwnerMatchReturnsCreatorID(t *testing.T) {
h := &KnowledgeBaseHandler{service: &stubKBService{
get: func(_ context.Context, _ string) (*types.KnowledgeBase, error) {
return &types.KnowledgeBase{ID: "kb-1", TenantID: 1, CreatorID: "u-creator"}, nil
},
}}
creator, err := h.KBCreatorLookup(newKBLookupCtx(t, 1, "kb-1"))
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if creator != "u-creator" {
t.Fatalf("expected creator=u-creator, got %q", creator)
}
}
func TestKBCreatorLookup_MissingTenantContext(t *testing.T) {
// Without tenant context, the lookup can't decide scope. Surfacing
// a real error (which middleware turns into 503) is safer than
// silently returning ErrResourceNotFound: the request shouldn't be
// happening at all.
gin.SetMode(gin.TestMode)
c, _ := gin.CreateTestContext(httptest.NewRecorder())
c.Request = httptest.NewRequest(http.MethodGet, "/x", nil)
c.Params = gin.Params{{Key: "id", Value: "kb-1"}}
h := &KnowledgeBaseHandler{service: &stubKBService{
get: func(_ context.Context, _ string) (*types.KnowledgeBase, error) {
t.Fatalf("service must not be called without tenant context")
return nil, nil
},
}}
_, err := h.KBCreatorLookup(c)
if err == nil {
t.Fatalf("expected error when tenant context missing")
}
if errors.Is(err, middleware.ErrResourceNotFound) {
t.Fatalf("missing tenant must not be reported as not-found: %v", err)
}
}
// stubAgentService mirrors stubKBService for the agent lookup tests.
type stubAgentService struct {
interfaces.CustomAgentService
get func(ctx context.Context, id string) (*types.CustomAgent, error)
}
func (s *stubAgentService) GetAgentByID(ctx context.Context, id string) (*types.CustomAgent, error) {
return s.get(ctx, id)
}
func TestAgentCreatorLookup_BuiltinIsTenantOwned(t *testing.T) {
h := &CustomAgentHandler{service: &stubAgentService{
get: func(_ context.Context, _ string) (*types.CustomAgent, error) {
return &types.CustomAgent{
ID: "smart-reasoning", TenantID: 1, IsBuiltin: true, CreatedBy: "ignored",
}, nil
},
}}
creator, err := h.AgentCreatorLookup(newKBLookupCtx(t, 1, "smart-reasoning"))
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if creator != "" {
t.Fatalf("built-in agent must surface as tenant-owned (empty creator), got %q", creator)
}
}
func TestAgentCreatorLookup_AgentNotFoundMapsToSentinel(t *testing.T) {
h := &CustomAgentHandler{service: &stubAgentService{
get: func(_ context.Context, _ string) (*types.CustomAgent, error) {
return nil, service.ErrAgentNotFound
},
}}
_, err := h.AgentCreatorLookup(newKBLookupCtx(t, 1, "missing-agent"))
if !errors.Is(err, middleware.ErrResourceNotFound) {
t.Fatalf("expected ErrResourceNotFound, got %v", err)
}
}
+130 -48
View File
@@ -1,7 +1,10 @@
package middleware
import (
"context"
"errors"
"net/http"
"sync"
"github.com/Tencent/WeKnora/internal/config"
"github.com/Tencent/WeKnora/internal/logger"
@@ -9,25 +12,49 @@ import (
"github.com/gin-gonic/gin"
)
// ErrResourceNotFound is the sentinel a CreatorLookup returns when the
// :id on the request does not match any row the lookup can see (either
// the row is genuinely missing or its tenant doesn't match). When a
// lookup returns this error, RequireOwnershipOrRole intentionally lets
// the request proceed so the downstream handler can respond with its
// own 404 — middleware-level 403 would hide real "URL is wrong" failures
// behind a permissions error, which breaks client diagnostics and
// operator dashboards.
var ErrResourceNotFound = errors.New("rbac: resource not found")
// CreatorLookup resolves the creator user ID for the resource targeted
// by the current request, based on whatever is on the gin.Context (URL
// params, query, body). Implementations live next to the handlers they
// guard, e.g. handler.kbCreatorLookup(c) reads ":id" and returns
// KnowledgeBase.CreatorID.
//
// Returning ("", nil) means "no creator recorded" — the resource pre-dates
// the migration backfill. RequireOwnershipOrRole treats this as
// "tenant-owned" and requires the role check to pass.
//
// Any non-nil error short-circuits the request with 403; callers should
// distinguish "not found" (404 in the handler if needed) from genuine
// failures inside their lookup helper.
// Return value contract:
// - (creatorID, nil) where creatorID != "" -> the resource has a
// recorded owner; ownership match grants access.
// - ("", nil) -> "tenant-owned": no
// human creator was recorded (legacy row or built-in resource);
// only callers whose role meets the bar may proceed.
// - ("", ErrResourceNotFound) -> the :id does not
// resolve to any row visible to this caller's tenant. Middleware
// proceeds to the handler so the handler can return 404 instead
// of masking it as 403.
// - ("", other error) -> transient or
// unexpected failure (DB hiccup, etc.). Middleware returns 503
// when enforcement is on so monitoring catches the real fault;
// when enforcement is off, it logs and lets the request through.
type CreatorLookup func(c *gin.Context) (creatorID string, err error)
// RequireRole returns a gin middleware that aborts the request with
// HTTP 403 unless the caller's TenantRole (set by the auth middleware
// in TenantRoleContextKey) is at least min.
//
// Cross-tenant superusers (User.CanAccessAllTenants) automatically
// satisfy any role gate. Otherwise rolling out tenant-RBAC would silently
// break organisation-level operators who own no tenant_members row in
// the tenant they're administering. The escape hatch is bounded by the
// existing canAccessTenant gate in auth.go; this middleware does not
// grant extra reach, only honours what was already approved.
//
// When cfg.Tenant.EnableRBAC is false, the middleware logs the would-be
// rejection but lets the request through — preserving today's behaviour
// during the rollout window. Once operators flip the flag to true,
@@ -38,21 +65,27 @@ type CreatorLookup func(c *gin.Context) (creatorID string, err error)
// is the safest fail-closed value: anything that requires more than
// Viewer will reject.
func RequireRole(min types.TenantRole, cfg *config.Config) gin.HandlerFunc {
warnOnNilConfig(cfg)
return func(c *gin.Context) {
role := types.TenantRoleFromContext(c.Request.Context())
ctx := c.Request.Context()
role := types.TenantRoleFromContext(ctx)
if role.HasPermission(min) {
c.Next()
return
}
uid, _ := types.UserIDFromContext(c.Request.Context())
if isCrossTenantSuperuser(ctx) {
c.Next()
return
}
uid, _ := types.UserIDFromContext(ctx)
if !rbacEnforcementEnabled(cfg) {
logger.Warnf(c.Request.Context(),
logger.Warnf(ctx,
"[rbac] role insufficient (logged but not enforced): user=%s have=%s need=%s path=%s",
uid, role, min, c.Request.URL.Path)
c.Next()
return
}
logger.Warnf(c.Request.Context(),
logger.Warnf(ctx,
"[rbac] role insufficient: user=%s have=%s need=%s path=%s",
uid, role, min, c.Request.URL.Path)
c.JSON(http.StatusForbidden, gin.H{
@@ -69,66 +102,81 @@ func RequireRole(min types.TenantRole, cfg *config.Config) gin.HandlerFunc {
// Use it for KB / agent mutations where Contributors should only manage
// their own resources but Admins+ have free reign. The lookup closure
// is responsible for translating the URL into the resource's creator
// user ID.
// user ID (see CreatorLookup for the return-value contract).
//
// Decision order:
// 1. role >= min -> allow.
// 2. lookup returns the caller's user ID -> allow.
// 3. lookup returns a non-empty different user ID -> deny (or log when
// enforcement is disabled).
// 4. lookup returns an empty creator ID (legacy / unmigrated row) ->
// treat as tenant-owned; only role >= min may proceed. Effectively
// equivalent to step 1 for that row.
// 5. lookup returns an error -> deny (don't fail open on lookup errors:
// a broken creator query is more often a bug than a transient blip,
// and treating a load failure as "approve" would be a footgun).
//
// Like RequireRole, when cfg.Tenant.EnableRBAC is false the middleware
// logs but does not block.
// 1. role >= min -> allow without running lookup.
// 2. cross-tenant superuser -> allow without running lookup.
// 3. enforcement off -> log, allow without running lookup. This is the
// critical rollout-safety guarantee: when EnableRBAC is false, the
// lookup is NEVER invoked, so dormant mode incurs zero extra DB
// roundtrips on hot per-resource mutation paths.
// 4. lookup returns ErrResourceNotFound -> pass through; let the
// handler issue the proper 404.
// 5. lookup returns other error -> 503 (transient/unexpected fault).
// Preserves observability instead of disguising server errors as 403.
// 6. lookup returns the caller's user ID -> allow (ownership match).
// 7. lookup returns "" -> tenant-owned, role check already failed: 403.
// 8. lookup returns a different non-empty user ID -> 403.
func RequireOwnershipOrRole(min types.TenantRole, lookup CreatorLookup, cfg *config.Config) gin.HandlerFunc {
warnOnNilConfig(cfg)
return func(c *gin.Context) {
ctx := c.Request.Context()
role := types.TenantRoleFromContext(ctx)
// Fast path: role meets the bar, skip the lookup entirely.
// 1. Fast path: role meets the bar.
if role.HasPermission(min) {
c.Next()
return
}
// 2. Cross-tenant superuser bypass — same reasoning as RequireRole.
if isCrossTenantSuperuser(ctx) {
c.Next()
return
}
uid, _ := types.UserIDFromContext(ctx)
creator, err := lookup(c)
if err != nil {
// 3. Fail-open shortcut: when enforcement is off, do NOT run the
// lookup. Running it would add a hidden DB roundtrip on every
// mutating request during the rollout window — see #1318 review.
if !rbacEnforcementEnabled(cfg) {
logger.Warnf(ctx,
"[rbac] ownership/role would be checked (enforcement off, lookup skipped): "+
"user=%s have=%s need=%s path=%s",
uid, role, min, c.Request.URL.Path)
c.Next()
return
}
creator, err := lookup(c)
switch {
case errors.Is(err, ErrResourceNotFound):
// 4. Hand off to the handler so the client sees a real 404
// rather than a fake "no permission" 403.
c.Next()
return
case err != nil:
// 5. Genuine failure — surface it as 5xx so monitoring catches it.
logger.Errorf(ctx,
"[rbac] creator lookup failed: user=%s path=%s err=%v",
uid, c.Request.URL.Path, err)
if !rbacEnforcementEnabled(cfg) {
c.Next()
return
}
c.JSON(http.StatusForbidden, gin.H{
"error": "Forbidden: cannot verify resource ownership",
c.JSON(http.StatusServiceUnavailable, gin.H{
"error": "Service Unavailable: cannot verify resource ownership",
})
c.Abort()
return
}
// Ownership match wins even when role is below min — that's the
// whole point: Contributors can edit their own resources.
// 6. Ownership match wins even when role is below min — that's the
// whole point: Contributors can edit their own resources.
if creator != "" && creator == uid {
c.Next()
return
}
if !rbacEnforcementEnabled(cfg) {
logger.Warnf(ctx,
"[rbac] ownership/role insufficient (logged, not enforced): "+
"user=%s have=%s need=%s creator=%q path=%s",
uid, role, min, creator, c.Request.URL.Path)
c.Next()
return
}
// 7-8. Tenant-owned (creator=="") or non-creator with insufficient role.
logger.Warnf(ctx,
"[rbac] ownership/role insufficient: user=%s have=%s need=%s creator=%q path=%s",
uid, role, min, creator, c.Request.URL.Path)
@@ -141,9 +189,43 @@ func RequireOwnershipOrRole(min types.TenantRole, lookup CreatorLookup, cfg *con
// rbacEnforcementEnabled reports whether middleware should actually
// reject failed checks. When the flag is off the middleware still runs
// (so role lookups exercise the membership table and any logging fires)
// but rejection is downgraded to a warning. Mirrors the pattern in
// resolveTenantRole's fail-open branch in middleware/auth.go.
// role-only checks (logging, fast paths), but rejection is downgraded
// to a warning and ownership lookups are skipped entirely so the dormant
// rollout window incurs no per-request DB cost.
func rbacEnforcementEnabled(cfg *config.Config) bool {
return cfg != nil && cfg.Tenant != nil && cfg.Tenant.EnableRBAC
}
// isCrossTenantSuperuser reports whether the caller is an org-level
// superuser whose CanAccessAllTenants flag was honoured by the auth
// middleware (cfg.Tenant.EnableCrossTenantAccess must also be on for
// the flag to mean anything operationally). Such callers bypass tenant
// role gates because their access is already governed by a separate
// org-level authorisation check.
func isCrossTenantSuperuser(ctx context.Context) bool {
u, ok := ctx.Value(types.UserContextKey).(*types.User)
if !ok || u == nil {
return false
}
return u.CanAccessAllTenants
}
// warnOnNilConfig emits a one-shot startup warning when a guard is
// constructed with a nil-or-incomplete config. nil cfg makes
// rbacEnforcementEnabled return false, which means an entire deployment
// silently runs with RBAC disabled — usually because of a configuration
// bug rather than an intentional choice. Operators should see a noisy
// log line at boot pointing at the misconfiguration.
var nilCfgWarnOnce sync.Once
func warnOnNilConfig(cfg *config.Config) {
if cfg != nil && cfg.Tenant != nil {
return
}
nilCfgWarnOnce.Do(func() {
logger.Errorf(context.Background(),
"[rbac] middleware constructed with nil/incomplete config "+
"(cfg=%v); enforcement is permanently disabled. This is "+
"almost certainly a wiring bug.", cfg)
})
}
+96 -4
View File
@@ -142,14 +142,106 @@ func TestRequireOwnershipOrRole_LegacyEmptyCreatorTreatedAsTenantOwned(t *testin
}
}
func TestRequireOwnershipOrRole_LookupErrorRejects(t *testing.T) {
// A failing lookup is treated as deny — failing open here would mean
func TestRequireOwnershipOrRole_LookupErrorReturns503(t *testing.T) {
// A transient lookup error surfaces as 503 (not 403) so monitoring
// and clients can tell "your permission was denied" from "the server
// briefly couldn't verify ownership". Failing open here would mean
// any DB hiccup on the creator query becomes a free pass.
lookup := func(c *gin.Context) (string, error) { return "", errors.New("boom") }
w := rbacTestHarness(types.TenantRoleContributor, "u1",
RequireOwnershipOrRole(types.TenantRoleAdmin, lookup, cfgRBAC(true)))
if w.Code != http.StatusForbidden {
t.Fatalf("lookup error must reject, got %d", w.Code)
if w.Code != http.StatusServiceUnavailable {
t.Fatalf("lookup error must surface as 503, got %d", w.Code)
}
}
func TestRequireOwnershipOrRole_NotFoundPassesThroughTo404(t *testing.T) {
// When the lookup signals "no such resource visible to this tenant",
// the middleware MUST NOT mask it as 403. The handler downstream
// gets to decide the right status (usually 404), which keeps client
// error handling honest and avoids hiding "wrong URL" behind a
// permissions error.
called := false
lookup := func(c *gin.Context) (string, error) {
return "", ErrResourceNotFound
}
router := gin.New()
router.Use(func(c *gin.Context) {
ctx := c.Request.Context()
ctx = context.WithValue(ctx, types.TenantRoleContextKey, types.TenantRoleContributor)
ctx = context.WithValue(ctx, types.UserIDContextKey, "u1")
c.Request = c.Request.WithContext(ctx)
c.Next()
})
router.GET("/protected",
RequireOwnershipOrRole(types.TenantRoleAdmin, lookup, cfgRBAC(true)),
func(c *gin.Context) {
called = true
c.JSON(http.StatusNotFound, gin.H{"error": "kb not found"})
},
)
req := httptest.NewRequest(http.MethodGet, "/protected", nil)
w := httptest.NewRecorder()
router.ServeHTTP(w, req)
if !called {
t.Fatalf("handler should have been invoked so it can produce 404")
}
if w.Code != http.StatusNotFound {
t.Fatalf("expected handler 404 to win, got %d", w.Code)
}
}
func TestRequireOwnershipOrRole_SkipsLookupWhenRBACDisabled(t *testing.T) {
// H1 regression: when enforcement is off, the lookup must not run at
// all. Hooking up RBAC pre-rollout used to add a hidden DB roundtrip
// to every mutating request even though the result was thrown away.
calls := 0
lookup := func(c *gin.Context) (string, error) {
calls++
return "someone-else", nil
}
w := rbacTestHarness(types.TenantRoleViewer, "u1",
RequireOwnershipOrRole(types.TenantRoleAdmin, lookup, cfgRBAC(false)))
if w.Code != http.StatusOK {
t.Fatalf("fail-open should let the request through, got %d", w.Code)
}
if calls != 0 {
t.Fatalf("lookup must not run when EnableRBAC=false (got %d calls)", calls)
}
}
func TestRequireOwnershipOrRole_CrossTenantSuperuserBypass(t *testing.T) {
// Cross-tenant superusers resolve to Admin in foreign tenants (see
// resolveTenantRole). For Owner-only gates we additionally let them
// through to preserve the pre-RBAC ability to administer any tenant.
calls := 0
lookup := func(c *gin.Context) (string, error) {
calls++
return "", nil
}
router := gin.New()
router.Use(func(c *gin.Context) {
ctx := c.Request.Context()
ctx = context.WithValue(ctx, types.TenantRoleContextKey, types.TenantRoleAdmin)
ctx = context.WithValue(ctx, types.UserIDContextKey, "su1")
ctx = context.WithValue(ctx, types.UserContextKey, &types.User{
ID: "su1", CanAccessAllTenants: true,
})
c.Request = c.Request.WithContext(ctx)
c.Next()
})
router.GET("/protected",
RequireOwnershipOrRole(types.TenantRoleOwner, lookup, cfgRBAC(true)),
func(c *gin.Context) { c.JSON(http.StatusOK, gin.H{}) },
)
req := httptest.NewRequest(http.MethodGet, "/protected", nil)
w := httptest.NewRecorder()
router.ServeHTTP(w, req)
if w.Code != http.StatusOK {
t.Fatalf("superuser must bypass Owner gate, got %d", w.Code)
}
if calls != 0 {
t.Fatalf("superuser bypass must skip lookup, got %d", calls)
}
}
+111 -81
View File
@@ -151,28 +151,28 @@ func NewRouter(params RouterParams) *gin.Engine {
RegisterAuthRoutes(v1, params.AuthHandler)
RegisterTenantRoutes(v1, params.TenantHandler, rbacGuards)
RegisterKnowledgeBaseRoutes(v1, params.KBHandler, rbacGuards)
RegisterKnowledgeTagRoutes(v1, params.TagHandler)
RegisterKnowledgeTagRoutes(v1, params.TagHandler, rbacGuards)
RegisterKnowledgeRoutes(v1, params.KnowledgeHandler, rbacGuards)
RegisterFAQRoutes(v1, params.FAQHandler)
RegisterFAQRoutes(v1, params.FAQHandler, rbacGuards)
RegisterChunkRoutes(v1, params.ChunkHandler, rbacGuards)
RegisterSessionRoutes(v1, params.SessionHandler)
RegisterChatRoutes(v1, params.SessionHandler)
RegisterMessageRoutes(v1, params.MessageHandler)
RegisterSessionRoutes(v1, params.SessionHandler, rbacGuards)
RegisterChatRoutes(v1, params.SessionHandler, rbacGuards)
RegisterMessageRoutes(v1, params.MessageHandler, rbacGuards)
RegisterModelRoutes(v1, params.ModelHandler, params.ModelCredentialsHandler, rbacGuards)
RegisterEvaluationRoutes(v1, params.EvaluationHandler)
RegisterInitializationRoutes(v1, params.InitializationHandler)
RegisterSystemRoutes(v1, params.SystemHandler)
RegisterMCPServiceRoutes(v1, params.MCPServiceHandler, params.MCPCredentialsHandler, rbacGuards)
RegisterWebSearchRoutes(v1, params.WebSearchHandler)
RegisterWebSearchRoutes(v1, params.WebSearchHandler, rbacGuards)
RegisterWebSearchProviderRoutes(v1, params.WebSearchProviderHandler, params.WebSearchCredentialsHandler, rbacGuards)
RegisterVectorStoreRoutes(v1, params.VectorStoreHandler, rbacGuards)
RegisterCustomAgentRoutes(v1, params.CustomAgentHandler, rbacGuards)
RegisterSkillRoutes(v1, params.SkillHandler)
RegisterSkillRoutes(v1, params.SkillHandler, rbacGuards)
RegisterOrganizationRoutes(v1, params.OrganizationHandler)
RegisterIMChannelRoutes(v1, params.IMHandler, rbacGuards)
RegisterDataSourceRoutes(v1, params.DataSourceHandler, params.DataSourceCredentialsHandler, rbacGuards)
RegisterWeKnoraCloudRoutes(v1, params.WeKnoraCloudHandler)
RegisterWikiPageRoutes(v1, params.WikiPageHandler)
RegisterWeKnoraCloudRoutes(v1, params.WeKnoraCloudHandler, rbacGuards)
RegisterWikiPageRoutes(v1, params.WikiPageHandler, rbacGuards)
RegisterChunkerDebugRoutes(v1)
}
@@ -246,31 +246,35 @@ func RegisterKnowledgeRoutes(r *gin.RouterGroup, handler *handler.KnowledgeHandl
}
// RegisterFAQRoutes 注册 FAQ 相关路由
func RegisterFAQRoutes(r *gin.RouterGroup, handler *handler.FAQHandler) {
//
// FAQ entries are KB content: reads are Viewer+, all mutations
// (create / update / upsert / delete / batch field+tag updates,
// import display flag) are Contributor+. Search is read-only.
func RegisterFAQRoutes(r *gin.RouterGroup, handler *handler.FAQHandler, g *rbacGuards) {
if handler == nil {
return
}
faq := r.Group("/knowledge-bases/:id/faq")
{
faq.GET("/entries", handler.ListEntries)
faq.GET("/entries/export", handler.ExportEntries)
faq.GET("/entries/:entry_id", handler.GetEntry)
faq.POST("/entries", handler.UpsertEntries)
faq.POST("/entry", handler.CreateEntry)
faq.PUT("/entries/:entry_id", handler.UpdateEntry)
faq.POST("/entries/:entry_id/similar-questions", handler.AddSimilarQuestions)
faq.GET("/entries", g.Viewer(), handler.ListEntries)
faq.GET("/entries/export", g.Viewer(), handler.ExportEntries)
faq.GET("/entries/:entry_id", g.Viewer(), handler.GetEntry)
faq.POST("/entries", g.Contributor(), handler.UpsertEntries)
faq.POST("/entry", g.Contributor(), handler.CreateEntry)
faq.PUT("/entries/:entry_id", g.Contributor(), handler.UpdateEntry)
faq.POST("/entries/:entry_id/similar-questions", g.Contributor(), handler.AddSimilarQuestions)
// Unified batch update API - supports is_enabled, is_recommended, tag_id
faq.PUT("/entries/fields", handler.UpdateEntryFieldsBatch)
faq.PUT("/entries/tags", handler.UpdateEntryTagBatch)
faq.DELETE("/entries", handler.DeleteEntries)
faq.POST("/search", handler.SearchFAQ)
faq.PUT("/entries/fields", g.Contributor(), handler.UpdateEntryFieldsBatch)
faq.PUT("/entries/tags", g.Contributor(), handler.UpdateEntryTagBatch)
faq.DELETE("/entries", g.Contributor(), handler.DeleteEntries)
faq.POST("/search", g.Viewer(), handler.SearchFAQ)
// FAQ import result display status
faq.PUT("/import/last-result/display", handler.UpdateLastImportResultDisplayStatus)
faq.PUT("/import/last-result/display", g.Contributor(), handler.UpdateLastImportResultDisplayStatus)
}
// FAQ import progress route (outside of knowledge-base scope)
// FAQ import progress route (outside of knowledge-base scope) — Viewer+
faqImport := r.Group("/faq/import")
{
faqImport.GET("/progress/:task_id", handler.GetImportProgress)
faqImport.GET("/progress/:task_id", g.Viewer(), handler.GetImportProgress)
}
}
@@ -302,39 +306,49 @@ func RegisterKnowledgeBaseRoutes(r *gin.RouterGroup, handler *handler.KnowledgeB
}
}
// RegisterKnowledgeTagRoutes 注册知识库标签相关路由
func RegisterKnowledgeTagRoutes(r *gin.RouterGroup, tagHandler *handler.TagHandler) {
// RegisterKnowledgeTagRoutes 注册知识库标签相关路由。
//
// Tags are KB metadata: Viewer reads, Contributor writes. Per-KB
// ownership granularity for tags is out of scope for PR 2; this is
// purely role-based.
func RegisterKnowledgeTagRoutes(r *gin.RouterGroup, tagHandler *handler.TagHandler, g *rbacGuards) {
if tagHandler == nil {
return
}
kbTags := r.Group("/knowledge-bases/:id/tags")
{
kbTags.GET("", tagHandler.ListTags)
kbTags.POST("", tagHandler.CreateTag)
kbTags.PUT("/:tag_id", tagHandler.UpdateTag)
kbTags.DELETE("/:tag_id", tagHandler.DeleteTag)
kbTags.GET("", g.Viewer(), tagHandler.ListTags)
kbTags.POST("", g.Contributor(), tagHandler.CreateTag)
kbTags.PUT("/:tag_id", g.Contributor(), tagHandler.UpdateTag)
kbTags.DELETE("/:tag_id", g.Contributor(), tagHandler.DeleteTag)
}
}
// RegisterMessageRoutes 注册消息相关的路由
func RegisterMessageRoutes(r *gin.RouterGroup, handler *handler.MessageHandler) {
// 消息路由组
// RegisterMessageRoutes 注册消息相关的路由。
//
// Per-session ownership is already enforced inside each handler (the
// user must own the session). We add Viewer+ here so non-members
// (e.g. revoked accounts retained in the tenant for audit) cannot
// reach the endpoints at all once RBAC is on.
func RegisterMessageRoutes(r *gin.RouterGroup, handler *handler.MessageHandler, g *rbacGuards) {
messages := r.Group("/messages")
{
// 搜索历史对话(关键词 + 向量混合搜索)
messages.POST("/search", handler.SearchMessages)
// 获取聊天历史知识库的统计信息
messages.GET("/chat-history-stats", handler.GetChatHistoryKBStats)
// 加载更早的消息,用于向上滚动加载
messages.GET("/:session_id/load", handler.LoadMessages)
// 删除消息
messages.DELETE("/:session_id/:id", handler.DeleteMessage)
messages.POST("/search", g.Viewer(), handler.SearchMessages)
messages.GET("/chat-history-stats", g.Viewer(), handler.GetChatHistoryKBStats)
messages.GET("/:session_id/load", g.Viewer(), handler.LoadMessages)
messages.DELETE("/:session_id/:id", g.Viewer(), handler.DeleteMessage)
}
}
// RegisterSessionRoutes 注册路由
func RegisterSessionRoutes(r *gin.RouterGroup, handler *session.Handler) {
sessions := r.Group("/sessions")
// RegisterSessionRoutes 注册路由。
//
// Sessions are per-user resources; the handler enforces user ownership.
// We gate at Viewer+ to keep non-members out once RBAC is on, matching
// the message routes above. A future refactor can introduce
// per-session ownership in the middleware layer the same way KB/agent
// routes do today.
func RegisterSessionRoutes(r *gin.RouterGroup, handler *session.Handler, g *rbacGuards) {
sessions := r.Group("/sessions", g.Viewer())
{
sessions.POST("", handler.CreateSession)
sessions.DELETE("/batch", handler.BatchDeleteSessions)
@@ -356,21 +370,23 @@ func RegisterSessionRoutes(r *gin.RouterGroup, handler *session.Handler) {
}
}
// RegisterChatRoutes 注册路由
func RegisterChatRoutes(r *gin.RouterGroup, handler *session.Handler) {
knowledgeChat := r.Group("/knowledge-chat")
// RegisterChatRoutes 注册路由。Chat endpoints are tenant-member usage
// surfaces; Viewer+ is sufficient because per-session/per-agent
// authorisation is enforced inside the handlers.
func RegisterChatRoutes(r *gin.RouterGroup, handler *session.Handler, g *rbacGuards) {
knowledgeChat := r.Group("/knowledge-chat", g.Viewer())
{
knowledgeChat.POST("/:session_id", handler.KnowledgeQA)
}
// Agent-based chat
agentChat := r.Group("/agent-chat")
agentChat := r.Group("/agent-chat", g.Viewer())
{
agentChat.POST("/:session_id", handler.AgentQA)
}
// 新增知识检索接口,不需要session_id
knowledgeSearch := r.Group("/knowledge-search")
knowledgeSearch := r.Group("/knowledge-search", g.Viewer())
{
knowledgeSearch.POST("", handler.SearchKnowledge)
}
@@ -555,20 +571,21 @@ func RegisterMCPServiceRoutes(
}
// RegisterWebSearchRoutes registers web search routes
func RegisterWebSearchRoutes(r *gin.RouterGroup, webSearchHandler *handler.WebSearchHandler) {
// Web search providers
func RegisterWebSearchRoutes(r *gin.RouterGroup, webSearchHandler *handler.WebSearchHandler, g *rbacGuards) {
// Web search providers — Viewer+ (read-only listing of provider catalog).
webSearch := r.Group("/web-search")
{
// Get available providers
webSearch.GET("/providers", webSearchHandler.GetProviders)
webSearch.GET("/providers", g.Viewer(), webSearchHandler.GetProviders)
}
}
// RegisterWebSearchProviderRoutes registers CRUD routes for web search provider configurations.
// RegisterWebSearchProviderRoutes registers CRUD routes for web search
// provider configurations.
//
// Web search providers hold tenant-level external API credentials
// (Google/Bing/Tavily/...); reads are Viewer+, all writes / connection
// tests / credential subresource are Admin+.
// Provider rows hold external service credentials (Bing, Tavily, Google,
// etc.); reads are Viewer+, all mutations / connection tests (which
// probe external systems with stored credentials) and the per-field
// credential subresource are Admin+.
func RegisterWebSearchProviderRoutes(
r *gin.RouterGroup,
h *handler.WebSearchProviderHandler,
@@ -648,12 +665,16 @@ func RegisterCustomAgentRoutes(r *gin.RouterGroup, agentHandler *handler.CustomA
r.GET("/agents/:id/suggested-questions", g.Viewer(), agentHandler.GetSuggestedQuestions)
}
// RegisterSkillRoutes registers skill routes
func RegisterSkillRoutes(r *gin.RouterGroup, skillHandler *handler.SkillHandler) {
// RegisterSkillRoutes registers skill routes.
//
// PR 2 currently only exposes a read-only `ListSkills`; gated to
// Viewer+. Future skill upload / enable endpoints must use Admin+ since
// skills run sandboxed code on tenant resources.
func RegisterSkillRoutes(r *gin.RouterGroup, skillHandler *handler.SkillHandler, g *rbacGuards) {
skills := r.Group("/skills")
{
// List all preloaded skills
skills.GET("", skillHandler.ListSkills)
// List all preloaded skills — Viewer+
skills.GET("", g.Viewer(), skillHandler.ListSkills)
}
}
@@ -1082,38 +1103,47 @@ func RegisterDataSourceRoutes(
}
// RegisterWeKnoraCloudRoutes 注册 WeKnoraCloud 初始化路由
func RegisterWeKnoraCloudRoutes(r *gin.RouterGroup, handler *handler.WeKnoraCloudHandler) {
r.POST("/weknoracloud/credentials", handler.SaveCredentials)
r.GET("/models/weknoracloud/status", handler.Status)
// RegisterWeKnoraCloudRoutes registers the WeKnoraCloud credential
// management endpoints. SaveCredentials persists external SaaS keys
// for the tenant (Admin+), Status is a low-risk readiness probe (Viewer+).
func RegisterWeKnoraCloudRoutes(r *gin.RouterGroup, handler *handler.WeKnoraCloudHandler, g *rbacGuards) {
r.POST("/weknoracloud/credentials", g.Admin(), handler.SaveCredentials)
r.GET("/models/weknoracloud/status", g.Viewer(), handler.Status)
}
// RegisterWikiPageRoutes registers wiki page related routes
func RegisterWikiPageRoutes(r *gin.RouterGroup, wikiHandler *handler.WikiPageHandler) {
// RegisterWikiPageRoutes registers wiki page related routes.
//
// Wiki pages are KB content (wiki mode): reads are Viewer+, content
// mutations (create/update/delete) and maintenance actions
// (rebuild-links, auto-fix, change issue status) are Contributor+.
// Per-KB ownership granularity for individual pages is a follow-up,
// same as plain knowledge entries.
func RegisterWikiPageRoutes(r *gin.RouterGroup, wikiHandler *handler.WikiPageHandler, g *rbacGuards) {
wiki := r.Group("/knowledgebase/:kb_id/wiki")
{
// Page CRUD
wiki.GET("/pages", wikiHandler.ListPages)
wiki.POST("/pages", wikiHandler.CreatePage)
wiki.GET("/pages/*slug", wikiHandler.GetPage)
wiki.PUT("/pages/*slug", wikiHandler.UpdatePage)
wiki.DELETE("/pages/*slug", wikiHandler.DeletePage)
wiki.GET("/pages", g.Viewer(), wikiHandler.ListPages)
wiki.POST("/pages", g.Contributor(), wikiHandler.CreatePage)
wiki.GET("/pages/*slug", g.Viewer(), wikiHandler.GetPage)
wiki.PUT("/pages/*slug", g.Contributor(), wikiHandler.UpdatePage)
wiki.DELETE("/pages/*slug", g.Contributor(), wikiHandler.DeletePage)
// Special pages
wiki.GET("/index", wikiHandler.GetIndex)
wiki.GET("/log", wikiHandler.GetLog)
wiki.GET("/index", g.Viewer(), wikiHandler.GetIndex)
wiki.GET("/log", g.Viewer(), wikiHandler.GetLog)
// Graph and stats
wiki.GET("/graph", wikiHandler.GetGraph)
wiki.GET("/stats", wikiHandler.GetStats)
wiki.GET("/graph", g.Viewer(), wikiHandler.GetGraph)
wiki.GET("/stats", g.Viewer(), wikiHandler.GetStats)
// Search and maintenance
wiki.GET("/search", wikiHandler.SearchPages)
wiki.POST("/rebuild-links", wikiHandler.RebuildLinks)
wiki.GET("/lint", wikiHandler.Lint)
wiki.POST("/auto-fix", wikiHandler.AutoFix)
wiki.GET("/search", g.Viewer(), wikiHandler.SearchPages)
wiki.POST("/rebuild-links", g.Contributor(), wikiHandler.RebuildLinks)
wiki.GET("/lint", g.Viewer(), wikiHandler.Lint)
wiki.POST("/auto-fix", g.Contributor(), wikiHandler.AutoFix)
// Issues
wiki.GET("/issues", wikiHandler.ListIssues)
wiki.PUT("/issues/:issue_id/status", wikiHandler.UpdateIssueStatus)
wiki.GET("/issues", g.Viewer(), wikiHandler.ListIssues)
wiki.PUT("/issues/:issue_id/status", g.Contributor(), wikiHandler.UpdateIssueStatus)
}
}
+27
View File
@@ -54,6 +54,33 @@ func UserIDFromContext(ctx context.Context) (string, bool) {
return v, ok && v != ""
}
// IsSyntheticUserID reports whether id refers to the synthetic system
// user that the X-API-Key auth path attaches to each tenant
// (User.ID = "system-<tenantID>"). These users have no real human
// behind them and no tenant_members row, so RBAC ownership matching
// against them is never meaningful — service-layer code that records
// "the creator" should skip storing this ID and treat the resource as
// tenant-owned instead.
//
// Kept minimal on purpose: the prefix and "all digits afterwards"
// invariant comes from middleware/auth.go's User construction for the
// API-key branch. If that prefix changes, update both sides.
func IsSyntheticUserID(id string) bool {
const prefix = "system-"
if len(id) <= len(prefix) {
return false
}
if id[:len(prefix)] != prefix {
return false
}
for _, r := range id[len(prefix):] {
if r < '0' || r > '9' {
return false
}
}
return true
}
// TenantRoleFromContext extracts the caller's TenantRole in the currently
// active tenant. Returns TenantRoleViewer when the key is absent so that
// callers fail closed (least privilege) if the auth middleware did not
+29
View File
@@ -4,6 +4,35 @@ import (
"testing"
)
func TestIsSyntheticUserID(t *testing.T) {
cases := []struct {
name string
id string
want bool
}{
{"matches system-<digits>", "system-1", true},
{"matches large tenant id", "system-1234567890", true},
{"empty string", "", false},
{"prefix only", "system-", false},
{"missing prefix", "1", false},
{"non-digit suffix", "system-abc", false},
{"mixed suffix", "system-1a2", false},
{"prefix with space", "system- 1", false},
{"uppercase prefix", "SYSTEM-1", false},
{"normal uuid user", "550e8400-e29b-41d4-a716-446655440000", false},
{"system uuid trap", "system-550e8400", false}, // contains '-'
}
for _, c := range cases {
c := c
t.Run(c.name, func(t *testing.T) {
got := IsSyntheticUserID(c.id)
if got != c.want {
t.Fatalf("IsSyntheticUserID(%q) = %v, want %v", c.id, got, c.want)
}
})
}
}
func TestLanguageLocaleName(t *testing.T) {
tests := []struct {
name string
+9 -3
View File
@@ -76,9 +76,15 @@ type CustomAgent struct {
// Created by user ID
CreatedBy string `yaml:"created_by" json:"created_by" gorm:"type:varchar(36)"`
// RunnableByViewer controls whether users with TenantRoleViewer can
// start chat sessions against this agent. Defaults to true so viewers
// can still consume published agents; admins toggle it off for agents
// whose tools should be restricted to contributors and above.
// run this agent IN AGENT MODE (i.e. with tools, MCP, sandboxed code
// execution, etc.). Plain RAG / Wiki QA sessions against the same
// agent are unaffected — they don't invoke tools, so restricting
// them buys no security and would just block Viewer consumption of
// published agents. Defaults to true; admins toggle it off for
// agents whose tools should be restricted to contributors and above.
//
// Enforcement lives in handler/session/qa.go's AgentQA, gated behind
// cfg.Tenant.EnableRBAC like every other PR2 check.
//
// Note: no GORM `default:true` tag here. With a plain `bool` field that
// tag causes GORM to treat Go's zero value (false) as "unspecified" and