Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
feat(mcp): enforce the workspace capability ceiling on every MCP call (P1b 1b-2) (#21201)
Vincent Huang9fd83c148005
diff --git a/backend/api/auth/auth.go b/backend/api/auth/auth.goindex 765fa35742..ab291f5790 100644--- a/backend/api/auth/auth.go+++ b/backend/api/auth/auth.go@@ -489,10 +489,10 @@ func getAuthContext(fullMethod string) (*common.AuthContext, error) {if !ok {return nil, errs.Errorf("invalid MCP method class extension, full method name %q", fullMethod)}- mcpForbiddenReasonAny := proto.GetExtension(md, v1pb.E_McpForbiddenReason)- mcpForbiddenReason, ok := mcpForbiddenReasonAny.(v1pb.MCPForbiddenReason)+ mcpDenialReasonAny := proto.GetExtension(md, v1pb.E_McpDenialReason)+ mcpDenialReason, ok := mcpDenialReasonAny.(v1pb.MCPDenialReason)if !ok {- return nil, errs.Errorf("invalid MCP forbidden reason extension, full method name %q", fullMethod)+ return nil, errs.Errorf("invalid MCP denial reason extension, full method name %q", fullMethod)}return &common.AuthContext{@@ -501,10 +501,33 @@ func getAuthContext(fullMethod string) (*common.AuthContext, error) {AuthMethod: authMethod,Audit: audit,MCPMethodClass: mcpMethodClass,- MCPForbiddenReason: mcpForbiddenReason,+ MCPDenialReason: mcpDenialReason,}, nil}+// MCPClassIsRefused reports whether NO MCP capability ceiling serves methods of+// this class, so a session can never call one whatever the workspace is+// configured for. It exists here rather than beside the gate because two+// packages need the same answer for different reasons — the gate refuses on it,+// and the MCP OpenAPI index declines to advertise on it — and they must not+// disagree about which methods an agent is offered.+//+// It is a predicate rather than a copy of the serving table: the table lives in+// backend/api/v1 with the code that evaluates it, and+// TestLintRefusedClassesMatchTheServingTable holds this function against it, so+// adding a ceiling mode that serves a class cannot leave this stale.+//+// UNSPECIFIED counts as refused. The gate refuses an unclassified method, and+// CI rejects one, so advertising it would offer work that cannot be done.+func MCPClassIsRefused(class v1pb.MCPMethodClass) bool {+ switch class {+ case v1pb.MCPMethodClass_READ, v1pb.MCPMethodClass_WRITE:+ return false+ default:+ return true+ }+}+// MCPMethodClassOfProcedure resolves the MCP classification for a connect// procedure path such as "/bytebase.v1.AuthService/Login". Callers that only// decide what to ADVERTISE may treat an error as "not classified"; thediff --git a/backend/api/mcp/AGENTS.md b/backend/api/mcp/AGENTS.mdindex d639a217aa..f4d948762c 100644--- a/backend/api/mcp/AGENTS.md+++ b/backend/api/mcp/AGENTS.md@@ -11,8 +11,7 @@ Skills are markdown files in `skills/` that get embedded into the binary and ser```skills/├── query.md-├── database-change.md-└── grant-permission.md+└── database-change.md```### Skill Format@@ -103,5 +102,5 @@ const getSkillDescription = `Get step-by-step guides for Bytebase tasks.**Workflow:** get_skill("task") → search_api(operationId) → call_api(...)-Skills: query, database-change, grant-permission, NEW-SKILL`+Skills: query, database-change, NEW-SKILL````diff --git a/backend/api/mcp/gen/openapi.yaml b/backend/api/mcp/gen/openapi.yamlindex ab519cc857..ba006eb441 100644--- a/backend/api/mcp/gen/openapi.yaml+++ b/backend/api/mcp/gen/openapi.yaml@@ -14989,27 +14989,11 @@ components:Protocol) server's delegated credential. The values are copied verbatim fromthe verified credential's grant state; empty fields record that the grantstored nothing (legacy sessions), never a resolved or synthesized value.- bytebase.v1.MCPExclusionReason:+ bytebase.v1.MCPDenialReason:type: string- title: MCPExclusionReason+ title: MCPDenialReasonenum:- - MCP_EXCLUSION_REASON_UNSPECIFIED- - ADMINISTERS_THE_WORKSPACE- - READS_OTHER_USERS_SQL- - OPENS_AN_ADMIN_CONNECTION- - SENDS_DATA_TO_A_THIRD_PARTY- - RETURNS_A_STORED_SECRET- description: |-- Why an RPC is served by no MCP mode. Unlike MCPForbiddenReason, which names- a mechanism that breaks the MCP boundary, these name a scope decision: the- method is out because this phase ships two modes and neither is the right- home for it. Each value is what a future admin-capable ceiling would have to- argue with, one population at a time.- bytebase.v1.MCPForbiddenReason:- type: string- title: MCPForbiddenReason- enum:- - MCP_FORBIDDEN_REASON_UNSPECIFIED+ - MCP_DENIAL_REASON_UNSPECIFIED- MINTS_CREDENTIAL- RESETS_CREDENTIAL- TAKES_OVER_ACCOUNT@@ -15018,12 +15002,29 @@ components:- MINTS_CREDENTIAL_FOR_OTHERS- REWRITES_SESSION_BOUNDARY- DRIVES_THE_APPROVAL_DECISION+ - ADMINISTERS_THE_WORKSPACE+ - READS_OTHER_USERS_SQL+ - OPENS_AN_ADMIN_CONNECTION+ - SENDS_DATA_TO_A_THIRD_PARTY+ - RETURNS_A_STORED_SECRETdescription: |-- Why an RPC is FORBIDDEN to MCP sessions. The mechanism, not the wording:- each value names what its methods actually do, and the serving side turns- that into a sentence. A denial whose stated reason has drifted from the- mechanism is worse than a bare refusal, because it is the thing the next- reader trusts — so a method changing what it does changes its reason here.+ Why an MCP session may not call an RPC. The mechanism, not the wording: each+ value names what its methods actually do, and the serving side turns that+ into a sentence. A denial whose stated reason has drifted from the mechanism+ is worse than a bare refusal, because it is the thing the next reader trusts+ — so a method changing what it does changes its reason here.++ One enum covers both refused classes, and every value belongs to exactly one+ of them: values 1-8 name a mechanism that breaks the MCP boundary, which is+ what FORBIDDEN means, and values 9-13 name a scope decision this phase took,+ which is what EXCLUDED means. The distinction is real and lives on the class+ annotation — a FORBIDDEN mechanism is a durable never, an EXCLUDED scope+ decision is what a future admin-capable ceiling would argue with, one+ population at a time. Splitting it across two enums as well only made the+ nonsense states representable: a method could carry both, or carry the kind+ that contradicts its class. Neither is expressible now, and the one check+ left — the reason belongs to the class it is used on — is a table the gate+ already keeps for the wording.bytebase.v1.MCPMethodClass:type: stringtitle: MCPMethodClass@@ -15038,12 +15039,11 @@ components:authorization of an MCP session is this classification intersected with thecaller's own RBAC: it can only ever narrow what the human could do, neverwiden it.- Only FORBIDDEN is enforced today. READ, WRITE and EXCLUDED are recorded- classifications and nothing reads them at request time yet — the gate that- selects between them is a later change. A method annotated READ or WRITE is- therefore served exactly as it is today; the annotation states where it- belongs, not where the boundary currently sits. FORBIDDEN is the exception- and is enforced the moment it is annotated.+ Every value is enforced, at the gate on the internal MCP chain. READ and+ WRITE are the serving classes the workspace's MCP capability ceiling selects+ between, EXCLUDED and FORBIDDEN are served by no ceiling, and an unclassified+ method is refused rather than served. Annotating a method is therefore a+ change to what an MCP session can reach, taking effect on the next request.bytebase.v1.MaskingExemptionPolicy:type: objectproperties:diff --git a/backend/api/mcp/openapi_index.go b/backend/api/mcp/openapi_index.goindex 06cf119d1f..0f51e04547 100644--- a/backend/api/mcp/openapi_index.go+++ b/backend/api/mcp/openapi_index.go@@ -13,7 +13,6 @@ import (v3high "github.com/pb33f/libopenapi/datamodel/high/v3""github.com/bytebase/bytebase/backend/api/auth"- v1pb "github.com/bytebase/bytebase/backend/generated-go/v1")//go:embed gen/openapi.yaml@@ -73,9 +72,11 @@ type OpenAPIIndex struct {// endpoints holds every endpoint an MCP session may be offered. Discovery// walks this slice, so anything in it is advertisable by construction.endpoints []EndpointInfo- // hiddenEndpoints holds the FORBIDDEN ones: resolvable through byOperation- // so a direct call still gets the gate's actionable denial, but reachable- // by no discovery path.+ // hiddenEndpoints holds every endpoint no MCP capability ceiling serves —+ // FORBIDDEN and EXCLUDED alike — resolvable through byOperation so a+ // direct call still gets the gate's actionable denial, but reachable by no+ // discovery path. That is 121 of the 209 classified RPCs, and 13 services+ // whose every method is refused leave Services() entirely.hiddenEndpoints []EndpointInfobyOperation map[string]*EndpointInfobyService map[string][]*EndpointInfo@@ -178,7 +179,7 @@ func (idx *OpenAPIIndex) parseSpec() {// anyway (from memory, or from a skill written before the// classification) should meet the gate's actionable denial rather than// "unknown operation".- if forbiddenToMCP(path) {+ if refusedToMCP(path) {idx.hiddenEndpoints = append(idx.hiddenEndpoints, endpoint)idx.byOperation[endpoint.OperationID] = &idx.hiddenEndpoints[len(idx.hiddenEndpoints)-1]continue@@ -201,17 +202,22 @@ func (idx *OpenAPIIndex) parseSpec() {slices.Sort(idx.services)}-// forbiddenToMCP reports whether the RPC behind a connect path is annotated-// mcp_method_class = FORBIDDEN. A path whose descriptor cannot be resolved is-// treated as not forbidden: this decides only what to advertise, and hiding a-// legitimate endpoint because a lookup failed would be the worse failure —-// enforcement is the interceptor's job and reads the annotation itself.-func forbiddenToMCP(path string) bool {+// refusedToMCP reports whether the RPC behind a connect path is served by no+// MCP capability ceiling — FORBIDDEN and EXCLUDED alike, since the ceiling gate+// refuses both whatever the workspace is set to. It keys on that predicate+// rather than on one class, so a class the ceiling stops serving stops being+// advertised in the same change.+//+// A path whose descriptor cannot be resolved is treated as not refused: this+// decides only what to advertise, and hiding a legitimate endpoint because a+// lookup failed would be the worse failure — enforcement is the interceptor's+// job and reads the annotation itself.+func refusedToMCP(path string) bool {class, err := auth.MCPMethodClassOfProcedure(path)if err != nil {return false}- return class == v1pb.MCPMethodClass_FORBIDDEN+ return auth.MCPClassIsRefused(class)}func extractPermissions(description string) []string {diff --git a/backend/api/mcp/openapi_index_forbidden_test.go b/backend/api/mcp/openapi_index_forbidden_test.godeleted file mode 100644index 55e343dad1..0000000000--- a/backend/api/mcp/openapi_index_forbidden_test.go+++ /dev/null@@ -1,50 +0,0 @@-package mcp--import (- "testing"-- "github.com/stretchr/testify/require"-)--// TestForbiddenEndpointsAreNotAdvertised pins the two halves of how the index-// treats a FORBIDDEN RPC: invisible to every discovery path an agent has, and-// still resolvable by operation ID so a call that arrives anyway meets the-// gate's actionable denial rather than "unknown operation, use search_api".-func TestForbiddenEndpointsAreNotAdvertised(t *testing.T) {- idx, err := NewOpenAPIIndex()- require.NoError(t, err)-- const forbidden = "bytebase.v1.AuthService.Login"- const forbiddenPath = "/bytebase.v1.AuthService/Login"- require.True(t, forbiddenToMCP(forbiddenPath), "precondition: Login is annotated FORBIDDEN")-- t.Run("still resolvable by operation ID", func(t *testing.T) {- ep, ok := idx.GetEndpoint(forbidden)- require.True(t, ok, "call_api must still resolve it, so the denial can explain itself")- require.Equal(t, forbiddenPath, ep.Path)- })-- t.Run("only callable auth endpoints are listed", func(t *testing.T) {- require.Contains(t, idx.Services(), "AuthService",- "AuthService has a non-FORBIDDEN authentication restriction endpoint")- endpoints := idx.GetServiceEndpoints("AuthService")- require.Len(t, endpoints, 1)- require.Equal(t, "bytebase.v1.AuthService.GetAuthenticationRestriction", endpoints[0].OperationID)- })-- t.Run("absent from search", func(t *testing.T) {- for _, query := range []string{"login", "password", "workspace"} {- for _, hit := range idx.Search(query) {- require.False(t, forbiddenToMCP(hit.Path),- "search %q offered %s, which an MCP session can never call", query, hit.Path)- }- }- })-- t.Run("reachable endpoints are unaffected", func(t *testing.T) {- _, ok := idx.GetEndpoint("bytebase.v1.ProjectService.ListProjects")- require.True(t, ok)- require.Contains(t, idx.Services(), "ProjectService")- require.NotEmpty(t, idx.Search("project"))- })-}diff --git a/backend/api/mcp/openapi_index_refused_test.go b/backend/api/mcp/openapi_index_refused_test.gonew file mode 100644index 0000000000..a04d1ae7fe--- /dev/null+++ b/backend/api/mcp/openapi_index_refused_test.go@@ -0,0 +1,70 @@+package mcp++import (+ "testing"++ "github.com/stretchr/testify/require"+)++// TestRefusedEndpointsAreNotAdvertised pins the two halves of how the index+// treats an RPC no MCP ceiling serves: invisible to every discovery path an+// agent has, and still resolvable by operation ID so a call that arrives anyway+// meets the gate's actionable denial rather than "unknown operation, use+// search_api".+//+// The predicate is "refused under every ceiling", not "FORBIDDEN". Both refused+// classes are covered because the gate refuses both, and an agent offered work+// that always comes back 403 burns turns on it and writes a policy-denial audit+// row each time — which dilutes the very signal those rows exist to carry.+func TestRefusedEndpointsAreNotAdvertised(t *testing.T) {+ idx, err := NewOpenAPIIndex()+ require.NoError(t, err)++ const forbidden = "bytebase.v1.AuthService.Login"+ const forbiddenPath = "/bytebase.v1.AuthService/Login"+ require.True(t, refusedToMCP(forbiddenPath), "precondition: Login is annotated FORBIDDEN")++ const excluded = "bytebase.v1.UserService.ListUsers"+ const excludedPath = "/bytebase.v1.UserService/ListUsers"+ require.True(t, refusedToMCP(excludedPath), "precondition: ListUsers is annotated EXCLUDED")++ t.Run("still resolvable by operation ID", func(t *testing.T) {+ for operation, path := range map[string]string{forbidden: forbiddenPath, excluded: excludedPath} {+ ep, ok := idx.GetEndpoint(operation)+ require.True(t, ok, "call_api must still resolve %s, so the denial can explain itself", operation)+ require.Equal(t, path, ep.Path)+ }+ })++ t.Run("only callable auth endpoints are listed", func(t *testing.T) {+ require.Contains(t, idx.Services(), "AuthService",+ "AuthService has a served authentication restriction endpoint")+ endpoints := idx.GetServiceEndpoints("AuthService")+ require.Len(t, endpoints, 1)+ require.Equal(t, "bytebase.v1.AuthService.GetAuthenticationRestriction", endpoints[0].OperationID)+ })++ t.Run("a service whose every method is refused is not listed at all", func(t *testing.T) {+ // Every ProjectService read returns the incoming-webhook URL verbatim+ // and every write administers the workspace, so the whole service is+ // EXCLUDED. Nothing about it is offered.+ require.NotContains(t, idx.Services(), "ProjectService")+ require.Empty(t, idx.GetServiceEndpoints("ProjectService"))+ })++ t.Run("absent from search", func(t *testing.T) {+ for _, query := range []string{"login", "password", "workspace", "project", "user", "instance"} {+ for _, hit := range idx.Search(query) {+ require.False(t, refusedToMCP(hit.Path),+ "search %q offered %s, which an MCP session can never call", query, hit.Path)+ }+ }+ })++ t.Run("served endpoints are unaffected", func(t *testing.T) {+ _, ok := idx.GetEndpoint("bytebase.v1.DatabaseService.ListDatabases")+ require.True(t, ok)+ require.Contains(t, idx.Services(), "DatabaseService")+ require.NotEmpty(t, idx.Search("database"))+ })+}diff --git a/backend/api/mcp/server.go b/backend/api/mcp/server.goindex 5cc906a027..a3dba6e19b 100644--- a/backend/api/mcp/server.go+++ b/backend/api/mcp/server.go@@ -51,12 +51,19 @@ type Server struct {type serverStore interface {GetWorkspaceID(context.Context) (string, error)GetWorkspaceProfileSetting(context.Context, string) (*storepb.WorkspaceProfileSetting, error)- GetSettingUncached(context.Context, string, storepb.SettingName) (*store.SettingMessage, error)+ GetMCPCapabilityUncached(context.Context, string) (storepb.WorkspaceProfileSetting_MCPCapability, error)DeleteOAuth2RefreshTokensByUserAndClient(context.Context, string, string) error}// NewServer creates a new MCP server. internalAPI is the internal API handler// chain tool calls dispatch to in memory; it is never bound to a listener.+// It takes the concrete store; tests reach newServerWithStore with a fake.+//+// The nil check is not redundant with the typed parameter. A nil *store.Store+// assigned to the serverStore interface field produces a NON-nil interface+// holding a nil pointer, which no later nil test catches, so without this the+// failure moves from a returned error here to a nil-receiver panic on the first+// ceiling read inside authMiddleware.func NewServer(stores *store.Store, profile *config.Profile, secret string, internalAPI http.Handler) (*Server, error) {if stores == nil {return nil, errors.New("store is required")@@ -199,11 +206,23 @@ func (s *Server) authMiddleware(next echo.HandlerFunc) echo.HandlerFunc {}// Enforce the workspace MCP capability ceiling before dispatching to any- // tool. DISABLED — and, until per-tool enforcement lands in a later- // phase, the not-yet-enforceable READ_ONLY ceiling — reject the- // connection outright. Read live so an admin change takes effect on the- // next request without re-issuing tokens.- if !mcpConnectionAllowed(s.mcpCapability(c.Request().Context(), workspaceID)) {+ // tool. DISABLED rejects the connection outright, and so does READ_ONLY:+ // the per-method gate on the internal chain now serves a read-only+ // ceiling correctly, but the query tool still reaches SQLService/Query,+ // which authorizes writes per statement. Admitting a read-only session+ // before that clamp exists would be a read-only session that can write.+ // Read live so an admin change takes effect on the next request without+ // re-issuing tokens.+ capability, err := s.mcpCapability(c.Request().Context(), workspaceID)+ if err != nil {+ // Infra failure reading the policy, not a verdict on the+ // workspace: a 403 here would tell the operator their admin+ // disabled MCP. 503 says retry, and the session still does not+ // proceed.+ slog.Error("failed to read the MCP capability ceiling; cannot admit the session", log.BBError(err))+ return echo.NewHTTPError(http.StatusServiceUnavailable, "cannot read the MCP policy; retry shortly")+ }+ if !mcpConnectionAllowed(capability) {return echo.NewHTTPError(http.StatusForbidden, "MCP access is disabled for this workspace by policy")}@@ -571,51 +590,63 @@ func (s *Server) unauthorized(c *echo.Context, errDescription string) error {}// mcpConnectionAllowed reports whether an MCP connection may proceed under the-// resolved workspace capability ceiling. This phase enforces the connection-level-// gate only: DISABLED is rejected, and the not-yet-enforceable-// READ_ONLY ceiling is also rejected — a ceiling the server cannot yet-// apply per-tool must fail closed rather than silently grant read-write. A-// later phase turns it into allow-with-clamp. Unknown stored values (e.g. a+// resolved workspace capability ceiling. DISABLED is rejected, and so is+// READ_ONLY: per-method enforcement exists from P1b 1b-2, but the SQL statement+// clamp does not, so a read-only session admitted here could still write+// through the query tool. 1b-3 lands the clamp and flips this to+// allow-with-clamp; nothing before it may. Unknown stored values (e.g. the// reserved number) hit the default arm and fail closed too.+//+// UNSPECIFIED is refused rather than treated as "never configured", even though+// that is what an unset ceiling means in the stored proto. The resolution+// happens before this point — store.GetMCPCapabilityUncached returns READ_WRITE+// for a workspace that never set one — so UNSPECIFIED reaching here is a zero+// value nobody resolved, and a gate that admits on a zero value is one+// mistake away from admitting on a failure.func mcpConnectionAllowed(capability storepb.WorkspaceProfileSetting_MCPCapability) bool {switch capability {- case storepb.WorkspaceProfileSetting_MCP_CAPABILITY_UNSPECIFIED,- storepb.WorkspaceProfileSetting_READ_WRITE:+ case storepb.WorkspaceProfileSetting_READ_WRITE:return truedefault:return false}}-// mcpCapability resolves the workspace's effective MCP capability ceiling. An-// unset ceiling resolves to READ_WRITE so workspaces that never configured-// one keep working; a genuine lookup error fails closed to DISABLED so a-// policy that cannot be read never silently permits MCP. A missing setting row-// is treated as unset, not an error.+// mcpCapability resolves the workspace's effective MCP capability ceiling for+// the connection gate. A stored value this build cannot interpret — a mistyped+// enum name, a wrong-typed row — resolves to DISABLED, so the connection is+// refused and the operator is told the policy is the problem, which is true:+// no retry fixes it, an admin has to. A read that FAILED returns an error+// instead, because "your workspace disabled MCP" is a lie during a database+// blip; the caller answers 503 and the client retries, exactly as it already+// does when the token audience cannot be resolved.+//+// Either way the session does not proceed. The request gate on the internal+// chain makes the same split on the same two errors — the connection and the+// per-method gate must never disagree about a workspace's ceiling, nor about+// which kind of failure the operator is looking at.//-// The read deliberately bypasses the store's setting cache: the cache has no-// TTL and only in-process writes refresh it, so a profile cached as unset-// would keep admitting MCP indefinitely after the ceiling is flipped by an-// out-of-band admin path (direct SQL, another process). A kill switch must-// observe the stored truth on the next request.-func (s *Server) mcpCapability(ctx context.Context, workspaceID string) storepb.WorkspaceProfileSetting_MCPCapability {- setting, err := s.store.GetSettingUncached(ctx, workspaceID, storepb.SettingName_WORKSPACE_PROFILE)+// The resolution itself lives in the store, uncached. Bypassing the setting+// cache is what makes the kill switch a kill switch: the cache has no TTL and+// only in-process writes refresh it, so a profile cached as unset would keep+// admitting MCP after the ceiling was flipped out of band.+func (s *Server) mcpCapability(ctx context.Context, workspaceID string) (storepb.WorkspaceProfileSetting_MCPCapability, error) {+ capability, err := s.store.GetMCPCapabilityUncached(ctx, workspaceID)if err != nil {- slog.Warn("failed to read MCP capability policy; failing closed",- slog.String("workspace", workspaceID), log.BBError(err))- return storepb.WorkspaceProfileSetting_DISABLED- }- if setting == nil {- return storepb.WorkspaceProfileSetting_READ_WRITE- }- profile, ok := setting.Value.(*storepb.WorkspaceProfileSetting)- if !ok {- return storepb.WorkspaceProfileSetting_READ_WRITE- }- if capability := profile.GetMcpCapability(); capability != storepb.WorkspaceProfileSetting_MCP_CAPABILITY_UNSPECIFIED {- return capability+ if errors.Is(err, store.ErrMCPCapabilityUnreadable) {+ slog.Warn("the stored MCP capability ceiling cannot be interpreted; refusing the connection",+ slog.String("workspace", workspaceID), log.BBError(err))+ return storepb.WorkspaceProfileSetting_DISABLED, nil+ }+ // DISABLED rather than UNSPECIFIED, even though the error is what the+ // caller acts on. UNSPECIFIED is the zero value and means "nobody+ // resolved this"; DISABLED is a decision. mcpConnectionAllowed refuses+ // both, so nothing turns on it today — the point is that the value+ // stays safe to read on its own, in case a later caller logs the error+ // and carries on.+ return storepb.WorkspaceProfileSetting_DISABLED, err}- return storepb.WorkspaceProfileSetting_READ_WRITE+ return capability, nil}// buildResourceMetadataURL returns the absolute URL of the protected resourcediff --git a/backend/api/mcp/server_killswitch_test.go b/backend/api/mcp/server_killswitch_test.goindex 18dd1b893d..70437f976f 100644--- a/backend/api/mcp/server_killswitch_test.go+++ b/backend/api/mcp/server_killswitch_test.go@@ -24,17 +24,21 @@ import (_ "github.com/bytebase/bytebase/backend/plugin/db/pg")-// TestMCPConnectionAllowed pins the connection-level gate: only an unset ceiling-// and READ_WRITE admit a connection in this phase. DISABLED, the-// not-yet-enforceable READ_ONLY ceiling, and unknown stored values (such as-// the reserved number 2) all fail closed so a ceiling the server cannot apply-// per-tool never silently grants read-write.+// TestMCPConnectionAllowed pins the connection-level gate: only READ_WRITE+// admits a connection in this phase. DISABLED, the not-yet-enforceable+// READ_ONLY ceiling, unknown stored values (such as the reserved number 2), and+// the zero value all fail closed, so a ceiling the server cannot apply per-tool+// never silently grants read-write.+//+// UNSPECIFIED is refused here even though an unset stored ceiling means+// READ_WRITE: the store resolves that before this point, so a zero value+// arriving here was resolved by nobody.func TestMCPConnectionAllowed(t *testing.T) {tests := []struct {capability storepb.WorkspaceProfileSetting_MCPCapabilityallowed bool}{- {storepb.WorkspaceProfileSetting_MCP_CAPABILITY_UNSPECIFIED, true},+ {storepb.WorkspaceProfileSetting_MCP_CAPABILITY_UNSPECIFIED, false},{storepb.WorkspaceProfileSetting_READ_WRITE, true},{storepb.WorkspaceProfileSetting_DISABLED, false},{storepb.WorkspaceProfileSetting_MCPCapability(2), false}, // reserved (was METADATA_ONLY)@@ -193,3 +197,120 @@ func tokenForWorkspace(t *testing.T, secret, workspaceID string) string {require.NoError(t, err)return tokenStr}++// TestMCPCeilingStoredValueFailsClosed drives the /mcp connection gate against+// the ceiling values a workspace row can actually hold, including the ones no+// Bytebase write produces.+//+// The typo row is the one that mattered: protojson discards a field whose enum+// NAME it does not recognize, so `{"mcpCapability":"READ_WRTIE"}` used to parse+// as unset and resolve to READ_WRITE — a mistyped kill switch that silently did+// nothing. An unknown enum NUMBER never had that problem, because protojson+// keeps it and no mode serves it.+//+// The read-only row is the cutover pin. READ_ONLY is enforceable per method+// from this PR, but a read-only session can still write SQL through the query+// tool until 1b-3 clamps statements, so the connection stays refused. If this+// row ever returns 200 without the clamp shipping, the cutover moved early.+func TestMCPCeilingStoredValueFailsClosed(t *testing.T) {+ ctx := context.Background()+ container := testcontainer.GetTestPgContainer(ctx, t)+ t.Cleanup(func() { container.Close(ctx) })++ db := container.GetDB()+ require.NoError(t, migrator.MigrateSchema(ctx, db))++ rows := []struct {+ workspace string+ value string+ want int+ why string+ }{+ {"ws-typo", `{"mcpCapability":"READ_WRTIE"}`, http.StatusForbidden,+ "a ceiling this build cannot read is not a ceiling that permits"},+ {"ws-reserved", `{"mcpCapability":2}`, http.StatusForbidden,+ "the reserved number was METADATA_ONLY; no mode serves it"},+ {"ws-explicit-unset", `{"mcpCapability":"MCP_CAPABILITY_UNSPECIFIED"}`, http.StatusForbidden,+ "no Bytebase write produces this key with this value, so a row that has it was hand-edited"},+ {"ws-readonly", `{"mcpCapability":"READ_ONLY"}`, http.StatusForbidden,+ "READ_ONLY does not admit a connection until the SQL clamp lands (1b-3)"},+ {"ws-other-unknown-field", `{"someFieldFromANewerRelease":"x"}`, http.StatusOK,+ "one unknown field must not disable MCP: only the ceiling key is read strictly"},+ {"ws-open", `{}`, http.StatusOK,+ "a workspace that never set a ceiling keeps working"},+ }++ for _, row := range rows {+ _, err := db.ExecContext(ctx, `INSERT INTO workspace (resource_id) VALUES ($1)`, row.workspace)+ require.NoError(t, err)+ _, err = db.ExecContext(ctx,+ `INSERT INTO setting (name, workspace, value) VALUES ('WORKSPACE_PROFILE', $1, $2)`,+ row.workspace, row.value)+ require.NoError(t, err)+ }++ pgURL := fmt.Sprintf(+ "host=%s port=%s user=postgres password=root-password database=postgres",+ container.GetHost(), container.GetPort(),+ )+ s, err := store.New(ctx, pgURL, false)+ require.NoError(t, err)++ secret := "test-secret-key"+ profile := &config.Profile{Mode: common.ReleaseModeDev, ExternalURL: "https://bb.example.com"}+ srv, err := NewServer(s, profile, secret, nil)+ require.NoError(t, err)++ // The connection verdict alone cannot separate "the ceiling parsed as+ // READ_ONLY" from "the ceiling could not be read", because mcpCapability+ // maps any error to DISABLED and both refuse. So the resolver is asserted+ // directly, on every workspace at once.+ //+ // That doubles as the composite-primary-key check the setting table needs.+ // It is keyed (workspace, name), and GetMCPCapabilityUncached is a new+ // reader of it: a future edit that dropped the workspace predicate would+ // return whichever row the scan reached first and apply one tenant's MCP+ // ceiling to every other tenant — a kill switch answering for the wrong+ // workspace. Six workspaces with six different stored values sit in this+ // one database, so each must still resolve to its own; the ws-readonly row+ // is additionally the value 1b-3's cutover will flip against, and it must+ // resolve as itself rather than as a fail-closed error.+ for workspace, want := range map[string]storepb.WorkspaceProfileSetting_MCPCapability{+ "ws-readonly": storepb.WorkspaceProfileSetting_READ_ONLY,+ "ws-open": storepb.WorkspaceProfileSetting_READ_WRITE,+ "ws-other-unknown-field": storepb.WorkspaceProfileSetting_READ_WRITE,+ } {+ got, err := s.GetMCPCapabilityUncached(ctx, workspace)+ require.NoError(t, err, "%s stores a ceiling this build understands", workspace)+ require.Equal(t, want, got,+ "%s must resolve its OWN stored ceiling, not a neighbour's", workspace)+ }+ for _, workspace := range []string{"ws-typo", "ws-reserved", "ws-explicit-unset"} {+ got, err := s.GetMCPCapabilityUncached(ctx, workspace)+ if err == nil {+ // The reserved number parses; it is refused later because no+ // ceiling serves it. What must never happen is resolving to a+ // value some other workspace stored.+ require.NotEqual(t, storepb.WorkspaceProfileSetting_READ_WRITE, got,+ "%s must not resolve to a neighbour's permissive ceiling", workspace)+ }+ }++ for _, row := range rows {+ t.Run(row.workspace, func(t *testing.T) {+ e := echo.New()+ req := httptest.NewRequest(http.MethodPost, "/mcp", strings.NewReader(`{}`))+ req.Header.Set("Content-Type", "application/json")+ req.Header.Set("Authorization", "Bearer "+tokenForWorkspace(t, secret, row.workspace))+ rec := httptest.NewRecorder()+ c := e.NewContext(req, rec)+ handler := srv.authMiddleware(func(c *echo.Context) error {+ return c.String(http.StatusOK, "success")+ })+ if err := handler(c); err != nil {+ echo.DefaultHTTPErrorHandler(true)(c, err)+ }+ require.Equal(t, row.want, rec.Code, row.why)+ })+ }+}diff --git a/backend/api/mcp/server_test.go b/backend/api/mcp/server_test.goindex c7267c87a8..f646641882 100644--- a/backend/api/mcp/server_test.go+++ b/backend/api/mcp/server_test.go@@ -17,6 +17,7 @@ import ("github.com/bytebase/bytebase/backend/api/auth""github.com/bytebase/bytebase/backend/common""github.com/bytebase/bytebase/backend/component/config"+ "github.com/bytebase/bytebase/backend/store")func TestMCPAuthMiddleware(t *testing.T) {@@ -122,11 +123,58 @@ func TestMCPAuthMiddleware(t *testing.T) {}}+// TestNewServerRequiresStore keeps the constructor's nil check honest. A nil+// *store.Store assigned to the serverStore interface produces a NON-nil+// interface holding a nil pointer, so no later nil test catches it and the+// failure would surface as a nil-receiver panic on the first ceiling read+// inside authMiddleware.func TestNewServerRequiresStore(t *testing.T) {_, err := NewServer(nil, &config.Profile{}, "test-secret", nil)require.Error(t, err)}+// TestMCPCeilingFailuresRefuseTheConnectionDifferently pins the split the+// connection gate makes on the two ways a ceiling can be unusable. Both refuse.+// They must not describe themselves as each other: telling an operator their+// admin disabled MCP during a database blip sends them to the wrong place, and+// telling a client to retry a mistyped stored value promises something no+// retry delivers.+//+// The stored-value cases are covered against a real database in+// TestMCPCeilingStoredValueFailsClosed; this covers the arm above them.+func TestMCPCeilingFailuresRefuseTheConnectionDifferently(t *testing.T) {+ secret := "test-secret-key"+ profile := &config.Profile{Mode: common.ReleaseModeDev, ExternalURL: "https://bb.example.com"}++ statusFor := func(t *testing.T, capabilityErr error) int {+ t.Helper()+ fake := newTestServerStore()+ fake.capabilityErr = capabilityErr+ s, err := newServerWithStore(fake, profile, secret, nil)+ require.NoError(t, err)++ e := echo.New()+ req := httptest.NewRequest(http.MethodPost, "/mcp", strings.NewReader(`{}`))+ req.Header.Set("Content-Type", "application/json")+ req.Header.Set("Authorization", "Bearer "+tokenForWorkspace(t, secret, fake.workspaceID))+ rec := httptest.NewRecorder()+ c := e.NewContext(req, rec)+ handler := s.authMiddleware(func(c *echo.Context) error {+ return c.String(http.StatusOK, "success")+ })+ if err := handler(c); err != nil {+ echo.DefaultHTTPErrorHandler(true)(c, err)+ }+ return rec.Code+ }++ require.Equal(t, http.StatusServiceUnavailable, statusFor(t, errors.New("db unreachable")),+ "a failed read is an outage; the session is still refused, and the client may retry")+ require.Equal(t, http.StatusForbidden,+ statusFor(t, errors.Wrap(store.ErrMCPCapabilityUnreadable, "READ_WRTIE")),+ "a stored value this build cannot interpret is a policy an admin must fix, not something to retry")+}+func TestMCPAuthFailsExplicitlyWithoutExternalURL(t *testing.T) {s := &Server{store: newTestServerStore(),diff --git a/backend/api/mcp/skills/grant-permission.md b/backend/api/mcp/skills/grant-permission.mddeleted file mode 100644index 7a8c0dec63..0000000000--- a/backend/api/mcp/skills/grant-permission.md+++ /dev/null@@ -1,174 +0,0 @@-----name: grant-permission-description: Use when granting roles, managing access control, adding users to projects, or setting up RBAC permissions------# Grant Permission--## Overview--Grant roles to users or groups using Bytebase's RBAC system. Permissions can be set at workspace level (global) or project level (scoped).--## Prerequisites--- Have `bb.workspaces.setIamPolicy` for workspace-level grants-- Have `bb.projects.setIamPolicy` for project-level grants--## Permission Levels--| Level | Scope | Use Case |-|-------|-------|----------|-| **Workspace** | All projects | Admins, DBAs, global viewers |-| **Project** | Single project | Developers, project owners |--## Workflow--### Step 1: List Available Roles--```-search_api(operationId="RoleService/ListRoles")-```-```-call_api(operationId="RoleService/ListRoles", body={})-```--**Built-in roles:**--| Role | Description |-|------|-------------|-| `roles/workspaceAdmin` | Full workspace access |-| `roles/workspaceDBA` | Database administration |-| `roles/workspaceMember` | Basic workspace access |-| `roles/projectOwner` | Full project access |-| `roles/projectDeveloper` | Development access (create issues, plans) |-| `roles/projectReleaser` | Execute rollouts |-| `roles/sqlEditorUser` | SQL Editor access only |-| `roles/projectViewer` | Read-only access |-| `roles/gitopsServiceAgent` | GitOps automation |--### Step 2: Get Current IAM Policy--Always fetch current policy first to avoid overwriting existing bindings.--**Workspace level:**-```-search_api(operationId="WorkspaceService/GetIamPolicy")-```-```-call_api(operationId="WorkspaceService/GetIamPolicy", body={- "resource": "workspaces/{id}"-})-```--**Project level:**-```-search_api(operationId="ProjectService/GetIamPolicy")-```-```-call_api(operationId="ProjectService/GetIamPolicy", body={- "resource": "projects/{project-id}"-})-```--Save the returned `etag` for the update.--### Step 3: Set IAM Policy--Add new bindings while preserving existing ones.--**Workspace level:**-```-search_api(operationId="WorkspaceService/SetIamPolicy")-```-```-call_api(operationId="WorkspaceService/SetIamPolicy", body={- "resource": "workspaces/{id}",- "etag": "{etag-from-get}",- "policy": {- "bindings": [- {- "role": "roles/workspaceDBA",- "members": ["user:[email protected]"]- },- {- "role": "roles/workspaceMember",- "members": [- "user:[email protected]",- "user:[email protected]",- "group:[email protected]"- ]- }- ]- }-})-```--**Project level:**-```-call_api(operationId="ProjectService/SetIamPolicy", body={- "resource": "projects/{project-id}",- "etag": "{etag-from-get}",- "policy": {- "bindings": [- {- "role": "roles/projectOwner",- "members": ["user:[email protected]"]- },- {- "role": "roles/projectDeveloper",- "members": ["group:[email protected]"]- }- ]- }-})-```--## Member Format--| Type | Format | Example |-|------|--------|---------|-| User | `user:{email}` | `user:[email protected]` |-| Group | `group:{email}` | `group:[email protected]` |-| All users | `allUsers` | `allUsers` |--## Time-Limited Access (CEL Expressions)--Grant temporary access using CEL conditions.--```-call_api(operationId="ProjectService/SetIamPolicy", body={- "resource": "projects/{project-id}",- "etag": "{etag}",- "policy": {- "bindings": [{- "role": "roles/projectDeveloper",- "members": ["user:[email protected]"],- "condition": {- "expression": "request.time < timestamp('2024-12-31T23:59:59Z')",- "title": "Temporary access",- "description": "Access expires end of 2024"- }- }]- }-})-```--**CEL variables for sqlEditorUser:**-- `resource.database`: Database name (`instances/{id}/databases/{name}`)-- `resource.schema_name`: Schema name-- `resource.table_name`: Table name-- `request.time`: For expiration--**CEL examples:**-- Expire at date: `request.time < timestamp('2024-12-31T23:59:59Z')`-- Limit to database: `resource.database == "instances/prod/databases/main"`--## Common Errors--| Error | Cause | Fix |-|-------|-------|-----|-| etag mismatch | Policy changed | Re-fetch policy and retry |-| role not found | Invalid role name | List roles first, use `roles/{name}` format |-| invalid member | Wrong format | Use `user:email` or `group:email` format |-| permission denied | Missing setIamPolicy | Check workspace/project admin access |-| invalid CEL | Bad expression syntax | Validate CEL expression format |diff --git a/backend/api/mcp/store_test.go b/backend/api/mcp/store_test.goindex e482f35534..a35fab98b8 100644--- a/backend/api/mcp/store_test.go+++ b/backend/api/mcp/store_test.go@@ -4,19 +4,20 @@ import ("context"storepb "github.com/bytebase/bytebase/backend/generated-go/store"- "github.com/bytebase/bytebase/backend/store")type testServerStore struct {workspaceID stringworkspaceProfile *storepb.WorkspaceProfileSetting- setting *store.SettingMessage+ capability storepb.WorkspaceProfileSetting_MCPCapability+ capabilityErr error}func newTestServerStore() *testServerStore {return &testServerStore{workspaceID: "ws-test",workspaceProfile: &storepb.WorkspaceProfileSetting{},+ capability: storepb.WorkspaceProfileSetting_READ_WRITE,}}@@ -28,8 +29,8 @@ func (s *testServerStore) GetWorkspaceProfileSetting(context.Context, string) (*return s.workspaceProfile, nil}-func (s *testServerStore) GetSettingUncached(context.Context, string, storepb.SettingName) (*store.SettingMessage, error) {- return s.setting, nil+func (s *testServerStore) GetMCPCapabilityUncached(context.Context, string) (storepb.WorkspaceProfileSetting_MCPCapability, error) {+ return s.capability, s.capabilityErr}func (*testServerStore) DeleteOAuth2RefreshTokensByUserAndClient(context.Context, string, string) error {diff --git a/backend/api/mcp/tool_search_test.go b/backend/api/mcp/tool_search_test.goindex 2b2c70a838..999c9dea0c 100644--- a/backend/api/mcp/tool_search_test.go+++ b/backend/api/mcp/tool_search_test.go@@ -27,7 +27,11 @@ func TestSearchAPIListServices(t *testing.T) {require.Contains(t, text, "Available Services")require.Contains(t, text, "SQLService")require.Contains(t, text, "DatabaseService")- require.Contains(t, text, "ProjectService")+ // A service the MCP ceiling serves nothing of is not on the menu.+ // ProjectService is the clearest case: its reads return the+ // incoming-webhook URL verbatim and its writes administer the workspace,+ // so every one of its methods is refused.+ require.NotContains(t, text, "ProjectService")}func TestSearchAPIByService(t *testing.T) {diff --git a/backend/api/mcp/tool_skill.go b/backend/api/mcp/tool_skill.goindex dbf73a78f8..ccd58a34d8 100644--- a/backend/api/mcp/tool_skill.go+++ b/backend/api/mcp/tool_skill.go@@ -34,7 +34,7 @@ const getSkillDescription = `Get step-by-step guides for Bytebase tasks.**Workflow:** get_skill("task") → search_api(operationId) → call_api(...)-Skills: query, database-change, grant-permission`+Skills: query, database-change`func (s *Server) registerSkillTool() {mcp.AddTool(s.mcpServer, &mcp.Tool{diff --git a/backend/api/mcp/tool_skill_test.go b/backend/api/mcp/tool_skill_test.goindex cfadb27fe9..7522e6034a 100644--- a/backend/api/mcp/tool_skill_test.go+++ b/backend/api/mcp/tool_skill_test.go@@ -2,11 +2,13 @@ package mcpimport ("context"+ "regexp""testing"mcpsdk "github.com/modelcontextprotocol/go-sdk/mcp""github.com/stretchr/testify/require"+ "github.com/bytebase/bytebase/backend/api/auth""github.com/bytebase/bytebase/backend/common""github.com/bytebase/bytebase/backend/component/config")@@ -70,7 +72,7 @@ func TestGetSkillAllSkillsLoadable(t *testing.T) {s, err := newServerWithStore(newTestServerStore(), profile, "test-secret", nil)require.NoError(t, err)- skills := []string{"query", "database-change", "grant-permission"}+ skills := []string{"query", "database-change"}for _, skill := range skills {t.Run(skill, func(t *testing.T) {result, _, err := s.handleGetSkill(context.Background(), nil, SkillInput{@@ -86,3 +88,47 @@ func TestGetSkillAllSkillsLoadable(t *testing.T) {})}}++// TestSkillsOnlyInstructServableCalls is the rule that keeps a shipped skill+// honest: every operation a skill tells the agent to call must be one the MCP+// ceiling gate serves. It states the rule rather than fixing an instance of it,+// because the failure mode is silent — a classification change lands in a proto+// file, the skill keeps shipping, and the agent follows a playbook whose every+// step comes back 403.+//+// That is exactly what happened to the grant-permission skill: 1b-1 classified+// the five IAM operations it drove as EXCLUDED, 1b-2 turned EXCLUDED into a+// denial, and nothing connected the two. The skill is gone; this is what stops+// the next one going the same way.+//+// It resolves through the same index call_api uses, so an operation ID that no+// longer resolves fails here too.+func TestSkillsOnlyInstructServableCalls(t *testing.T) {+ idx, err := NewOpenAPIIndex()+ require.NoError(t, err)++ entries, err := skillFiles.ReadDir("skills")+ require.NoError(t, err)+ require.NotEmpty(t, entries, "the embedded skills directory must not be empty")++ operationID := regexp.MustCompile(`operationId="([^"]+)"`)+ for _, entry := range entries {+ t.Run(entry.Name(), func(t *testing.T) {+ content, err := skillFiles.ReadFile("skills/" + entry.Name())+ require.NoError(t, err)++ matches := operationID.FindAllStringSubmatch(string(content), -1)+ require.NotEmpty(t, matches, "a skill that instructs no call is not a skill")+ for _, match := range matches {+ operation := match[1]+ endpoint, ok := idx.GetEndpoint(operation)+ require.True(t, ok, "%s instructs operation %q, which call_api cannot resolve", entry.Name(), operation)+ class, err := auth.MCPMethodClassOfProcedure(endpoint.Path)+ require.NoError(t, err, "%s instructs %q, whose classification cannot be read", entry.Name(), operation)+ require.False(t, auth.MCPClassIsRefused(class),+ "%s instructs %q, which is %v — no MCP ceiling serves it, so the skill cannot be followed",+ entry.Name(), operation, class)+ }+ })+ }+}diff --git a/backend/api/v1/audit.go b/backend/api/v1/audit.goindex 733d5d0153..a348a25453 100644--- a/backend/api/v1/audit.go+++ b/backend/api/v1/audit.go@@ -77,11 +77,29 @@ func (in *AuditInterceptor) WrapUnary(next connect.UnaryFunc) connect.UnaryFunchandlerAuditWorkspaceID = workspaceID})+ // The MCP ceiling gate sits inside this interceptor and refuses a call+ // before it reaches its handler. needAudit reads only the method's own+ // audit annotation, and 47 of the 121 methods the gate refuses carry+ // none: the four FORBIDDEN ones that were silent before the gate grew+ // (Refresh, SwitchWorkspace, TestIdentityProvider, TestEmailSetting)+ // plus 43 EXCLUDED ones. Their denials would leave no trace at all.+ // A policy denial is recorded whatever the annotation says: the+ // annotation decides whether ordinary use of a method is interesting,+ // and a refused agent is interesting either way. Only the internal MCP+ // chain runs the gate, so the public chain is unaffected.+ //+ // Recording a request that was never recorded is why getRequestString+ // grew redactors below: a denial must not transcribe the secret it+ // refused. The rule for a new one is the population above, not the four+ // named methods.+ mcpPolicyDenied := false+ ctx = common.WithSetMCPPolicyDenied(ctx, func() { mcpPolicyDenied = true })+startTime := time.Now()response, rerr := next(ctx, req)latency := time.Since(startTime)- if needAudit(ctx) {+ if needAudit(ctx) || mcpPolicyDenied {var respMsg anyif !common.IsNil(response) {respMsg = response.Any()@@ -268,9 +286,23 @@ func (in *AuditInterceptor) createAuditLog(ctx context.Context, e *auditEntry) eseenParent[ap.parent] = trueparents = append(parents, ap)}- handlerValidatedWorkspaceMethod := e.method == v1connect.AuthServiceRequestPasswordResetProcedure ||+ // The reset flow is allow_without_credential, so an unauthenticated caller+ // could name any workspace and write rows into it. Its audit parent+ // therefore comes only from the workspace the HANDLER validated, and never+ // from the request or the fallback below.+ //+ // A request carrying a delegated MCP grant is the one exception, because+ // its workspace was not named by the caller: the internal MCP interceptor+ // verified the credential and bound the workspace before the request+ // reached this chain. Without the exception these three methods are the+ // last silent denials in the system — the ceiling gate refuses them before+ // dispatch, so the handler never runs and never announces a workspace —+ // and they are the flow that mails or consumes the secret a login accepts.+ // Presence of the grant is the marker, never a field value.+ handlerValidatedWorkspaceMethod := (e.method == v1connect.AuthServiceRequestPasswordResetProcedure ||e.method == v1connect.AuthServiceResetPasswordProcedure ||- e.method == v1connect.AuthServiceSendEmailLoginCodeProcedure+ e.method == v1connect.AuthServiceSendEmailLoginCodeProcedure) &&+ authContext.DelegatedGrant == nilif handlerValidatedWorkspaceMethod {if e.handlerAuditWorkspaceID != "" {appendParent(auditParent{@@ -534,6 +566,9 @@ func getRequestString(request any) (string, error) {if request == nil || reflect.ValueOf(request).IsNil() {return nil}+ if redacted, ok := redactMCPDenialRequest(request); ok {+ return redacted+ }switch r := request.(type) {case *v1pb.ExportRequest:return redactExportRequest(r)@@ -660,6 +695,56 @@ func getRequestString(request any) (string, error) {return string(b), nil}+// redactMCPDenialRequest handles the requests that reach the audit log only+// because MCP denials are recorded. The methods themselves are unaudited; what+// arrives here is a refusal, and a refusal that transcribed the secret it+// refused would be worse than the silence it replaced. Every secret masked here+// is already masked on a sibling method that has always been audited.+//+// It is a function rather than six more arms of getRequestString's switch+// because it is one population with one reason for existing, and that reason is+// worth stating once where a reader can find it.+//+// Which six is not a judgment to repeat by eye — the first pass of it missed+// ListInstanceDatabase, whose request carries a whole Instance and therefore+// every data-source credential the product has. The population is derived from+// the descriptors instead, and TestLintDenialRequestsAreReviewedForRedaction+// fails when a method joins it.+//+// The bool reports whether this was one of them, so an unrelated request falls+// through to the main switch untouched.+func redactMCPDenialRequest(request any) (protoreflect.ProtoMessage, bool) {+ switch r := request.(type) {+ case *v1pb.TestWebhookRequest:+ r = proto.CloneOf(r)+ r.Webhook = redactWebhook(r.Webhook)+ return r, true+ case *v1pb.TestEmailSettingRequest:+ r = proto.CloneOf(r)+ r.EmailSetting = redactEmailSetting(r.EmailSetting)+ return r, true+ case *v1pb.TestIdentityProviderRequest:+ return redactTestIdentityProviderRequest(r), true+ case *v1pb.SwitchWorkspaceRequest:+ return redactSwitchWorkspaceRequest(r), true+ case *v1pb.AIChatRequest:+ return redactAIChatRequest(r), true+ case *v1pb.ListInstanceDatabaseRequest:+ // The request carries a whole Instance — "we need to set this+ // field if the target instance is not created yet" — so it holds+ // every data-source credential: password, ssl_key,+ // ssh_private_key, the Kerberos keytab, the AWS/Azure/GCP+ // credentials, the external-secret token and master_password.+ // redactInstance is the same helper CreateInstance and+ // UpdateInstance already use.+ r = proto.CloneOf(r)+ r.Instance = redactInstance(r.Instance)+ return r, true+ default:+ return nil, false+ }+}+func getResponseString(response any) (string, error) {m := func() protoreflect.ProtoMessage {if response == nil || reflect.ValueOf(response).IsNil() {@@ -803,18 +888,10 @@ func redactLoginRequest(r *v1pb.LoginRequest) *v1pb.LoginRequest {if r.Password != "" {r.Password = maskedString}- if r.OtpCode != nil {- r.OtpCode = &maskedString- }- if r.RecoveryCode != nil {- r.RecoveryCode = &maskedString- }- if r.MfaTempToken != nil {- r.MfaTempToken = &maskedString- }- if r.EmailCode != nil {- r.EmailCode = &maskedString- }+ maskOptionalString(&r.OtpCode)+ maskOptionalString(&r.RecoveryCode)+ maskOptionalString(&r.MfaTempToken)+ maskOptionalString(&r.EmailCode)if r.IdpContext != nil {r.IdpContext = nil}@@ -911,6 +988,84 @@ func redactIdentityProvider(r *v1pb.IdentityProvider) *v1pb.IdentityProvider {return r}+// redactEmailSetting masks the SMTP password, the same field redactSetting+// masks when the same value arrives through UpdateSetting.+func redactEmailSetting(e *v1pb.EmailSetting) *v1pb.EmailSetting {+ if e == nil {+ return nil+ }+ e = proto.CloneOf(e)+ if smtp := e.GetSmtp(); smtp.GetPassword() != "" {+ smtp.Password = maskedString+ }+ return e+}++// redactTestIdentityProviderRequest masks both halves of a connection test: the+// provider's own client secret or LDAP bind password, which redactIdentityProvider+// already masks on Create and Update, and the credential supplied to run the+// test — an authorization code, or a directory user's password. Each arm checks+// the wrapped message: a oneof wrapper can be set with a nil payload, and this+// runs on the audit path, where a panic would cost the row.+func redactTestIdentityProviderRequest(r *v1pb.TestIdentityProviderRequest) *v1pb.TestIdentityProviderRequest {+ if r == nil {+ return nil+ }+ r = proto.CloneOf(r)+ r.IdentityProvider = redactIdentityProvider(r.IdentityProvider)+ switch context := r.GetContext().(type) {+ case *v1pb.TestIdentityProviderRequest_Oauth2Context:+ if context.Oauth2Context != nil {+ context.Oauth2Context.Code = maskedString+ }+ case *v1pb.TestIdentityProviderRequest_OidcContext:+ if context.OidcContext != nil {+ context.OidcContext.Code = maskedString+ }+ case *v1pb.TestIdentityProviderRequest_LdapContext:+ if context.LdapContext != nil {+ context.LdapContext.Password = maskedString+ }+ default:+ }+ return r+}++// redactSwitchWorkspaceRequest masks the MFA proofs, the same three fields+// redactLoginRequest masks when they arrive on Login.+func redactSwitchWorkspaceRequest(r *v1pb.SwitchWorkspaceRequest) *v1pb.SwitchWorkspaceRequest {+ if r == nil {+ return nil+ }+ r = proto.CloneOf(r)+ maskOptionalString(&r.OtpCode)+ maskOptionalString(&r.RecoveryCode)+ maskOptionalString(&r.MfaTempToken)+ return r+}++// redactAIChatRequest drops the conversation instead of masking a field. The+// request has no secret in it; it has an unbounded body — every message the+// caller sent, plus the tool definitions — and the audit row stores it whole+// (the size cap applies to the stdout logger only). AIService/Chat is EXCLUDED+// and unaudited, so the only rows it ever produces are the gate's denials, and+// a denial needs the fact of the call, not its transcript.+func redactAIChatRequest(r *v1pb.AIChatRequest) *v1pb.AIChatRequest {+ if r == nil {+ return nil+ }+ return &v1pb.AIChatRequest{}+}++// maskOptionalString masks an optional string field in place when it is set,+// so the several credential fields spelled `optional string` mask the same way+// wherever they appear.+func maskOptionalString(field **string) {+ if *field != nil {+ *field = &maskedString+ }+}+func redactWebhook(w *v1pb.Webhook) *v1pb.Webhook {if w == nil {return nildiff --git a/backend/api/v1/audit_redaction_test.go b/backend/api/v1/audit_redaction_test.goindex 56b2d541af..b43625ba8c 100644--- a/backend/api/v1/audit_redaction_test.go+++ b/backend/api/v1/audit_redaction_test.go@@ -374,6 +374,13 @@ func TestAuditRedactsEveryInputOnlyDataSourceField(t *testing.T) {{"add data source", &v1pb.AddDataSourceRequest{DataSource: filled}},{"update data source", &v1pb.UpdateDataSourceRequest{DataSource: filled}},{"remove data source", &v1pb.RemoveDataSourceRequest{DataSource: filled}},+ // The seventh carrier, and the one that reaches the audit log only+ // because MCP denials are recorded: ListInstanceDatabase is+ // EXCLUDED and unaudited, so its request was never written down+ // until the ceiling gate started recording its refusals.+ {"list instance database", &v1pb.ListInstanceDatabaseRequest{Instance: &v1pb.Instance{+ DataSources: []*v1pb.DataSource{filled},+ }}},} {t.Run(fmt.Sprintf("%s/oneof arm %d", tt.name, arm), func(t *testing.T) {got, err := getRequestString(tt.request)diff --git a/backend/api/v1/issue_service.go b/backend/api/v1/issue_service.goindex 2c5ab91aab..19cc29e6b9 100644--- a/backend/api/v1/issue_service.go+++ b/backend/api/v1/issue_service.go@@ -407,6 +407,9 @@ func (s *IssueService) getUserByIdentifier(ctx context.Context, identifier strin// CreateIssue creates a issue.func (s *IssueService) CreateIssue(ctx context.Context, req *connect.Request[v1pb.CreateIssueRequest]) (*connect.Response[v1pb.Issue], error) {+ if err := rejectMCPOriginatedGrantIssue(ctx, req.Msg.GetIssue().GetType()); err != nil {+ return nil, err+ }projectID, err := common.GetProjectID(req.Msg.Parent)if err != nil {return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("%v", err.Error()))@@ -538,6 +541,42 @@ func (s *IssueService) findLinkedIssueForCreate(ctx context.Context, issue *storreturn existing, nil}+// rejectMCPOriginatedGrantIssue refuses an MCP session creating an issue of any+// type but the database change an agent exists to compose. A ROLE_GRANT issue+// completes on creation whenever the workspace approval rule produces no+// template, and completing it writes the project IAM binding for whichever+// grantee the request named — which is ProjectService/SetIamPolicy, a method+// the MCP ceiling refuses outright. The session would end up granting access+// with no human step.+//+// It lives here rather than only in the ceiling gate because CREATION is the+// fact it turns on, and the gate cannot see that fact. UpdateIssue with+// allow_missing is the same creation under another name, but only when the+// issue does not exist: the handler reaches this function through that branch+// alone, so an ordinary AIP upsert of an issue that DOES exist never arrives+// here — and it must not be refused, since the type in a full-resource PATCH+// says nothing about whether the call creates anything. The gate keeps its own+// refusal for CreateIssue, where the request shape IS the whole story and the+// denial can land before dispatch; this one covers the delegation the gate+// cannot follow, the same way rejectMCPOriginatedTokenMint sits at the mint+// rather than only at its callers.+//+// Presence of the delegated grant is the MCP-origin marker, never a field+// value (common.DelegatedGrant).+func rejectMCPOriginatedGrantIssue(ctx context.Context, issueType v1pb.Issue_Type) error {+ authCtx, ok := common.GetAuthContextFromContext(ctx)+ if !ok || authCtx.DelegatedGrant == nil {+ return nil+ }+ if issueType == v1pb.Issue_DATABASE_CHANGE {+ return nil+ }+ return connect.NewError(connect.CodePermissionDenied, errors.Errorf(+ "an MCP session may not create a %v issue: that issue type completes on creation whenever the "++ "workspace approval rule produces no template, which grants access with no human step. "++ "Create it signed in to the Bytebase console instead", issueType))+}+func (s *IssueService) buildIssueMessage(ctx context.Context, project *store.ProjectMessage, userEmail string, request *v1pb.CreateIssueRequest, labels []string) (*store.IssueMessage, error) {var planUID *int64var roleGrant *storepb.RoleGrantdiff --git a/backend/api/v1/mcp_forbidden.go b/backend/api/v1/mcp_forbidden.godeleted file mode 100644index 27e7cc1398..0000000000--- a/backend/api/v1/mcp_forbidden.go+++ /dev/null@@ -1,263 +0,0 @@-package v1--import (- "context"-- "connectrpc.com/connect"- "github.com/pkg/errors"-- "github.com/bytebase/bytebase/backend/common"- v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"-)--// mcpForbiddenReasons is UX copy, NOT the classification and NOT the mapping.-// Both of those live on the RPC itself, as the bytebase.v1.mcp_method_class and-// bytebase.v1.mcp_forbidden_reason annotations, beside permission / audit /-// auth_method — one source of truth, visible where the RPC is defined, and read-// here off the AuthContext the auth interceptor already resolves. This table-// only turns a reason into a sentence the agent can act on, so it has one row-// per mechanism rather than one per method, and a missing row costs wording,-// never enforcement.-//-// Each sentence completes "<procedure> is not available to MCP sessions because-// ___", so it states what the method does rather than merely that it is-// refused: a denial whose stated reason has drifted from the mechanism is worse-// than a bare refusal, because it is the thing the next reader trusts.-var mcpForbiddenReasons = map[v1pb.MCPForbiddenReason]string{- // The method hands a token back to the caller. For a non-web caller — and- // an MCP session is always one — finalizeLogin and switchWorkspaceInternal- // put a plain bb.user.access token in the response body. That token is not- // audience-bound to the MCP resource, survives revocation of the OAuth- // grant, and ignores the workspace MCP kill switch, so obtaining one ends- // the MCP boundary for good.- v1pb.MCPForbiddenReason_MINTS_CREDENTIAL: "it hands back a login token that would outlive the MCP grant",-- // The method drives the out-of-band reset flow — mailing a reset or login- // code, or consuming one — that sets or delivers the very secret Login- // accepts. Denying Login alone would leave the agent holding the credential- // for the next human login.- v1pb.MCPForbiddenReason_RESETS_CREDENTIAL: "it drives the credential-reset flow that sets or delivers the secret a login accepts",-- // UpdateUser's password and MFA branches take no proof of the old password.- // A caller updating itself needs no permission at all, and on self-hosted a- // caller holding bb.users.update reaches any other end user's password too- // (user_service.go: the caller != subject branch checks that permission and- // nothing further). Either way the session ends up holding credentials it- // can log in with. The whole method is refused, not just those branches —- // the classification is per method.- v1pb.MCPForbiddenReason_TAKES_OVER_ACCOUNT: "it can rewrite an account's credentials, which would let the session take that account over",-- // Logout deletes the web refresh token and expires the session cookies. It- // mints nothing; it destroys the human's own login session, which an agent- // acting on their behalf has no business doing.- v1pb.MCPForbiddenReason_ENDS_SESSION: "it ends the human's own login session",-- // The workspace-lifecycle pair. Both end in- // AuthService.switchWorkspaceInternal, which mints a plain workspace token- // whenever the caller has no refresh cookie — and an MCP session never has- // one — after having already destroyed the caller's membership.- v1pb.MCPForbiddenReason_ENDS_MEMBERSHIP: "it destroys the caller's own workspace membership and mints a plain workspace token",-- // The method leaves someone holding a principal the caller is not. Four- // ways, all of them annotated:- // - issuing the credential outright — a service key or SCIM token- // returned in plaintext, a caller-chosen password on a new account;- // - carrying an existing one out — a stored client secret or SMTP- // password sent to a host the caller named;- // - choosing what will later be trusted to mint one — the issuer and- // subject ExchangeToken validates against;- // - redirecting where one gets delivered — UpdateEmail rebinds any- // account to an address the caller picked, and the reset flow mails the- // code to whatever address the account then carries.- // The levers that contain a runaway session all act on the caller's own- // principal: revoke the OAuth grant, flip the workspace MCP switch,- // deactivate the human. None of them reaches a principal that was never the- // caller's, so what these give away outlives all three.- //- // InstanceService/UpdateDataSource is the same "carry an existing one out"- // shape as the two Test methods, against the database's credentials rather- // than Bytebase's own: it merges a partial request onto the STORED,- // already-decrypted data source, so an update_mask naming only a- // destination field (host, port, ssh_host, additional_addresses,- // sasl_config.kdc_host) keeps the stored password, ssl_key and- // ssh_private_key. With validate_only it dials the caller's host- // immediately and persists nothing; without it the retarget is written and- // SyncInstance triggers the connection on demand. No allowlist filters the- // host on either path. A database user is a principal other than the- // caller, the same way the SMTP account behind TestEmailSetting is.- //- // Its siblings are NOT here and the line is severity, not tidiness:- // UpdateInstance and BatchUpdateInstances rebuild the data-source list- // wholesale, so every secret is wiped unless resent — except the Kerberos- // keytab, which retainStoredKeytabs used to inherit by data-source ID.- // That narrower, persist-only version of the vector is now closed at the- // retention rule instead of at reachability: a keytab is not inherited to- // a destination the caller moved (instance_service_converter.go). It costs- // an agent no instance management, something no one has yet decided it- // should lose, and it binds human callers too — a Kerberos host edit now- // asks for the keytab again, on the console as much as on the API.- // The keytab is the ONLY secret that rule reaches, because it is the only- // one those two methods inherit. On UpdateDataSource above, every other- // stored secret still rides an update_mask that names only a destination,- // which is why that method is refused here rather than fixed there:- // requiring a password re-supplied on every host edit is a product call.- // AddDataSource and CreateInstance also dial on validate_only but build- // the data source entirely from the request, so they carry no stored- // secret and are not this class. BOT-57.- //- // The Undelete* family (user, service account, workload identity) is- // deliberately NOT in this group, and it is the nearest thing left out, so- // the reasoning is recorded rather than left to be rediscovered. It- // restores a principal whose password or key hash survived the soft- // delete, so an operator's deactivation is undone. It is out because the- // caller learns and chooses nothing: the credential goes back to whoever- // already had it, and a second delete takes it away again. Issuing beats- // re-arming, and this mechanism is about issuing. BOT-54.- v1pb.MCPForbiddenReason_MINTS_CREDENTIAL_FOR_OTHERS: "it hands someone control of a principal other than the caller, which revoking this session would not take back",-- // SettingService/UpdateSetting, refused for the boundary it rewrites- // rather than for any credential it hands out. Three mask paths carry it:- // value.workspace_profile.mcp_capability IS the MCP ceiling, so a session- // that reaches it is not bounded by it; value.email.smtp keeps the- // stored password when the request omits it while accepting a new host,- // which hands over the relay resolvePreLoginEmailSetting reads to mail- // password resets and login codes; and value.ai.endpoint does the same to- // the AI key it never names — the stored api_key survives the mask, and the- // next AIService/Chat puts it in an auth header to the host just written- // (ai_service.go). SaaS refuses AI writes outright (setting_service.go), so- // that third one is a self-hosted vector, and the key it carries out is- // whatever the operator configured — GEMINI_API_KEY, where it is set, seeds- // one key into every workspace created after it (getAdditionalWorkspaceSettings).- // TestEmailSetting is the one-shot version of the second; this is the- // persisting one. The same method also writes the SSO domain allowlist and- // the sign-in switches.- //- // Classification is per method, so this refuses the whole RPC — including- // the settings that have nothing to do with any of them. Splitting the- // handler so ordinary configuration stays reachable to an agent is the- // follow-up (BOT-53); disallowing first is the deliberate order.- v1pb.MCPForbiddenReason_REWRITES_SESSION_BOUNDARY: "it rewrites the workspace settings that bound this session, including the switch meant to contain it",-- // The four approval methods. ApproveIssue and RejectIssue are two actions of- // one handler (issue_review.go reviewIssue), and that handler records the- // review decision itself: applyReviewAction requires an approver role via- // canReview, enforces the self-approval guard, and appends an APPROVED or- // REJECTED approver (component/review/workflow.go). An agent composes a- // change; it does not move its own change through the gate. That is the- // whole claim,- // and it is deliberately narrower than "an agent only executes approved work",- // which this classification does NOT deliver: CreatePlan, CreateRollout and- // BatchRunTasks are all WRITE, and both approval checks on the execution- // path are guarded on an issue existing, so a plan created without one- // reaches execution with no approval at all. Whether an issueless rollout- // belongs in WRITE is the gate PR's decision to take deliberately rather- // than inherit.- //- // RequestIssue is the third action of the same handler and is deliberately- // NOT here — it is WRITE. Spec §1b-1 named four approval methods; that line- // grouped by RPC family rather than by mechanism, and the mechanism does not- // agree. This action requires the issue to be already rejected, requires the- // actor to be the issue CREATOR, never calls canReview, and records no- // decision: it strips the REJECTED approvers and returns the issue to- // PENDING for a fresh human decision. It cannot approve anything, so- // refusing it protects nothing the other two do not, and it costs the- // propose-fix-resubmit loop, since while a rejection stands Approve and- // Reject both hard-fail and this is the only exit from that state. The- // reasoning is on the RPC in issue_service.proto. Raised by the Codex- // review; Vincent took the call.- //- // RetryIssueApproval is the near miss and is in deliberately. It casts no- // vote — it re-runs approval-template finding for an issue stuck in- // CHECKING, and only the issue creator may call it (issue_service.go- // canRequestIssue) — but it is the other half of the reason's wording- // rather than an exception to it: on an auto-approved result the same call- // activates the grant and enqueues the rollout (issue_service.go:789,796),- // so it moves an issue through the gate without any human acting. What it- // does not buy is containment of re-derivation in general: UpdatePlan with- // a specs mask, and UpdateIssue on a label change, both reset- // ApprovalFindingDone and force the template to be found again against the- // current workspace rule (component/review/plan.go, metadata.go), and both- // stay WRITE. That is the intended line — editing a proposal is the agent's- // job, and re-review after an edit is the system working — not an oversight.- // Refusing RetryIssueApproval costs an agent the self-service recovery for- // its own stuck issue; the operator retries from the console.- v1pb.MCPForbiddenReason_DRIVES_THE_APPROVAL_DECISION: "it works the approval step meant to gate the change, and an agent does not move its own change through that gate",-}--// reasonForbiddenClass is the fallback for a method annotated FORBIDDEN whose-// reason is unset or unknown to this build. The class annotation is what denies-// the method; the table only supplies better wording.-const reasonForbiddenClass = "it is not reachable by an AI agent session"--// NewInternalMCPForbiddenInterceptor denies every method annotated-// mcp_method_class = FORBIDDEN before dispatch. It belongs to the internal MCP-// chain only — every request there originates at /mcp — and sits inside the-// audit interceptor, outside ACL: the class is refused regardless of what RBAC-// would have said.-//-// Only FORBIDDEN is enforced. Every v1 RPC now carries a class and CI rejects-// UNSPECIFIED, so READ, WRITE and EXCLUDED are recorded classifications with no-// request-time reader yet: a method carrying one is served exactly as it is-// today, and the gate that selects between them is a later change. This-// interceptor grows with the annotations rather than with a list kept here.-//-// Sitting inside audit gets the denial a row for most of the annotated-// FORBIDDEN methods, but not all, and the exceptions are worth knowing because-// none of them is visible from the annotations alone. Two mechanisms remain:-//-// - No audit annotation, so needAudit refuses the row outright:-// SwitchWorkspace, Refresh, TestIdentityProvider, TestEmailSetting.-//-// - Audit annotation, but no reachable audit parent: RequestPasswordReset,-// ResetPassword and SendEmailLoginCode are allow_without_credential, so-// createAuditLog takes their parent ONLY from what the handler validated-// via common.SetAuditWorkspaceID and deliberately skips the workspace-// fallback (handlerValidatedWorkspaceMethod, audit.go) — an unvalidated-// workspace on an unauthenticated method would let anyone write rows into-// someone else's. This gate refuses before dispatch, so the handler never-// runs and no parent is ever set. #21162 gave the first two the audit-// annotation; it did not give them rows.-//-// A third way is CLOSED and kept here because it is the one a reader would-// otherwise rediscover: createAuditLog used to return on its first statement-// for anything whose validate_only field is set, before it considered the-// denial at all. That silenced any FORBIDDEN method whose request carries the-// field — CreateIdentityProvider, UpdateSetting and UpdateDataSource — and-// validate_only is the variant that leaves no other trace, since it dials the-// caller's host and persists nothing. The skip now applies only when the call-// SUCCEEDED (audit.go), so a denial always records.-//-// The first group is 1b-2's typed policy-denial record. The second needs that-// too, or the audit path to accept the delegated credential's workspace, which-// the internal chain has already verified.-// TestMCPResetFlowDenialsAreSilent pins the second, so the next person to add-// an annotation learns it is not enough from a red test rather than from an-// operator asking where the row went; TestMCPCannotRetargetADataSource now-// asserts the closed third, as an A/B on one flag — two identical denials of-// one method, both auditable. The ones that sting are TestIdentityProvider and-// TestEmailSetting: each would carry a stored secret to an address the agent-// chose, and their denials are the rows an operator would most want.-func NewInternalMCPForbiddenInterceptor() connect.Interceptor {- return connect.UnaryInterceptorFunc(func(next connect.UnaryFunc) connect.UnaryFunc {- return func(ctx context.Context, req connect.AnyRequest) (connect.AnyResponse, error) {- authCtx, ok := common.GetAuthContextFromContext(ctx)- if !ok {- // The auth interceptor runs first and always sets this. Its- // absence means the chain was reordered, and guessing which- // class a method is in is exactly the wrong response.- return nil, connect.NewError(connect.CodeInternal,- errors.New("MCP method classification unavailable: no auth context"))- }- if authCtx.MCPMethodClass != v1pb.MCPMethodClass_FORBIDDEN {- return next(ctx, req)- }- reason, ok := mcpForbiddenReasons[authCtx.MCPForbiddenReason]- if !ok {- reason = reasonForbiddenClass- }- return nil, connect.NewError(connect.CodePermissionDenied, errors.Errorf(- "%s is not available to MCP sessions because %s. Perform this action signed in to the Bytebase console instead",- req.Spec().Procedure, reason))- }- })-}diff --git a/backend/api/v1/mcp_forbidden_test.go b/backend/api/v1/mcp_forbidden_test.godeleted file mode 100644index 3937be0e80..0000000000--- a/backend/api/v1/mcp_forbidden_test.go+++ /dev/null@@ -1,738 +0,0 @@-package v1--import (- "context"- "fmt"- "os"- "slices"- "strings"- "testing"-- "connectrpc.com/connect"- "github.com/stretchr/testify/require"- "google.golang.org/protobuf/proto"- "google.golang.org/protobuf/reflect/protoreflect"- "google.golang.org/protobuf/reflect/protoregistry"-- "github.com/bytebase/bytebase/backend/common"- v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"- "github.com/bytebase/bytebase/backend/generated-go/v1/v1connect"-)--// mcpClassification is one v1 RPC's MCP annotations, as the compiled-// descriptors carry them.-type mcpClassification struct {- procedure string- class v1pb.MCPMethodClass- forbiddenReason v1pb.MCPForbiddenReason- exclusionReason v1pb.MCPExclusionReason- permission string-}--// mcpClassificationsFromDescriptors reads every v1 RPC's classification off the-// compiled descriptors — the same place getAuthContext reads it — so everything-// below is asserted against the annotations themselves, not against a Go copy-// of them that could agree with itself while the protos say otherwise. It only-// reads; the judgments live in the check functions, which take the rows as an-// argument so a deliberately broken copy can be fed to the same code.-func mcpClassificationsFromDescriptors(t *testing.T) []mcpClassification {- t.Helper()- var rows []mcpClassification- protoregistry.GlobalFiles.RangeFiles(func(fd protoreflect.FileDescriptor) bool {- if fd.Package() != "bytebase.v1" {- return true- }- services := fd.Services()- for i := range services.Len() {- sd := services.Get(i)- methods := sd.Methods()- for j := range methods.Len() {- md := methods.Get(j)- class, ok := proto.GetExtension(md.Options(), v1pb.E_McpMethodClass).(v1pb.MCPMethodClass)- require.True(t, ok, "method %s carries a malformed mcp_method_class", md.FullName())- forbiddenReason, ok := proto.GetExtension(md.Options(), v1pb.E_McpForbiddenReason).(v1pb.MCPForbiddenReason)- require.True(t, ok, "method %s carries a malformed mcp_forbidden_reason", md.FullName())- exclusionReason, ok := proto.GetExtension(md.Options(), v1pb.E_McpExclusionReason).(v1pb.MCPExclusionReason)- require.True(t, ok, "method %s carries a malformed mcp_exclusion_reason", md.FullName())- permission, ok := proto.GetExtension(md.Options(), v1pb.E_Permission).(string)- require.True(t, ok, "method %s carries a malformed permission", md.FullName())- rows = append(rows, mcpClassification{- procedure: fmt.Sprintf("/%s/%s", sd.FullName(), md.Name()),- class: class,- forbiddenReason: forbiddenReason,- exclusionReason: exclusionReason,- permission: permission,- })- }- }- return true- })- slices.SortFunc(rows, func(a, b mcpClassification) int { return strings.Compare(a.procedure, b.procedure) })- return rows-}--// forbiddenProceduresFromDescriptors narrows the classification to the refused-// set, which is the half the interceptor enforces today.-func forbiddenProceduresFromDescriptors(t *testing.T) map[string]v1pb.MCPForbiddenReason {- t.Helper()- found := map[string]v1pb.MCPForbiddenReason{}- for _, row := range mcpClassificationsFromDescriptors(t) {- if row.class == v1pb.MCPMethodClass_FORBIDDEN {- found[row.procedure] = row.forbiddenReason- }- }- return found-}--// TestForbiddenClassMembership pins which RPCs are annotated FORBIDDEN.-// Membership is a security decision, so adding or removing one has to be-// deliberate: this list is the second signature on that decision.-func TestForbiddenClassMembership(t *testing.T) {- want := []string{- v1connect.AuthServiceLoginProcedure,- v1connect.AuthServiceSignupProcedure,- v1connect.AuthServiceExchangeTokenProcedure,- v1connect.AuthServiceRefreshProcedure,- v1connect.AuthServiceLogoutProcedure,- v1connect.AuthServiceRequestPasswordResetProcedure,- v1connect.AuthServiceResetPasswordProcedure,- v1connect.AuthServiceSendEmailLoginCodeProcedure,- v1connect.AuthServiceSwitchWorkspaceProcedure,- v1connect.UserServiceUpdateUserProcedure,- v1connect.WorkspaceServiceLeaveWorkspaceProcedure,- v1connect.WorkspaceServiceDeleteWorkspaceProcedure,- v1connect.ServiceAccountServiceCreateServiceAccountProcedure,- v1connect.ServiceAccountServiceUpdateServiceAccountProcedure,- v1connect.WorkspaceServiceRotateDirectorySyncTokenProcedure,- v1connect.UserServiceCreateUserProcedure,- v1connect.IdentityProviderServiceCreateIdentityProviderProcedure,- v1connect.IdentityProviderServiceUpdateIdentityProviderProcedure,- v1connect.IdentityProviderServiceTestIdentityProviderProcedure,- v1connect.WorkloadIdentityServiceCreateWorkloadIdentityProcedure,- v1connect.WorkloadIdentityServiceUpdateWorkloadIdentityProcedure,- v1connect.SettingServiceTestEmailSettingProcedure,- v1connect.UserServiceUpdateEmailProcedure,- v1connect.SettingServiceUpdateSettingProcedure,- v1connect.InstanceServiceUpdateDataSourceProcedure,- v1connect.IssueServiceApproveIssueProcedure,- v1connect.IssueServiceRejectIssueProcedure,- v1connect.IssueServiceRetryIssueApprovalProcedure,- }- got := forbiddenProceduresFromDescriptors(t)-- for _, procedure := range want {- require.Contains(t, got, procedure, "%s must be annotated mcp_method_class = FORBIDDEN", procedure)- }- require.Len(t, got, len(want),- "an RPC was annotated FORBIDDEN without being added here; membership must be an explicit decision")-- // Which mechanism each method is refused for, read off the annotations- // rather than off a Go copy of them. The reason has to describe what the- // method does, not merely be present: Logout destroys a session rather than- // issuing a credential, and a denial that says otherwise teaches the next- // reader something false. These are near-synonyms in English and are not- // near-synonyms in what they tell an operator, so every method is pinned.- wantReason := map[string]v1pb.MCPForbiddenReason{- v1connect.AuthServiceLoginProcedure: v1pb.MCPForbiddenReason_MINTS_CREDENTIAL,- v1connect.AuthServiceSignupProcedure: v1pb.MCPForbiddenReason_MINTS_CREDENTIAL,- v1connect.AuthServiceExchangeTokenProcedure: v1pb.MCPForbiddenReason_MINTS_CREDENTIAL,- v1connect.AuthServiceRefreshProcedure: v1pb.MCPForbiddenReason_MINTS_CREDENTIAL,- v1connect.AuthServiceSwitchWorkspaceProcedure: v1pb.MCPForbiddenReason_MINTS_CREDENTIAL,- v1connect.AuthServiceRequestPasswordResetProcedure: v1pb.MCPForbiddenReason_RESETS_CREDENTIAL,- v1connect.AuthServiceResetPasswordProcedure: v1pb.MCPForbiddenReason_RESETS_CREDENTIAL,- v1connect.AuthServiceSendEmailLoginCodeProcedure: v1pb.MCPForbiddenReason_RESETS_CREDENTIAL,- v1connect.UserServiceUpdateUserProcedure: v1pb.MCPForbiddenReason_TAKES_OVER_ACCOUNT,- v1connect.AuthServiceLogoutProcedure: v1pb.MCPForbiddenReason_ENDS_SESSION,- v1connect.WorkspaceServiceLeaveWorkspaceProcedure: v1pb.MCPForbiddenReason_ENDS_MEMBERSHIP,- v1connect.WorkspaceServiceDeleteWorkspaceProcedure: v1pb.MCPForbiddenReason_ENDS_MEMBERSHIP,- v1connect.ServiceAccountServiceCreateServiceAccountProcedure: v1pb.MCPForbiddenReason_MINTS_CREDENTIAL_FOR_OTHERS,- v1connect.ServiceAccountServiceUpdateServiceAccountProcedure: v1pb.MCPForbiddenReason_MINTS_CREDENTIAL_FOR_OTHERS,- v1connect.WorkspaceServiceRotateDirectorySyncTokenProcedure: v1pb.MCPForbiddenReason_MINTS_CREDENTIAL_FOR_OTHERS,- v1connect.UserServiceCreateUserProcedure: v1pb.MCPForbiddenReason_MINTS_CREDENTIAL_FOR_OTHERS,- v1connect.UserServiceUpdateEmailProcedure: v1pb.MCPForbiddenReason_MINTS_CREDENTIAL_FOR_OTHERS,- v1connect.IdentityProviderServiceCreateIdentityProviderProcedure: v1pb.MCPForbiddenReason_MINTS_CREDENTIAL_FOR_OTHERS,- v1connect.IdentityProviderServiceUpdateIdentityProviderProcedure: v1pb.MCPForbiddenReason_MINTS_CREDENTIAL_FOR_OTHERS,- v1connect.IdentityProviderServiceTestIdentityProviderProcedure: v1pb.MCPForbiddenReason_MINTS_CREDENTIAL_FOR_OTHERS,- v1connect.WorkloadIdentityServiceCreateWorkloadIdentityProcedure: v1pb.MCPForbiddenReason_MINTS_CREDENTIAL_FOR_OTHERS,- v1connect.WorkloadIdentityServiceUpdateWorkloadIdentityProcedure: v1pb.MCPForbiddenReason_MINTS_CREDENTIAL_FOR_OTHERS,- v1connect.SettingServiceTestEmailSettingProcedure: v1pb.MCPForbiddenReason_MINTS_CREDENTIAL_FOR_OTHERS,- v1connect.SettingServiceUpdateSettingProcedure: v1pb.MCPForbiddenReason_REWRITES_SESSION_BOUNDARY,- v1connect.InstanceServiceUpdateDataSourceProcedure: v1pb.MCPForbiddenReason_MINTS_CREDENTIAL_FOR_OTHERS,- v1connect.IssueServiceApproveIssueProcedure: v1pb.MCPForbiddenReason_DRIVES_THE_APPROVAL_DECISION,- v1connect.IssueServiceRejectIssueProcedure: v1pb.MCPForbiddenReason_DRIVES_THE_APPROVAL_DECISION,- v1connect.IssueServiceRetryIssueApprovalProcedure: v1pb.MCPForbiddenReason_DRIVES_THE_APPROVAL_DECISION,- }- // Wording for every mechanism in use is checkReasonsMatchTheClass's job, over- // every class rather than only the ones enumerated here.- require.Equal(t, wantReason, got,- "every FORBIDDEN method records the mechanism it is refused for, and this is the second signature on it")-}--// The lint. Every clause is a function over the rows rather than a body of-// assertions, so the same code can be run against a deliberately broken copy —-// each clause has a RED test below that mutates one input and asserts the-// clause fires. A clause with no RED test is a clause nobody has proved can-// fail.--// mcpServingModes says which classes each ceiling mode serves. It is the-// specification the gate will implement, written here as data so the lint can-// hold the classification against it; nothing reads it at request time, and the-// interceptor still enforces FORBIDDEN alone. DISABLED serves nothing because-// it refuses the connection.-//-// The gate PR must LIFT this table into the code it evaluates rather than-// declare a second copy. Two copies would let this lint stay green while the-// runtime serving rules drift away from it, which is the one failure mode a-// specification-shaped test cannot catch about itself.-var mcpServingModes = map[v1pb.WorkspaceProfileSetting_MCPCapability][]v1pb.MCPMethodClass{- v1pb.WorkspaceProfileSetting_DISABLED: {},- v1pb.WorkspaceProfileSetting_READ_ONLY: {v1pb.MCPMethodClass_READ},- v1pb.WorkspaceProfileSetting_READ_WRITE: {v1pb.MCPMethodClass_READ, v1pb.MCPMethodClass_WRITE},-}--// checkEveryMethodIsClassified is the clause that ends the whack-a-mole. A new-// RPC arrives unannotated, which is UNSPECIFIED, which fails the build — so it-// gets classified before it can ship rather than after somebody notices it was-// reachable.-func checkEveryMethodIsClassified(rows []mcpClassification) []string {- var violations []string- for _, row := range rows {- if row.class == v1pb.MCPMethodClass_MCP_METHOD_CLASS_UNSPECIFIED {- violations = append(violations, row.procedure+": carries no mcp_method_class")- }- }- slices.Sort(violations)- return violations-}--// checkReasonsMatchTheClass proves each row's reason and class agree. A refused-// method says why it is refused and has wording to say it with; an excluded-// method says why it is out; and a served method claims neither, because a-// reason without its class denies nothing and would read, to anyone grepping-// for it, as a method that is not served.-func checkReasonsMatchTheClass(rows []mcpClassification, wording map[v1pb.MCPForbiddenReason]string) []string {- var violations []string- for _, row := range rows {- hasForbiddenReason := row.forbiddenReason != v1pb.MCPForbiddenReason_MCP_FORBIDDEN_REASON_UNSPECIFIED- hasExclusionReason := row.exclusionReason != v1pb.MCPExclusionReason_MCP_EXCLUSION_REASON_UNSPECIFIED- switch row.class {- case v1pb.MCPMethodClass_FORBIDDEN:- if !hasForbiddenReason {- violations = append(violations, row.procedure+": is FORBIDDEN and records no mcp_forbidden_reason")- } else if _, ok := wording[row.forbiddenReason]; !ok {- violations = append(violations, fmt.Sprintf("%s: is refused for %v, which has no sentence to say so", row.procedure, row.forbiddenReason))- }- if hasExclusionReason {- violations = append(violations, row.procedure+": is FORBIDDEN and also records an exclusion reason")- }- case v1pb.MCPMethodClass_EXCLUDED:- if !hasExclusionReason {- violations = append(violations, row.procedure+": is EXCLUDED and records no mcp_exclusion_reason")- }- if hasForbiddenReason {- violations = append(violations, row.procedure+": is EXCLUDED and also records a forbidden reason")- }- default:- if hasForbiddenReason {- violations = append(violations, row.procedure+": records why it is forbidden but is not classified FORBIDDEN")- }- if hasExclusionReason {- violations = append(violations, row.procedure+": records why it is excluded but is not classified EXCLUDED")- }- }- }- slices.Sort(violations)- return violations-}--// mcpDeniedClasses is the other half of the same decision: the classes no mode-// serves. Held against mcpServingModes below.-var mcpDeniedClasses = []v1pb.MCPMethodClass{v1pb.MCPMethodClass_FORBIDDEN, v1pb.MCPMethodClass_EXCLUDED}--// checkEveryClassHasAServingDecision proves that "no method is both denied and-// reachable through a serving mode" is true of the whole vocabulary rather than-// of the rows that happen to exist today.-//-// Asserting it row by row would prove nothing: a row carries one class, so-// FORBIDDEN and READ are mutually exclusive by construction, and a check that-// walks 208 rows looking for a contradiction the type system already forbids is-// a check that cannot fail. What can drift is the vocabulary. So this reads the-// two enums out of the compiled descriptors and holds the tables against them:-// every class is served by some mode or denied, never both and never neither,-// and every ceiling mode says what it serves. Add a fifth class to-// MCPMethodClass, or a fourth mode to MCPCapability, and the build fails until-// somebody decides who serves it — which is the decision that would otherwise-// be made by whichever `switch` in the gate happened to have a default arm.-//-// The last loop closes the circle back to the rows. `decided` holds the classes-// some decision claims — served, denied, or, when the tables disagree, both — so-// dropping READ out of the serving table does not merely report READ once. It-// reports every method annotated READ, which is the shape of the damage.-func checkEveryClassHasAServingDecision(- rows []mcpClassification,- serving map[v1pb.WorkspaceProfileSetting_MCPCapability][]v1pb.MCPMethodClass,- denied []v1pb.MCPMethodClass,- classes protoreflect.EnumDescriptor,- modes protoreflect.EnumDescriptor,-) []string {- var violations []string- servedBy := map[v1pb.MCPMethodClass][]v1pb.WorkspaceProfileSetting_MCPCapability{}- for mode, served := range serving {- for _, class := range served {- servedBy[class] = append(servedBy[class], mode)- }- }- // serving is a map, so without this the mode list in a violation message- // comes out in a different order on every run.- for class := range servedBy {- slices.Sort(servedBy[class])- }-- inVocabulary := map[v1pb.MCPMethodClass]bool{}- decided := map[v1pb.MCPMethodClass]bool{}- values := classes.Values()- for i := range values.Len() {- class := v1pb.MCPMethodClass(values.Get(i).Number())- if class == v1pb.MCPMethodClass_MCP_METHOD_CLASS_UNSPECIFIED {- continue- }- inVocabulary[class] = true- isServed, isDenied := len(servedBy[class]) > 0, slices.Contains(denied, class)- switch {- case isServed && isDenied:- violations = append(violations, fmt.Sprintf("%v is denied and served by %v", class, servedBy[class]))- case !isServed && !isDenied:- violations = append(violations, fmt.Sprintf("%v is neither served by a mode nor denied", class))- default:- }- // Having two decisions counts as decided here. The switch above has- // already said so once; repeating it per method would bury the one- // actionable line under a hundred rows naming the wrong problem.- decided[class] = isServed || isDenied- }- for _, class := range denied {- if !inVocabulary[class] {- violations = append(violations, fmt.Sprintf("%v is denied but is not a class", class))- }- }-- modeValues := modes.Values()- for i := range modeValues.Len() {- value := modeValues.Get(i)- mode := v1pb.WorkspaceProfileSetting_MCPCapability(value.Number())- if mode == v1pb.WorkspaceProfileSetting_MCP_CAPABILITY_UNSPECIFIED {- continue- }- if _, ok := serving[mode]; !ok {- violations = append(violations, fmt.Sprintf("ceiling mode %v does not say which classes it serves", mode))- }- }-- for _, row := range rows {- if row.class != v1pb.MCPMethodClass_MCP_METHOD_CLASS_UNSPECIFIED && !decided[row.class] {- violations = append(violations, fmt.Sprintf("%s: carries %v, which has no serving decision", row.procedure, row.class))- }- }- slices.Sort(violations)- return violations-}--func TestLintEveryMethodIsClassified(t *testing.T) {- require.Empty(t, checkEveryMethodIsClassified(mcpClassificationsFromDescriptors(t)))-}--func TestLintReasonsMatchTheClass(t *testing.T) {- require.Empty(t, checkReasonsMatchTheClass(mcpClassificationsFromDescriptors(t), mcpForbiddenReasons))-}--// mcpEnums reads the two enums the serving decision spans out of the compiled-// descriptors, so the lint below tracks the protos rather than a Go copy of-// them.-func mcpEnums(t *testing.T) (classes, modes protoreflect.EnumDescriptor) {- t.Helper()- return v1pb.MCPMethodClass(0).Descriptor(), v1pb.WorkspaceProfileSetting_MCPCapability(0).Descriptor()-}--func TestLintEveryClassHasAServingDecision(t *testing.T) {- classes, modes := mcpEnums(t)- require.Empty(t, checkEveryClassHasAServingDecision(- mcpClassificationsFromDescriptors(t), mcpServingModes, mcpDeniedClasses, classes, modes))-}--// TestLintClausesFireWhenBroken is the RED half: one mutation per clause,-// asserting the clause catches it. Without these the clauses above are three-// functions that have only ever been shown to return nothing.-func TestLintClausesFireWhenBroken(t *testing.T) {- t.Run("an unclassified method fails", func(t *testing.T) {- // The shape a new RPC arrives in: defined, annotated with nothing.- // TestLintEveryMethodIsClassified owns the claim that the real- // descriptor set is clean; this owns the claim that the clause fires.- broken := append(slices.Clone(mcpClassificationsFromDescriptors(t)),- mcpClassification{procedure: "/bytebase.v1.NewService/NewMethod"})- require.Contains(t, checkEveryMethodIsClassified(broken),- "/bytebase.v1.NewService/NewMethod: carries no mcp_method_class")- })-- t.Run("a reasonless FORBIDDEN fails", func(t *testing.T) {- broken := []mcpClassification{{procedure: "/p", class: v1pb.MCPMethodClass_FORBIDDEN}}- require.Equal(t, []string{"/p: is FORBIDDEN and records no mcp_forbidden_reason"},- checkReasonsMatchTheClass(broken, mcpForbiddenReasons))- })-- t.Run("a FORBIDDEN reason with no wording fails", func(t *testing.T) {- broken := []mcpClassification{{- procedure: "/p",- class: v1pb.MCPMethodClass_FORBIDDEN,- forbiddenReason: v1pb.MCPForbiddenReason(9999),- }}- require.Equal(t, []string{"/p: is refused for 9999, which has no sentence to say so"},- checkReasonsMatchTheClass(broken, mcpForbiddenReasons))- })-- t.Run("a reasonless EXCLUDED fails", func(t *testing.T) {- broken := []mcpClassification{{procedure: "/p", class: v1pb.MCPMethodClass_EXCLUDED}}- require.Equal(t, []string{"/p: is EXCLUDED and records no mcp_exclusion_reason"},- checkReasonsMatchTheClass(broken, mcpForbiddenReasons))- })-- t.Run("a served method carrying a denial reason fails", func(t *testing.T) {- broken := []mcpClassification{- {procedure: "/p", class: v1pb.MCPMethodClass_READ, forbiddenReason: v1pb.MCPForbiddenReason_MINTS_CREDENTIAL},- {procedure: "/q", class: v1pb.MCPMethodClass_WRITE, exclusionReason: v1pb.MCPExclusionReason_ADMINISTERS_THE_WORKSPACE},- // The mistake two reason enums make possible: both at once. Whichever- // class the method carries, the other reason is a sentence about it- // that is not true.- {- procedure: "/r",- class: v1pb.MCPMethodClass_FORBIDDEN,- forbiddenReason: v1pb.MCPForbiddenReason_MINTS_CREDENTIAL,- exclusionReason: v1pb.MCPExclusionReason_ADMINISTERS_THE_WORKSPACE,- },- {- procedure: "/s",- class: v1pb.MCPMethodClass_EXCLUDED,- exclusionReason: v1pb.MCPExclusionReason_ADMINISTERS_THE_WORKSPACE,- forbiddenReason: v1pb.MCPForbiddenReason_MINTS_CREDENTIAL,- },- }- require.Equal(t, []string{- "/p: records why it is forbidden but is not classified FORBIDDEN",- "/q: records why it is excluded but is not classified EXCLUDED",- "/r: is FORBIDDEN and also records an exclusion reason",- "/s: is EXCLUDED and also records a forbidden reason",- }, checkReasonsMatchTheClass(broken, mcpForbiddenReasons))- })-- // The serving-decision clause is over the vocabulary, so its mutations are- // vocabulary mutations: a class that two decisions claim, a class no decision- // claims, a ceiling mode nobody wrote a row for, and a row reaching a class- // the tables skipped.- classes, modes := mcpEnums(t)-- t.Run("a class both served and denied fails once, not once per method", func(t *testing.T) {- widened := map[v1pb.WorkspaceProfileSetting_MCPCapability][]v1pb.MCPMethodClass{- v1pb.WorkspaceProfileSetting_DISABLED: {},- v1pb.WorkspaceProfileSetting_READ_ONLY: {v1pb.MCPMethodClass_READ, v1pb.MCPMethodClass_EXCLUDED},- v1pb.WorkspaceProfileSetting_READ_WRITE: {- v1pb.MCPMethodClass_READ, v1pb.MCPMethodClass_WRITE, v1pb.MCPMethodClass_EXCLUDED,- },- }- // The real rows are passed deliberately: 93 of them carry EXCLUDED, and- // the diagnosis worth reading is the one about the table, not ninety-three- // about methods whose annotation is fine. Two modes, so the mode list in- // the message is only stable because servedBy is sorted.- require.Equal(t, []string{"EXCLUDED is denied and served by [READ_ONLY READ_WRITE]"},- checkEveryClassHasAServingDecision(mcpClassificationsFromDescriptors(t), widened, mcpDeniedClasses, classes, modes))- })-- t.Run("a class nobody decided fails, and takes its rows with it", func(t *testing.T) {- // The damage from dropping a class out of the serving table is every- // method annotated with it, so the clause reports every method too.- rows := []mcpClassification{- {procedure: "/p", class: v1pb.MCPMethodClass_WRITE},- {procedure: "/q", class: v1pb.MCPMethodClass_READ},- }- require.Equal(t, []string{- "/p: carries WRITE, which has no serving decision",- "WRITE is neither served by a mode nor denied",- }, checkEveryClassHasAServingDecision(rows, map[v1pb.WorkspaceProfileSetting_MCPCapability][]v1pb.MCPMethodClass{- v1pb.WorkspaceProfileSetting_DISABLED: {},- v1pb.WorkspaceProfileSetting_READ_ONLY: {v1pb.MCPMethodClass_READ},- v1pb.WorkspaceProfileSetting_READ_WRITE: {v1pb.MCPMethodClass_READ},- }, mcpDeniedClasses, classes, modes))- })-- t.Run("a ceiling mode with no serving row fails", func(t *testing.T) {- require.Equal(t, []string{"ceiling mode DISABLED does not say which classes it serves"},- checkEveryClassHasAServingDecision(nil, map[v1pb.WorkspaceProfileSetting_MCPCapability][]v1pb.MCPMethodClass{- v1pb.WorkspaceProfileSetting_READ_ONLY: {v1pb.MCPMethodClass_READ},- v1pb.WorkspaceProfileSetting_READ_WRITE: {v1pb.MCPMethodClass_READ, v1pb.MCPMethodClass_WRITE},- }, mcpDeniedClasses, classes, modes))- })-- t.Run("a row carrying an undecided class fails", func(t *testing.T) {- rows := []mcpClassification{{procedure: "/p", class: v1pb.MCPMethodClass(9999)}}- require.Equal(t, []string{"/p: carries 9999, which has no serving decision"},- checkEveryClassHasAServingDecision(rows, mcpServingModes, mcpDeniedClasses, classes, modes))- })-}--// TestForbiddenClassLeavesReadsAlone pins the other half of the second batch's-// ruling, which is the half a later change could quietly widen: the reads of-// the services whose writes were forbidden are not themselves refused. This PR-// classifies most of them EXCLUDED — identity and credential administration —-// which is a scope decision a future admin-capable ceiling can revisit. What-// they must never become is FORBIDDEN, and that is what this pins.-//-// They carry no credential. Every identity-provider read goes through the one-// conversion that blanks the client secret and the LDAP bind password-// (idp_service.go, three "SECURITY: We do not expose" lines), service-account-// reads never populate ServiceKey (only create and the rotation branch do), and-// workload-identity reads return issuer, audience and subject pattern —-// configuration, not a secret. ListIdentityProviders is additionally-// allow_without_credential, the endpoint the login page calls unauthenticated,-// so forbidding it would cost an agent legitimate work while protecting nothing-// an anonymous client could not already read.-func TestForbiddenClassLeavesReadsAlone(t *testing.T) {- got := forbiddenProceduresFromDescriptors(t)- for _, procedure := range []string{- v1connect.IdentityProviderServiceGetIdentityProviderProcedure,- v1connect.IdentityProviderServiceListIdentityProvidersProcedure,- v1connect.WorkloadIdentityServiceGetWorkloadIdentityProcedure,- v1connect.WorkloadIdentityServiceListWorkloadIdentitiesProcedure,- v1connect.ServiceAccountServiceGetServiceAccountProcedure,- v1connect.ServiceAccountServiceListServiceAccountsProcedure,- } {- require.NotContains(t, got, procedure,- "%s is a read that carries no credential; forbidding it is scope this batch did not take", procedure)- }-}--// TestExcludedOnlyForALeak pins the population that is excluded for a defect-// rather than for what the method is. Every row here is an ordinary read that-// belongs in a serving class on its merits, and is out only because its-// response carries a stored secret the product already redacts elsewhere. The-// leak is the thing to fix; when one is fixed its row leaves this test and-// becomes READ, which is a reviewed widening rather than a silent one.-//-// Each entry names the leak and the redaction that closes it:-//-// - The four project reads share convertToProject-// (project_service_converter.go:264), which copies the incoming-webhook URL-// out verbatim. That URL is a bearer credential — whoever holds it posts-// into the customer's Slack, Feishu, WeCom or Teams as Bytebase — and this-// repo already treats it as one: redactWebhook masks it in audit rows-// (audit.go:914) beside the OIDC client secret and the LDAP bind password.-// ListProjects pages the whole workspace, so one call takes the lot.-//-// - The two instance reads and ListInstanceRoles share InstanceRole.Attribute-// (instance_service_converter.go:57), which is the raw SHOW GRANTS text the-// MySQL driver stores (plugin/db/mysql/role.go:38). On MariaDB that text-// carries "IDENTIFIED BY PASSWORD '<hash>'", so the response hands over-// every database account's password hash. The data-source half of the very-// same converter gets this right and says so: "We don't return the password-// and SSLs on reads" (instance_service_converter.go:253).-//-// - GetCurrentUser returns temp_otp_secret and temp_recovery_codes whenever-// the subject is the caller (user_service.go:742), so a session reading its-// own profile during an MFA-setup window captures the TOTP seed. The window-// is opened by the human in the console, not by the agent — UpdateUser,-// which starts it, is FORBIDDEN — which makes this the narrowest of the-// three and still a stored secret in a response body.-func TestExcludedOnlyForALeak(t *testing.T) {- want := []string{- v1connect.ProjectServiceGetProjectProcedure,- v1connect.ProjectServiceListProjectsProcedure,- v1connect.ProjectServiceBatchGetProjectsProcedure,- v1connect.ProjectServiceSearchProjectsProcedure,- v1connect.InstanceServiceGetInstanceProcedure,- v1connect.InstanceServiceListInstancesProcedure,- v1connect.InstanceRoleServiceListInstanceRolesProcedure,- v1connect.UserServiceGetCurrentUserProcedure,- }- var got []string- for _, row := range mcpClassificationsFromDescriptors(t) {- if row.exclusionReason == v1pb.MCPExclusionReason_RETURNS_A_STORED_SECRET {- got = append(got, row.procedure)- }- }- slices.Sort(want)- slices.Sort(got)- require.Equal(t, want, got,- "this population is excluded for a leak, not for what the method is; adding or removing one is a deliberate decision")-}--// TestDeprecatedSQLServiceAliasesMatchTheirCanonicalMethod pins the three-// query-history RPCs that SQLService still carries as deprecated aliases of-// QueryHistoryService. They have no HTTP binding, but the MCP surface indexes-// every POST path in its generated spec (mcp/openapi_index.go), so call_api-// resolves them by operation ID. An alias classified more permissively than the-// method it forwards to is a straight bypass of that method's classification.-func TestDeprecatedSQLServiceAliasesMatchTheirCanonicalMethod(t *testing.T) {- class := map[string]v1pb.MCPMethodClass{}- for _, row := range mcpClassificationsFromDescriptors(t) {- class[row.procedure] = row.class- }- for alias, canonical := range map[string]string{- v1connect.SQLServiceListQueryHistoriesProcedure: v1connect.QueryHistoryServiceListQueryHistoriesProcedure,- v1connect.SQLServiceGetQueryHistoryProcedure: v1connect.QueryHistoryServiceGetQueryHistoryProcedure,- v1connect.SQLServiceSearchQueryHistoriesProcedure: v1connect.QueryHistoryServiceSearchQueryHistoriesProcedure,- } {- require.Equal(t, class[canonical], class[alias],- "%s is a deprecated alias of %s and must not be reachable where the canonical method is not", alias, canonical)- }-}--// mcpInventoryPath holds a rendering of the annotations, committed so a-// reviewer can read the whole classification as one table instead of across-// thirty proto files. It is a rendering and not the source of truth: the-// annotations are, this file is regenerated from them, and nothing reads it at-// runtime.-const mcpInventoryPath = "testdata/mcp_method_classification.md"--const mcpInventoryRegenerate = "MCP_INVENTORY=write go test ./backend/api/v1/ -run TestMCPClassificationInventory"--func renderMCPInventory(rows []mcpClassification) string {- var b strings.Builder- b.WriteString("# MCP method classification\n\n")- b.WriteString("Rendered from the `bytebase.v1.mcp_method_class`, `mcp_forbidden_reason` and\n")- b.WriteString("`mcp_exclusion_reason` annotations on the v1 RPCs. The annotations are the source of\n")- b.WriteString("truth; this file is a reviewable view of them and nothing reads it at runtime.\n\n")- b.WriteString("Regenerate with:\n\n```\n" + mcpInventoryRegenerate + "\n```\n\n")- b.WriteString("Only FORBIDDEN is enforced today. READ, WRITE and EXCLUDED record where a method\n")- b.WriteString("belongs; the gate that acts on them is a later change.\n\n")-- counts := map[v1pb.MCPMethodClass]int{}- for _, row := range rows {- counts[row.class]++- }- b.WriteString("| Class | Methods | Meaning |\n|---|---|---|\n")- for _, line := range []struct {- class v1pb.MCPMethodClass- meaning string- }{- {v1pb.MCPMethodClass_READ, "served to a read-only session and above"},- {v1pb.MCPMethodClass_WRITE, "served to a read-write session only"},- {v1pb.MCPMethodClass_EXCLUDED, "served by no mode this phase ships"},- {v1pb.MCPMethodClass_FORBIDDEN, "never served, enforced today"},- {v1pb.MCPMethodClass_MCP_METHOD_CLASS_UNSPECIFIED, "unclassified — CI rejects this"},- } {- fmt.Fprintf(&b, "| %v | %d | %s |\n", line.class, counts[line.class], line.meaning)- }- fmt.Fprintf(&b, "| **total** | **%d** | |\n\n", len(rows))-- b.WriteString("| Method | Class | Reason | Permission |\n|---|---|---|---|\n")- for _, row := range rows {- reason := ""- switch row.class {- case v1pb.MCPMethodClass_FORBIDDEN:- reason = row.forbiddenReason.String()- case v1pb.MCPMethodClass_EXCLUDED:- reason = row.exclusionReason.String()- default:- }- permission := row.permission- if permission == "" {- permission = "—"- }- if reason == "" {- reason = "—"- }- fmt.Fprintf(&b, "| %s | %v | %s | %s |\n",- strings.TrimPrefix(row.procedure, "/bytebase.v1."), row.class, reason, permission)- }- return b.String()-}--// TestMCPClassificationInventory keeps the committed rendering in step with the-// annotations. It fails on a stale file rather than regenerating silently, so a-// classification change shows up in the diff a reviewer reads.-func TestMCPClassificationInventory(t *testing.T) {- rendered := renderMCPInventory(mcpClassificationsFromDescriptors(t))- if os.Getenv("MCP_INVENTORY") == "write" {- require.NoError(t, os.WriteFile(mcpInventoryPath, []byte(rendered), 0o600))- return- }- committed, err := os.ReadFile(mcpInventoryPath)- require.NoError(t, err)- require.Equal(t, string(committed), rendered, "the inventory is stale; regenerate with: %s", mcpInventoryRegenerate)-}--// TestInternalMCPForbiddenInterceptor pins what the interceptor does with a-// classification once the auth interceptor has resolved one.-func TestInternalMCPForbiddenInterceptor(t *testing.T) {- interceptor := NewInternalMCPForbiddenInterceptor()-- invoke := func(ctx context.Context, procedure string) (bool, error) {- dispatched := false- next := func(_ context.Context, _ connect.AnyRequest) (connect.AnyResponse, error) {- dispatched = true- return connect.NewResponse(&v1pb.User{}), nil- }- req := &specRequest{- AnyRequest: connect.NewRequest(&v1pb.GetUserRequest{}),- procedure: procedure,- }- _, err := interceptor.WrapUnary(next)(ctx, req)- return dispatched, err- }- withClass := func(class v1pb.MCPMethodClass, reason v1pb.MCPForbiddenReason) context.Context {- return context.WithValue(context.Background(), common.AuthContextKey,- &common.AuthContext{MCPMethodClass: class, MCPForbiddenReason: reason})- }-- for procedure, reason := range forbiddenProceduresFromDescriptors(t) {- t.Run(procedure, func(t *testing.T) {- dispatched, err := invoke(withClass(v1pb.MCPMethodClass_FORBIDDEN, reason), procedure)- require.Error(t, err, "a FORBIDDEN method must never reach its handler")- require.False(t, dispatched, "the denial must happen before dispatch, so no handler side effect can land")- require.Equal(t, connect.CodePermissionDenied, connect.CodeOf(err))- require.Contains(t, err.Error(), procedure, "the message must name the method the agent called")- require.Contains(t, err.Error(), mcpForbiddenReasons[reason],- "the message must name why, so the agent can act on it")- })- }-- // A method classified FORBIDDEN whose reason this build does not recognize- // is still refused — the class is what denies, and the wording degrades to- // the generic sentence rather than the denial degrading to nothing. This is- // the rolling-upgrade case: an old replica meeting a reason value added- // after it was built.- t.Run("unknown reason still denies", func(t *testing.T) {- dispatched, err := invoke(withClass(v1pb.MCPMethodClass_FORBIDDEN, v1pb.MCPForbiddenReason(9999)),- v1connect.AuthServiceLoginProcedure)- require.Error(t, err)- require.False(t, dispatched)- require.Equal(t, connect.CodePermissionDenied, connect.CodeOf(err))- require.Contains(t, err.Error(), reasonForbiddenClass)- })-- // Only FORBIDDEN is enforced in this phase, so every other class still- // dispatches. EXCLUDED is the one that most looks like a denial and is not- // one yet — it is the largest class, and it covers methods the console and- // the API serve today — so a later change to the condition above that turned- // it into a serving-class allowlist would silently deny them. UNSPECIFIED- // reaches here only in a build that has not been linted; it is served, as- // before.- for name, class := range map[string]v1pb.MCPMethodClass{- "unclassified": v1pb.MCPMethodClass_MCP_METHOD_CLASS_UNSPECIFIED,- "read": v1pb.MCPMethodClass_READ,- "write": v1pb.MCPMethodClass_WRITE,- "excluded": v1pb.MCPMethodClass_EXCLUDED,- } {- t.Run("dispatched: "+name, func(t *testing.T) {- dispatched, err := invoke(- withClass(class, v1pb.MCPForbiddenReason_MCP_FORBIDDEN_REASON_UNSPECIFIED),- v1connect.UserServiceGetUserProcedure)- require.NoError(t, err)- require.True(t, dispatched)- })- }-- t.Run("no auth context fails closed", func(t *testing.T) {- dispatched, err := invoke(context.Background(), v1connect.AuthServiceLoginProcedure)- require.Error(t, err, "without a resolved classification the interceptor must not guess")- require.False(t, dispatched)- require.Equal(t, connect.CodeInternal, connect.CodeOf(err))- })-}diff --git a/backend/api/v1/mcp_gate.go b/backend/api/v1/mcp_gate.gonew file mode 100644index 0000000000..75dde2d0f4--- /dev/null+++ b/backend/api/v1/mcp_gate.go@@ -0,0 +1,571 @@+package v1++import (+ "context"+ "fmt"+ "log/slog"+ "slices"+ "strings"++ "connectrpc.com/connect"+ "github.com/pkg/errors"++ "github.com/bytebase/bytebase/backend/common"+ "github.com/bytebase/bytebase/backend/common/log"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"+ "github.com/bytebase/bytebase/backend/generated-go/v1/v1connect"+ "github.com/bytebase/bytebase/backend/store"+)++// mcpDenialWording is one reason's sentence plus the class it belongs to. The+// class is carried here because a reason implies one — a mechanism that breaks+// the MCP boundary is what FORBIDDEN means, a scope decision is what EXCLUDED+// means — and one table saying so is what lets the lint check the pairing and+// the gate refuse to print the wrong half of it.+type mcpDenialWording struct {+ class v1pb.MCPMethodClass+ sentence string+}++// mcpDenialReasons is UX copy, NOT the classification and NOT the mapping.+// Both of those live on the RPC itself, as the bytebase.v1.mcp_method_class and+// bytebase.v1.mcp_denial_reason annotations, beside permission / audit /+// auth_method — one source of truth, visible where the RPC is defined, and read+// here off the AuthContext the auth interceptor already resolves. This table+// only turns a reason into a sentence the agent can act on, so it has one row+// per mechanism rather than one per method, and a missing row costs wording,+// never enforcement.+//+// Each sentence completes "<procedure> is not available to MCP sessions because+// ___", so it states what the method does rather than merely that it is+// refused: a denial whose stated reason has drifted from the mechanism is worse+// than a bare refusal, because it is the thing the next reader trusts.+var mcpDenialReasons = map[v1pb.MCPDenialReason]mcpDenialWording{+ // The method hands a token back to the caller. For a non-web caller — and+ // an MCP session is always one — finalizeLogin and switchWorkspaceInternal+ // put a plain bb.user.access token in the response body. That token is not+ // audience-bound to the MCP resource, survives revocation of the OAuth+ // grant, and ignores the workspace MCP kill switch, so obtaining one ends+ // the MCP boundary for good.+ v1pb.MCPDenialReason_MINTS_CREDENTIAL: {v1pb.MCPMethodClass_FORBIDDEN, "it hands back a login token that would outlive the MCP grant"},++ // The method drives the out-of-band reset flow — mailing a reset or login+ // code, or consuming one — that sets or delivers the very secret Login+ // accepts. Denying Login alone would leave the agent holding the credential+ // for the next human login.+ v1pb.MCPDenialReason_RESETS_CREDENTIAL: {v1pb.MCPMethodClass_FORBIDDEN, "it drives the credential-reset flow that sets or delivers the secret a login accepts"},++ // UpdateUser's password and MFA branches take no proof of the old password.+ // A caller updating itself needs no permission at all, and on self-hosted a+ // caller holding bb.users.update reaches any other end user's password too+ // (user_service.go: the caller != subject branch checks that permission and+ // nothing further). Either way the session ends up holding credentials it+ // can log in with. The whole method is refused, not just those branches —+ // the classification is per method.+ v1pb.MCPDenialReason_TAKES_OVER_ACCOUNT: {v1pb.MCPMethodClass_FORBIDDEN, "it can rewrite an account's credentials, which would let the session take that account over"},++ // Logout deletes the web refresh token and expires the session cookies. It+ // mints nothing; it destroys the human's own login session, which an agent+ // acting on their behalf has no business doing.+ v1pb.MCPDenialReason_ENDS_SESSION: {v1pb.MCPMethodClass_FORBIDDEN, "it ends the human's own login session"},++ // The workspace-lifecycle pair. Both end in+ // AuthService.switchWorkspaceInternal, which mints a plain workspace token+ // whenever the caller has no refresh cookie — and an MCP session never has+ // one — after having already destroyed the caller's membership.+ v1pb.MCPDenialReason_ENDS_MEMBERSHIP: {v1pb.MCPMethodClass_FORBIDDEN, "it destroys the caller's own workspace membership and mints a plain workspace token"},++ // The method leaves someone holding a principal the caller is not. Four+ // ways, all of them annotated:+ // - issuing the credential outright — a service key or SCIM token+ // returned in plaintext, a caller-chosen password on a new account;+ // - carrying an existing one out — a stored client secret or SMTP+ // password sent to a host the caller named;+ // - choosing what will later be trusted to mint one — the issuer and+ // subject ExchangeToken validates against;+ // - redirecting where one gets delivered — UpdateEmail rebinds any+ // account to an address the caller picked, and the reset flow mails the+ // code to whatever address the account then carries.+ // The levers that contain a runaway session all act on the caller's own+ // principal: revoke the OAuth grant, flip the workspace MCP switch,+ // deactivate the human. None of them reaches a principal that was never the+ // caller's, so what these give away outlives all three.+ //+ // InstanceService/UpdateDataSource is the same "carry an existing one out"+ // shape as the two Test methods, against the database's credentials rather+ // than Bytebase's own: it merges a partial request onto the STORED,+ // already-decrypted data source, so an update_mask naming only a+ // destination field (host, port, ssh_host, additional_addresses,+ // sasl_config.kdc_host) keeps the stored password, ssl_key and+ // ssh_private_key. With validate_only it dials the caller's host+ // immediately and persists nothing; without it the retarget is written and+ // SyncInstance triggers the connection on demand. No allowlist filters the+ // host on either path. A database user is a principal other than the+ // caller, the same way the SMTP account behind TestEmailSetting is.+ //+ // Its siblings are NOT here and the line is severity, not tidiness:+ // UpdateInstance and BatchUpdateInstances rebuild the data-source list+ // wholesale, so every secret is wiped unless resent — except the Kerberos+ // keytab, which retainStoredKeytabs used to inherit by data-source ID.+ // That narrower, persist-only version of the vector is now closed at the+ // retention rule instead of at reachability: a keytab is not inherited to+ // a destination the caller moved (instance_service_converter.go). It costs+ // an agent no instance management, something no one has yet decided it+ // should lose, and it binds human callers too — a Kerberos host edit now+ // asks for the keytab again, on the console as much as on the API.+ // The keytab is the ONLY secret that rule reaches, because it is the only+ // one those two methods inherit. On UpdateDataSource above, every other+ // stored secret still rides an update_mask that names only a destination,+ // which is why that method is refused here rather than fixed there:+ // requiring a password re-supplied on every host edit is a product call.+ // AddDataSource and CreateInstance also dial on validate_only but build+ // the data source entirely from the request, so they carry no stored+ // secret and are not this class. BOT-57.+ //+ // The Undelete* family (user, service account, workload identity) is+ // deliberately NOT in this group, and it is the nearest thing left out, so+ // the reasoning is recorded rather than left to be rediscovered. It+ // restores a principal whose password or key hash survived the soft+ // delete, so an operator's deactivation is undone. It is out because the+ // caller learns and chooses nothing: the credential goes back to whoever+ // already had it, and a second delete takes it away again. Issuing beats+ // re-arming, and this mechanism is about issuing. BOT-54.+ v1pb.MCPDenialReason_MINTS_CREDENTIAL_FOR_OTHERS: {v1pb.MCPMethodClass_FORBIDDEN, "it hands someone control of a principal other than the caller, which revoking this session would not take back"},++ // SettingService/UpdateSetting, refused for the boundary it rewrites+ // rather than for any credential it hands out. Three mask paths carry it:+ // value.workspace_profile.mcp_capability IS the MCP ceiling, so a session+ // that reaches it is not bounded by it; value.email.smtp keeps the+ // stored password when the request omits it while accepting a new host,+ // which hands over the relay resolvePreLoginEmailSetting reads to mail+ // password resets and login codes; and value.ai.endpoint does the same to+ // the AI key it never names — the stored api_key survives the mask, and the+ // next AIService/Chat puts it in an auth header to the host just written+ // (ai_service.go). SaaS refuses AI writes outright (setting_service.go), so+ // that third one is a self-hosted vector, and the key it carries out is+ // whatever the operator configured — GEMINI_API_KEY, where it is set, seeds+ // one key into every workspace created after it (getAdditionalWorkspaceSettings).+ // TestEmailSetting is the one-shot version of the second; this is the+ // persisting one. The same method also writes the SSO domain allowlist and+ // the sign-in switches.+ //+ // Classification is per method, so this refuses the whole RPC — including+ // the settings that have nothing to do with any of them. Splitting the+ // handler so ordinary configuration stays reachable to an agent is the+ // follow-up (BOT-53); disallowing first is the deliberate order.+ v1pb.MCPDenialReason_REWRITES_SESSION_BOUNDARY: {v1pb.MCPMethodClass_FORBIDDEN, "it rewrites the workspace settings that bound this session, including the switch meant to contain it"},++ // The four approval methods. ApproveIssue and RejectIssue are two actions of+ // one handler (issue_review.go reviewIssue), and that handler records the+ // review decision itself: applyReviewAction requires an approver role via+ // canReview, enforces the self-approval guard, and appends an APPROVED or+ // REJECTED approver (component/review/workflow.go). An agent composes a+ // change; it does not move its own change through the gate. That is the+ // whole claim,+ // and it is deliberately narrower than "an agent only executes approved work",+ // which this classification does NOT deliver: CreatePlan, CreateRollout and+ // BatchRunTasks are all WRITE, and both approval checks on the execution+ // path are guarded on an issue existing, so a plan created without one+ // reaches execution with no approval at all. Whether an issueless rollout+ // belongs in WRITE is the gate PR's decision to take deliberately rather+ // than inherit.+ //+ // RequestIssue is the third action of the same handler and is deliberately+ // NOT here — it is WRITE. Spec §1b-1 named four approval methods; that line+ // grouped by RPC family rather than by mechanism, and the mechanism does not+ // agree. This action requires the issue to be already rejected, requires the+ // actor to be the issue CREATOR, never calls canReview, and records no+ // decision: it strips the REJECTED approvers and returns the issue to+ // PENDING for a fresh human decision. It cannot approve anything, so+ // refusing it protects nothing the other two do not, and it costs the+ // propose-fix-resubmit loop, since while a rejection stands Approve and+ // Reject both hard-fail and this is the only exit from that state. The+ // reasoning is on the RPC in issue_service.proto. Raised by the Codex+ // review; Vincent took the call.+ //+ // RetryIssueApproval is the near miss and is in deliberately. It casts no+ // vote — it re-runs approval-template finding for an issue stuck in+ // CHECKING, and only the issue creator may call it (issue_service.go+ // canRequestIssue) — but it is the other half of the reason's wording+ // rather than an exception to it: on an auto-approved result the same call+ // activates the grant and enqueues the rollout (issue_service.go:789,796),+ // so it moves an issue through the gate without any human acting. What it+ // does not buy is containment of re-derivation in general: UpdatePlan with+ // a specs mask, and UpdateIssue on a label change, both reset+ // ApprovalFindingDone and force the template to be found again against the+ // current workspace rule (component/review/plan.go, metadata.go), and both+ // stay WRITE. That is the intended line — editing a proposal is the agent's+ // job, and re-review after an edit is the system working — not an oversight.+ // Refusing RetryIssueApproval costs an agent the self-service recovery for+ // its own stuck issue; the operator retries from the console.+ v1pb.MCPDenialReason_DRIVES_THE_APPROVAL_DECISION: {v1pb.MCPMethodClass_FORBIDDEN, "it works the approval step meant to gate the change, and an agent does not move its own change through that gate"},++ // The other refused class. An EXCLUDED method is out of scope for the modes+ // this release ships and an admin-capable ceiling could legitimately serve+ // it one day, while a FORBIDDEN method never becomes servable — so a denial+ // that blurred the two would tell an operator the wrong thing about whether+ // asking is worth it. The class on each row is what keeps them apart.+ v1pb.MCPDenialReason_ADMINISTERS_THE_WORKSPACE: {v1pb.MCPMethodClass_EXCLUDED, "it administers the workspace rather than doing database work, and no MCP mode this release ships covers workspace administration"},+ v1pb.MCPDenialReason_READS_OTHER_USERS_SQL: {v1pb.MCPMethodClass_EXCLUDED, "it returns SQL that other people wrote, across the workspace or past the sharing that keeps a saved query private"},+ v1pb.MCPDenialReason_OPENS_AN_ADMIN_CONNECTION: {v1pb.MCPMethodClass_EXCLUDED, "it opens an admin-credentialed connection to the database and returns other sessions' live, unmasked SQL"},+ v1pb.MCPDenialReason_SENDS_DATA_TO_A_THIRD_PARTY: {v1pb.MCPMethodClass_EXCLUDED, "it spends a stored workspace credential to send whatever the caller passes to a third party"},+ v1pb.MCPDenialReason_RETURNS_A_STORED_SECRET: {v1pb.MCPMethodClass_EXCLUDED, "its response carries a stored secret that the product redacts everywhere else"},+}++// The fallback wording, per class, for a method whose reason is unset, unknown+// to this build, or recorded for the other refused class. The class annotation+// is what denies; the table only supplies a better sentence.+const (+ reasonForbiddenClass = "it is not reachable by an AI agent session"+ reasonExcludedClass = "no MCP mode this release ships serves it"+)++// denialReason is the sentence for this method's recorded reason, or the+// class's fallback.+//+// The class is checked here as well as in the lint, and that is the point of+// carrying it on the row. One enum means a reason recorded for the wrong class+// is a value, not a parse error, so the runtime has to decline it: a FORBIDDEN+// method must never explain itself with an exclusion's sentence. A mismatch+// costs wording, the way a missing row does — never enforcement.+func denialReason(class v1pb.MCPMethodClass, reason v1pb.MCPDenialReason, fallback string) string {+ if wording, ok := mcpDenialReasons[reason]; ok && wording.class == class {+ return wording.sentence+ }+ return fallback+}++// mcpServingClasses is the ceiling: which method classes each stored capability+// serves. It is the whole of what the gate evaluates against the classification,+// and the lint in mcp_gate_test.go holds the annotations against this same+// variable rather than a copy — two copies would let the lint stay green while+// the runtime rules drifted away from it.+//+// It is keyed on the STORE enum because that is what a workspace's setting row+// holds and what the gate reads back; TestMCPCapabilityEnumsAgree pins the v1+// enum the settings API writes against it, so the two cannot drift apart.+//+// DISABLED serves nothing. It is here rather than omitted because a missing key+// and an empty list mean different things to the gate: an empty list is a mode+// that decided to serve nothing, a missing key is a mode nobody decided about,+// and only the first may reach a caller as an ordinary denial.+var mcpServingClasses = map[storepb.WorkspaceProfileSetting_MCPCapability][]v1pb.MCPMethodClass{+ storepb.WorkspaceProfileSetting_DISABLED: {},+ storepb.WorkspaceProfileSetting_READ_ONLY: {v1pb.MCPMethodClass_READ},+ storepb.WorkspaceProfileSetting_READ_WRITE: {v1pb.MCPMethodClass_READ, v1pb.MCPMethodClass_WRITE},+}++// mcpCeilingReader is the whole of what the gate needs from the store: one live+// read of the workspace's ceiling. *store.Store satisfies it; a test supplies+// its own, which is what lets a READ_ONLY ceiling be exercised at all before+// 1b-3 lets one connect. Named for what it does rather than for what satisfies+// it, per the convention for a single-method interface.+type mcpCeilingReader interface {+ GetMCPCapabilityUncached(ctx context.Context, workspace string) (storepb.WorkspaceProfileSetting_MCPCapability, error)+}++// internalMCPGateInterceptor refuses, before dispatch, every request an MCP+// session may not make. The rule is one line — effective = ceiling ∩ RBAC — and+// this interceptor is the ceiling half: it never grants anything, and ACL runs+// after it exactly as before, so a caller still needs the permission for+// whatever the ceiling lets through.+//+// The ceiling admits READ under a read-only workspace ceiling and above,+// READ and WRITE under read-write, and neither EXCLUDED nor FORBIDDEN under any+// ceiling. A method carrying no classification is refused too: CI rejects an+// unannotated RPC, so reaching that arm means the build was never linted, and+// guessing on behalf of an unclassified method is how a new RPC ships+// reachable.+//+// It belongs to the internal MCP chain only — every request there originates at+// /mcp — and sits inside the audit interceptor, outside ACL: the ceiling+// refuses regardless of what RBAC would have said, and the refusal is recorded.+//+// The ceiling is read live, per request, with no caching anywhere in the path+// (store.GetMCPCapabilityUncached). An admin tightening the ceiling binds the+// next request of a session already open; work already admitted finishes.+//+// A policy denial is recorded whatever the method's audit annotation says: the+// gate marks the outcome and the audit interceptor records it (see+// common.SetMCPPolicyDenied). 47 of the 121 refused methods carry no audit+// annotation — the 4 FORBIDDEN ones that were silent before this gate+// (Refresh, SwitchWorkspace, TestIdentityProvider, TestEmailSetting) plus 43+// EXCLUDED ones — and TestEmailSetting and TestIdentityProvider are the rows an+// operator would most want, since each would have carried a stored secret to an+// address the agent chose. Recording requests that were never recorded is why+// getRequestString grew redactors in the same change (audit.go).+//+// A ceiling the gate cannot act on splits in two, and the split is the same one+// the /mcp connection gate makes. A stored value this build cannot interpret —+// a mistyped enum name, a wrong-typed row — is a policy refusal: it will never+// succeed on retry, so it answers CodePermissionDenied and is audited, and the+// connection gate answers 403 for it. A read that FAILED is an outage: it+// answers CodeUnavailable, is not marked as a policy denial, and the connection+// gate answers 503, the same way it already answers 503 rather than 401 when it+// cannot resolve the token audience. Both refuse — an unknown policy never+// permits — and neither is allowed to describe itself as the other.+//+// Two gaps survive this PR, and both are worth knowing because nothing in the+// annotations shows either.+//+// - RequestPasswordReset, ResetPassword and SendEmailLoginCode are+// allow_without_credential, so createAuditLog takes their audit parent ONLY+// from what the handler announced (handlerValidatedWorkspaceMethod,+// audit.go) — an unvalidated workspace on an unauthenticated method would+// let anyone write rows into someone else's. This gate refuses before+// dispatch, so the handler never runs and no parent is ever set. Their+// denials are still silent, TestMCPResetFlowDenialsAreSilent pins that they+// are, and closing it means letting the audit path trust the workspace of+// the delegated credential the internal chain already verified.+//+// - Two refusals this gate is the right slot for the CLASS of, but not the+// right place for the decision, because the fact they turn on is not in the+// request. Both are guarded at the point where the fact is loaded, and both+// key on the delegated grant so the console is untouched:+// rejectMCPOriginatedGrantIssue (issue_service.go), for the issue types+// that complete into a permission grant, and+// rejectMCPOriginatedIssuelessRollout (rollout_service.go), for the+// issueless plan that reaches execution without ever meeting the approval+// the three FORBIDDEN approval methods exist to protect. Without the+// second, those three are decorative in the change lane: an agent that+// cannot clear the gate could skip it instead. The gate keeps the half it+// can decide — CreateIssue, where the request shape IS the whole story —+// so the denial still lands before dispatch wherever that is possible.+type internalMCPGateInterceptor struct {+ store mcpCeilingReader+}++// NewInternalMCPGateInterceptor returns the MCP ceiling gate for the internal+// chain. See internalMCPGateInterceptor for what it enforces.+func NewInternalMCPGateInterceptor(stores mcpCeilingReader) connect.Interceptor {+ return &internalMCPGateInterceptor{store: stores}+}++func (in *internalMCPGateInterceptor) WrapUnary(next connect.UnaryFunc) connect.UnaryFunc {+ return func(ctx context.Context, req connect.AnyRequest) (connect.AnyResponse, error) {+ policyDenial, err := in.refuse(ctx, req)+ if err == nil {+ return next(ctx, req)+ }+ if policyDenial {+ // Record the refusal before returning it: the audit interceptor+ // wraps this one and reads the mark when the request comes back+ // out. Only a verdict about the caller is marked — an unreadable+ // ceiling and a broken chain are not policy denials.+ common.SetMCPPolicyDenied(ctx)+ }+ return nil, err+ }+}++// WrapStreamingClient is a pass-through: the gate guards inbound handlers.+func (*internalMCPGateInterceptor) WrapStreamingClient(next connect.StreamingClientFunc) connect.StreamingClientFunc {+ return func(ctx context.Context, spec connect.Spec) connect.StreamingClientConn {+ return next(ctx, spec)+ }+}++// WrapStreamingHandler refuses outright. The gate's rule is per method and its+// classification vocabulary covers streaming RPCs too, but a streaming handler+// gets no request message, so the request-shape half of the rule cannot run —+// and the one streaming v1 RPC, SQLService/AdminExecute, is EXCLUDED anyway+// (it opens an admin connection to the customer's database). Refusing every+// stream keeps "every class is enforced at the gate" true without depending on+// the auth interceptor, which also refuses streams on this chain, continuing to+// do so.+func (*internalMCPGateInterceptor) WrapStreamingHandler(connect.StreamingHandlerFunc) connect.StreamingHandlerFunc {+ return func(_ context.Context, conn connect.StreamingHandlerConn) error {+ return connect.NewError(connect.CodePermissionDenied, errors.Errorf(+ "%s is not available to MCP sessions: no streaming RPC is served on the MCP transport",+ conn.Spec().Procedure))+ }+}++// refuse returns the error the gate refuses this request with, or nil to let it+// through to ACL. The bool reports whether the refusal is a verdict about the+// caller, which is an audited outcome; an infrastructure failure is not.+func (in *internalMCPGateInterceptor) refuse(ctx context.Context, req connect.AnyRequest) (bool, error) {+ procedure := req.Spec().Procedure+ authCtx, ok := common.GetAuthContextFromContext(ctx)+ if !ok {+ // The auth interceptor runs first and always sets this. Its absence+ // means the chain was reordered, and guessing which class a method is+ // in is exactly the wrong response.+ return false, connect.NewError(connect.CodeInternal,+ errors.New("MCP method classification unavailable: no auth context"))+ }++ switch authCtx.MCPMethodClass {+ case v1pb.MCPMethodClass_FORBIDDEN:+ return true, connect.NewError(connect.CodePermissionDenied, errors.Errorf(+ "%s is not available to MCP sessions because %s. Perform this action signed in to the Bytebase console instead",+ procedure, denialReason(authCtx.MCPMethodClass, authCtx.MCPDenialReason, reasonForbiddenClass)))+ case v1pb.MCPMethodClass_EXCLUDED:+ return true, connect.NewError(connect.CodePermissionDenied, errors.Errorf(+ "%s is served by no MCP capability ceiling because %s. Perform this action signed in to the Bytebase console instead",+ procedure, denialReason(authCtx.MCPMethodClass, authCtx.MCPDenialReason, reasonExcludedClass)))+ case v1pb.MCPMethodClass_READ, v1pb.MCPMethodClass_WRITE:+ default:+ return true, connect.NewError(connect.CodePermissionDenied, errors.Errorf(+ "%s carries no MCP classification, so no MCP session may call it", procedure))+ }++ if policyDenial, err := in.refuseByCeiling(ctx, procedure, authCtx.MCPMethodClass); err != nil {+ return policyDenial, err+ }+ if err := refuseByRequestShape(procedure, req.Any()); err != nil {+ return true, err+ }+ return false, nil+}++// refuseByCeiling holds the method's class against the workspace's live+// ceiling.+func (in *internalMCPGateInterceptor) refuseByCeiling(ctx context.Context, procedure string, class v1pb.MCPMethodClass) (bool, error) {+ // The internal auth interceptor puts the delegated credential's workspace+ // on every request it admits, so an empty one means the chain was+ // reordered — a bug in this process, not an outage, and not a verdict+ // about the caller.+ workspaceID := common.GetWorkspaceIDFromContext(ctx)+ if workspaceID == "" {+ return false, connect.NewError(connect.CodeInternal, errors.Errorf(+ "%s cannot be checked against the MCP capability ceiling: no workspace on the request", procedure))+ }+ // The store applies the backward-compatible default for a workspace that+ // never set a ceiling and reports everything it cannot make sense of as an+ // error.+ ceiling, err := in.store.GetMCPCapabilityUncached(ctx, workspaceID)+ if err != nil {+ // The agent gets no detail either way: the error text can carry the+ // workspace's storage state. What it does get is the right KIND of+ // answer, because the two failures are opposites for a client. A+ // stored value this build cannot interpret will never succeed on+ // retry — an admin has to rewrite it — so it is a policy refusal and+ // an audited one. A read that failed is an outage, so it is+ // retryable and is not a verdict about the caller. The /mcp+ // connection gate splits the same two the same way.+ slog.Warn("failed to resolve the MCP capability ceiling; refusing the request",+ slog.String("method", procedure), slog.String("workspace", workspaceID), log.BBError(err))+ if errors.Is(err, store.ErrMCPCapabilityUnreadable) {+ return true, connect.NewError(connect.CodePermissionDenied, errors.Errorf(+ "%s is refused: this workspace's stored MCP capability ceiling is not one this build understands, "++ "so the request fails closed. Ask a workspace admin to set the MCP ceiling again in the workspace settings",+ procedure))+ }+ return false, connect.NewError(connect.CodeUnavailable, errors.Errorf(+ "%s is refused: this workspace's MCP capability ceiling could not be read, so the request fails closed. "++ "Retry shortly; if it persists, a workspace admin must check the workspace MCP settings",+ procedure))+ }+ served, known := mcpServingClasses[ceiling]+ if !known {+ return true, connect.NewError(connect.CodePermissionDenied, errors.Errorf(+ "%s is refused: this workspace's stored MCP capability ceiling %v is not one this build serves. "++ "Ask a workspace admin to set the MCP ceiling to a supported value in the workspace settings",+ procedure, ceiling))+ }+ if slices.Contains(served, class) {+ return false, nil+ }+ return true, connect.NewError(connect.CodePermissionDenied, errors.Errorf(+ "%s is a %v method and this workspace's MCP capability ceiling is %v, which serves %s. "++ "Ask a workspace admin to raise the MCP ceiling in the workspace settings, "++ "or perform this action signed in to the Bytebase console instead",+ procedure, class, ceiling, describeServedClasses(served)))+}++// describeServedClasses renders a mode's serving list for a denial message.+func describeServedClasses(served []v1pb.MCPMethodClass) string {+ if len(served) == 0 {+ return "no method"+ }+ names := make([]string, 0, len(served))+ for _, class := range served {+ names = append(names, class.String())+ }+ return strings.Join(names, " and ") + " methods"+}++// mcpRequestShapeRefusals holds the refusals a per-method class cannot express,+// because what the call does depends on a field of the request rather than on+// which method it is. Each entry returns the reason to refuse for, or "" to+// allow.+//+// This lives inside the gate rather than beside it. The decision is the same+// decision — may this MCP session make this call? — and it has to be taken at+// the same point in the chain, so that the denial is recorded the same way, is+// worded the same way, and reaches the caller before any handler side effect+// can land. A second interceptor would duplicate the slot, the message, and the+// audit mark to serve one method, and it would put the exception somewhere the+// next person reading the class rule would not find it.+//+// The table is deliberately small and expected to stay that way. A method that+// needs one is a method whose class annotation is not the whole truth, and the+// better fix is usually to split the RPC.+var mcpRequestShapeRefusals = map[string]func(msg any) string{+ v1connect.IssueServiceCreateIssueProcedure: refuseGrantIssueCreation,+}++// refuseByRequestShape applies the table above.+func refuseByRequestShape(procedure string, msg any) error {+ refuse, ok := mcpRequestShapeRefusals[procedure]+ if !ok {+ return nil+ }+ reason := refuse(msg)+ if reason == "" {+ return nil+ }+ return connect.NewError(connect.CodePermissionDenied, errors.Errorf(+ "%s is not available to MCP sessions for this request because %s. "++ "Perform this action signed in to the Bytebase console instead", procedure, reason))+}++// refuseGrantIssueCreation is the CreateIssue carve-out. CreateIssue is WRITE+// for the database-change issue it exists for, and an agent composing a change+// is the whole point of the MCP surface. A ROLE_GRANT issue is a different+// method wearing the same name: it completes on creation whenever the workspace+// approval rule produces no template, and completing it writes the project IAM+// binding for whichever grantee the request names — which is+// ProjectService/SetIamPolicy, EXCLUDED for exactly that outcome. The session+// ends up granting access with no human step.+//+// It is an allow-list of the type the class covers, not a deny-list of the ones+// that reach past it. A deny-list would silently admit the next issue type+// somebody adds, and adding an issue type is not where anyone would think to+// re-read the MCP ceiling. ACCESS_GRANT is refused by that allow-list and never+// reaches the handler in the first place: buildIssueMessage has no arm for it,+// so the type is an invalid argument there, and those issues are written by+// AccessGrantService/CreateAccessGrant, which is EXCLUDED.+//+// An unset type is NOT refused: nothing can be created from it, since+// buildIssueMessage's default arm rejects an unspecified type as an invalid+// argument, so refusing it here would protect nothing and would answer a+// mechanism that does not apply.+//+// UpdateIssue is deliberately NOT in this table, and the reason is the limit of+// what a request shape can decide. allow_missing makes UpdateIssue create the+// issue — but only when it does not already exist, which is not a field of the+// request. An AIP upsert sends the complete resource, so a caller PATCHing an+// existing ROLE_GRANT issue carries type=ROLE_GRANT in a body the handler+// ignores, and refusing on that would refuse an ordinary edit for a mechanism+// that is not running. The creation it really does reach is guarded where the+// creation happens instead: rejectMCPOriginatedGrantIssue in issue_service.go.+func refuseGrantIssueCreation(msg any) string {+ request, ok := msg.(*v1pb.CreateIssueRequest)+ if !ok {+ // The table is keyed by procedure, so the request type is fixed. A+ // mismatch is a wiring bug, and a wiring bug on a refusal path fails+ // closed.+ return fmt.Sprintf("its request could not be read as an issue (%T)", msg)+ }+ switch request.GetIssue().GetType() {+ case v1pb.Issue_DATABASE_CHANGE, v1pb.Issue_TYPE_UNSPECIFIED:+ return ""+ default:+ return fmt.Sprintf(+ "a %v issue completes on creation whenever the workspace approval rule produces no template, "++ "which grants access with no human step", request.GetIssue().GetType())+ }+}diff --git a/backend/api/v1/mcp_gate_test.go b/backend/api/v1/mcp_gate_test.gonew file mode 100644index 0000000000..cc1b3b3275--- /dev/null+++ b/backend/api/v1/mcp_gate_test.go@@ -0,0 +1,1499 @@+package v1++import (+ "context"+ "fmt"+ "os"+ "slices"+ "strings"+ "testing"++ "connectrpc.com/connect"+ "github.com/pkg/errors"+ "github.com/stretchr/testify/require"+ "google.golang.org/protobuf/proto"+ "google.golang.org/protobuf/reflect/protoreflect"+ "google.golang.org/protobuf/reflect/protoregistry"++ "github.com/bytebase/bytebase/backend/api/auth"+ "github.com/bytebase/bytebase/backend/common"+ "github.com/bytebase/bytebase/backend/component/config"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"+ "github.com/bytebase/bytebase/backend/generated-go/v1/v1connect"+ "github.com/bytebase/bytebase/backend/store"+)++// mcpClassification is one v1 RPC's MCP annotations, as the compiled+// descriptors carry them.+type mcpClassification struct {+ procedure string+ class v1pb.MCPMethodClass+ reason v1pb.MCPDenialReason+ permission string+ audit bool+ // request is the method's input descriptor, which the redaction lint+ // below reads to see what a denial would write into an audit row.+ request protoreflect.MessageDescriptor+}++// mcpClassificationsFromDescriptors reads every v1 RPC's classification off the+// compiled descriptors — the same place getAuthContext reads it — so everything+// below is asserted against the annotations themselves, not against a Go copy+// of them that could agree with itself while the protos say otherwise. It only+// reads; the judgments live in the check functions, which take the rows as an+// argument so a deliberately broken copy can be fed to the same code.+func mcpClassificationsFromDescriptors(t *testing.T) []mcpClassification {+ t.Helper()+ var rows []mcpClassification+ protoregistry.GlobalFiles.RangeFiles(func(fd protoreflect.FileDescriptor) bool {+ if fd.Package() != "bytebase.v1" {+ return true+ }+ services := fd.Services()+ for i := range services.Len() {+ sd := services.Get(i)+ methods := sd.Methods()+ for j := range methods.Len() {+ md := methods.Get(j)+ class, ok := proto.GetExtension(md.Options(), v1pb.E_McpMethodClass).(v1pb.MCPMethodClass)+ require.True(t, ok, "method %s carries a malformed mcp_method_class", md.FullName())+ reason, ok := proto.GetExtension(md.Options(), v1pb.E_McpDenialReason).(v1pb.MCPDenialReason)+ require.True(t, ok, "method %s carries a malformed mcp_denial_reason", md.FullName())+ permission, ok := proto.GetExtension(md.Options(), v1pb.E_Permission).(string)+ require.True(t, ok, "method %s carries a malformed permission", md.FullName())+ audit, ok := proto.GetExtension(md.Options(), v1pb.E_Audit).(bool)+ require.True(t, ok, "method %s carries a malformed audit annotation", md.FullName())+ rows = append(rows, mcpClassification{+ procedure: fmt.Sprintf("/%s/%s", sd.FullName(), md.Name()),+ class: class,+ reason: reason,+ permission: permission,+ audit: audit,+ request: md.Input(),+ })+ }+ }+ return true+ })+ slices.SortFunc(rows, func(a, b mcpClassification) int { return strings.Compare(a.procedure, b.procedure) })+ return rows+}++// forbiddenProceduresFromDescriptors narrows the classification to the+// FORBIDDEN set, whose membership several assertions below pin. The gate+// enforces every class, not this one — its own doc owns that claim.+func forbiddenProceduresFromDescriptors(t *testing.T) map[string]v1pb.MCPDenialReason {+ t.Helper()+ found := map[string]v1pb.MCPDenialReason{}+ for _, row := range mcpClassificationsFromDescriptors(t) {+ if row.class == v1pb.MCPMethodClass_FORBIDDEN {+ found[row.procedure] = row.reason+ }+ }+ return found+}++// TestForbiddenClassMembership pins which RPCs are annotated FORBIDDEN.+// Membership is a security decision, so adding or removing one has to be+// deliberate: this list is the second signature on that decision.+func TestForbiddenClassMembership(t *testing.T) {+ want := []string{+ v1connect.AuthServiceLoginProcedure,+ v1connect.AuthServiceSignupProcedure,+ v1connect.AuthServiceExchangeTokenProcedure,+ v1connect.AuthServiceRefreshProcedure,+ v1connect.AuthServiceLogoutProcedure,+ v1connect.AuthServiceRequestPasswordResetProcedure,+ v1connect.AuthServiceResetPasswordProcedure,+ v1connect.AuthServiceSendEmailLoginCodeProcedure,+ v1connect.AuthServiceSwitchWorkspaceProcedure,+ v1connect.UserServiceUpdateUserProcedure,+ v1connect.WorkspaceServiceLeaveWorkspaceProcedure,+ v1connect.WorkspaceServiceDeleteWorkspaceProcedure,+ v1connect.ServiceAccountServiceCreateServiceAccountProcedure,+ v1connect.ServiceAccountServiceUpdateServiceAccountProcedure,+ v1connect.WorkspaceServiceRotateDirectorySyncTokenProcedure,+ v1connect.UserServiceCreateUserProcedure,+ v1connect.IdentityProviderServiceCreateIdentityProviderProcedure,+ v1connect.IdentityProviderServiceUpdateIdentityProviderProcedure,+ v1connect.IdentityProviderServiceTestIdentityProviderProcedure,+ v1connect.WorkloadIdentityServiceCreateWorkloadIdentityProcedure,+ v1connect.WorkloadIdentityServiceUpdateWorkloadIdentityProcedure,+ v1connect.SettingServiceTestEmailSettingProcedure,+ v1connect.UserServiceUpdateEmailProcedure,+ v1connect.SettingServiceUpdateSettingProcedure,+ v1connect.InstanceServiceUpdateDataSourceProcedure,+ v1connect.IssueServiceApproveIssueProcedure,+ v1connect.IssueServiceRejectIssueProcedure,+ v1connect.IssueServiceRetryIssueApprovalProcedure,+ }+ got := forbiddenProceduresFromDescriptors(t)++ for _, procedure := range want {+ require.Contains(t, got, procedure, "%s must be annotated mcp_method_class = FORBIDDEN", procedure)+ }+ require.Len(t, got, len(want),+ "an RPC was annotated FORBIDDEN without being added here; membership must be an explicit decision")++ // Which mechanism each method is refused for, read off the annotations+ // rather than off a Go copy of them. The reason has to describe what the+ // method does, not merely be present: Logout destroys a session rather than+ // issuing a credential, and a denial that says otherwise teaches the next+ // reader something false. These are near-synonyms in English and are not+ // near-synonyms in what they tell an operator, so every method is pinned.+ wantReason := map[string]v1pb.MCPDenialReason{+ v1connect.AuthServiceLoginProcedure: v1pb.MCPDenialReason_MINTS_CREDENTIAL,+ v1connect.AuthServiceSignupProcedure: v1pb.MCPDenialReason_MINTS_CREDENTIAL,+ v1connect.AuthServiceExchangeTokenProcedure: v1pb.MCPDenialReason_MINTS_CREDENTIAL,+ v1connect.AuthServiceRefreshProcedure: v1pb.MCPDenialReason_MINTS_CREDENTIAL,+ v1connect.AuthServiceSwitchWorkspaceProcedure: v1pb.MCPDenialReason_MINTS_CREDENTIAL,+ v1connect.AuthServiceRequestPasswordResetProcedure: v1pb.MCPDenialReason_RESETS_CREDENTIAL,+ v1connect.AuthServiceResetPasswordProcedure: v1pb.MCPDenialReason_RESETS_CREDENTIAL,+ v1connect.AuthServiceSendEmailLoginCodeProcedure: v1pb.MCPDenialReason_RESETS_CREDENTIAL,+ v1connect.UserServiceUpdateUserProcedure: v1pb.MCPDenialReason_TAKES_OVER_ACCOUNT,+ v1connect.AuthServiceLogoutProcedure: v1pb.MCPDenialReason_ENDS_SESSION,+ v1connect.WorkspaceServiceLeaveWorkspaceProcedure: v1pb.MCPDenialReason_ENDS_MEMBERSHIP,+ v1connect.WorkspaceServiceDeleteWorkspaceProcedure: v1pb.MCPDenialReason_ENDS_MEMBERSHIP,+ v1connect.ServiceAccountServiceCreateServiceAccountProcedure: v1pb.MCPDenialReason_MINTS_CREDENTIAL_FOR_OTHERS,+ v1connect.ServiceAccountServiceUpdateServiceAccountProcedure: v1pb.MCPDenialReason_MINTS_CREDENTIAL_FOR_OTHERS,+ v1connect.WorkspaceServiceRotateDirectorySyncTokenProcedure: v1pb.MCPDenialReason_MINTS_CREDENTIAL_FOR_OTHERS,+ v1connect.UserServiceCreateUserProcedure: v1pb.MCPDenialReason_MINTS_CREDENTIAL_FOR_OTHERS,+ v1connect.UserServiceUpdateEmailProcedure: v1pb.MCPDenialReason_MINTS_CREDENTIAL_FOR_OTHERS,+ v1connect.IdentityProviderServiceCreateIdentityProviderProcedure: v1pb.MCPDenialReason_MINTS_CREDENTIAL_FOR_OTHERS,+ v1connect.IdentityProviderServiceUpdateIdentityProviderProcedure: v1pb.MCPDenialReason_MINTS_CREDENTIAL_FOR_OTHERS,+ v1connect.IdentityProviderServiceTestIdentityProviderProcedure: v1pb.MCPDenialReason_MINTS_CREDENTIAL_FOR_OTHERS,+ v1connect.WorkloadIdentityServiceCreateWorkloadIdentityProcedure: v1pb.MCPDenialReason_MINTS_CREDENTIAL_FOR_OTHERS,+ v1connect.WorkloadIdentityServiceUpdateWorkloadIdentityProcedure: v1pb.MCPDenialReason_MINTS_CREDENTIAL_FOR_OTHERS,+ v1connect.SettingServiceTestEmailSettingProcedure: v1pb.MCPDenialReason_MINTS_CREDENTIAL_FOR_OTHERS,+ v1connect.SettingServiceUpdateSettingProcedure: v1pb.MCPDenialReason_REWRITES_SESSION_BOUNDARY,+ v1connect.InstanceServiceUpdateDataSourceProcedure: v1pb.MCPDenialReason_MINTS_CREDENTIAL_FOR_OTHERS,+ v1connect.IssueServiceApproveIssueProcedure: v1pb.MCPDenialReason_DRIVES_THE_APPROVAL_DECISION,+ v1connect.IssueServiceRejectIssueProcedure: v1pb.MCPDenialReason_DRIVES_THE_APPROVAL_DECISION,+ v1connect.IssueServiceRetryIssueApprovalProcedure: v1pb.MCPDenialReason_DRIVES_THE_APPROVAL_DECISION,+ }+ // Wording for every mechanism in use is checkReasonsMatchTheClass's job, over+ // every class rather than only the ones enumerated here.+ require.Equal(t, wantReason, got,+ "every FORBIDDEN method records the mechanism it is refused for, and this is the second signature on it")+}++// The lint. Every clause is a function over the rows rather than a body of+// assertions, so the same code can be run against a deliberately broken copy —+// each clause has a RED test below that mutates one input and asserts the+// clause fires. A clause with no RED test is a clause nobody has proved can+// fail.++// The serving table this lint holds the classification against is+// mcpServingClasses, the one the gate evaluates — not a copy. 1b-1 declared it+// here as a specification with a note that the gate PR had to lift it into the+// code, because two copies would let this lint stay green while the runtime+// rules drifted away from it. This is that lift.++// checkEveryMethodIsClassified is the clause that ends the whack-a-mole. A new+// RPC arrives unannotated, which is UNSPECIFIED, which fails the build — so it+// gets classified before it can ship rather than after somebody notices it was+// reachable.+func checkEveryMethodIsClassified(rows []mcpClassification) []string {+ var violations []string+ for _, row := range rows {+ if row.class == v1pb.MCPMethodClass_MCP_METHOD_CLASS_UNSPECIFIED {+ violations = append(violations, row.procedure+": carries no mcp_method_class")+ }+ }+ slices.Sort(violations)+ return violations+}++// checkReasonsMatchTheClass proves each row's reason and class agree. A refused+// method says why it is refused and has wording to say it with, and the reason+// it gives is one that belongs to its class; a served method claims none,+// because a reason without its class denies nothing and would read, to anyone+// grepping for it, as a method that is not served.+//+// One enum carries both refused classes, so the pairing is the check. Two+// enums made a wrong-class reason a parse-level impossibility on paper and, in+// practice, only added the states where a method carried both or carried the+// kind that contradicted its class — states this clause used to spend four of+// its six branches policing. What is left is the one thing that was ever real.+func checkReasonsMatchTheClass(rows []mcpClassification, wording map[v1pb.MCPDenialReason]mcpDenialWording) []string {+ var violations []string+ for _, row := range rows {+ refused := row.class == v1pb.MCPMethodClass_FORBIDDEN || row.class == v1pb.MCPMethodClass_EXCLUDED+ hasReason := row.reason != v1pb.MCPDenialReason_MCP_DENIAL_REASON_UNSPECIFIED+ switch {+ case refused && !hasReason:+ violations = append(violations, fmt.Sprintf("%s: is %v and records no mcp_denial_reason", row.procedure, row.class))+ case refused:+ recorded, ok := wording[row.reason]+ switch {+ case !ok:+ violations = append(violations, fmt.Sprintf("%s: is refused for %v, which has no sentence to say so", row.procedure, row.reason))+ case recorded.class != row.class:+ violations = append(violations, fmt.Sprintf("%s: is %v but records %v, which is a %v reason",+ row.procedure, row.class, row.reason, recorded.class))+ default:+ }+ case hasReason:+ violations = append(violations, fmt.Sprintf("%s: records %v, a denial reason, but is not refused", row.procedure, row.reason))+ default:+ }+ }+ slices.Sort(violations)+ return violations+}++// mcpDeniedClasses is the other half of the same decision: the classes no mode+// serves. Held against mcpServingClasses (mcp_gate.go) below.+var mcpDeniedClasses = []v1pb.MCPMethodClass{v1pb.MCPMethodClass_FORBIDDEN, v1pb.MCPMethodClass_EXCLUDED}++// checkEveryClassHasAServingDecision proves that "no method is both denied and+// reachable through a serving mode" is true of the whole vocabulary rather than+// of the rows that happen to exist today.+//+// Asserting it row by row would prove nothing: a row carries one class, so+// FORBIDDEN and READ are mutually exclusive by construction, and a check that+// walks 208 rows looking for a contradiction the type system already forbids is+// a check that cannot fail. What can drift is the vocabulary. So this reads the+// two enums out of the compiled descriptors and holds the tables against them:+// every class is served by some mode or denied, never both and never neither,+// and every ceiling mode says what it serves. Add a fifth class to+// MCPMethodClass, or a fourth mode to MCPCapability, and the build fails until+// somebody decides who serves it — which is the decision that would otherwise+// be made by whichever `switch` in the gate happened to have a default arm.+//+// The last loop closes the circle back to the rows. `decided` holds the classes+// some decision claims — served, denied, or, when the tables disagree, both — so+// dropping READ out of the serving table does not merely report READ once. It+// reports every method annotated READ, which is the shape of the damage.+func checkEveryClassHasAServingDecision(+ rows []mcpClassification,+ serving map[storepb.WorkspaceProfileSetting_MCPCapability][]v1pb.MCPMethodClass,+ denied []v1pb.MCPMethodClass,+ classes protoreflect.EnumDescriptor,+ modes protoreflect.EnumDescriptor,+) []string {+ var violations []string+ servedBy := map[v1pb.MCPMethodClass][]storepb.WorkspaceProfileSetting_MCPCapability{}+ for mode, served := range serving {+ for _, class := range served {+ servedBy[class] = append(servedBy[class], mode)+ }+ }+ // serving is a map, so without this the mode list in a violation message+ // comes out in a different order on every run.+ for class := range servedBy {+ slices.Sort(servedBy[class])+ }++ inVocabulary := map[v1pb.MCPMethodClass]bool{}+ decided := map[v1pb.MCPMethodClass]bool{}+ values := classes.Values()+ for i := range values.Len() {+ class := v1pb.MCPMethodClass(values.Get(i).Number())+ if class == v1pb.MCPMethodClass_MCP_METHOD_CLASS_UNSPECIFIED {+ continue+ }+ inVocabulary[class] = true+ isServed, isDenied := len(servedBy[class]) > 0, slices.Contains(denied, class)+ switch {+ case isServed && isDenied:+ violations = append(violations, fmt.Sprintf("%v is denied and served by %v", class, servedBy[class]))+ case !isServed && !isDenied:+ violations = append(violations, fmt.Sprintf("%v is neither served by a mode nor denied", class))+ default:+ }+ // Having two decisions counts as decided here. The switch above has+ // already said so once; repeating it per method would bury the one+ // actionable line under a hundred rows naming the wrong problem.+ decided[class] = isServed || isDenied+ }+ for _, class := range denied {+ if !inVocabulary[class] {+ violations = append(violations, fmt.Sprintf("%v is denied but is not a class", class))+ }+ }++ modeValues := modes.Values()+ for i := range modeValues.Len() {+ value := modeValues.Get(i)+ mode := storepb.WorkspaceProfileSetting_MCPCapability(value.Number())+ if mode == storepb.WorkspaceProfileSetting_MCP_CAPABILITY_UNSPECIFIED {+ continue+ }+ if _, ok := serving[mode]; !ok {+ violations = append(violations, fmt.Sprintf("ceiling mode %v does not say which classes it serves", mode))+ }+ }++ for _, row := range rows {+ if row.class != v1pb.MCPMethodClass_MCP_METHOD_CLASS_UNSPECIFIED && !decided[row.class] {+ violations = append(violations, fmt.Sprintf("%s: carries %v, which has no serving decision", row.procedure, row.class))+ }+ }+ slices.Sort(violations)+ return violations+}++func TestLintEveryMethodIsClassified(t *testing.T) {+ require.Empty(t, checkEveryMethodIsClassified(mcpClassificationsFromDescriptors(t)))+}++func TestLintReasonsMatchTheClass(t *testing.T) {+ require.Empty(t, checkReasonsMatchTheClass(mcpClassificationsFromDescriptors(t), mcpDenialReasons))+}++// mcpEnums reads the two enums the serving decision spans out of the compiled+// descriptors, so the lint below tracks the protos rather than a Go copy of+// them. The ceiling comes from the STORE enum because that is the one a+// setting row holds and the gate reads back.+func mcpEnums(t *testing.T) (classes, modes protoreflect.EnumDescriptor) {+ t.Helper()+ return v1pb.MCPMethodClass(0).Descriptor(), storepb.WorkspaceProfileSetting_MCPCapability(0).Descriptor()+}++func TestLintEveryClassHasAServingDecision(t *testing.T) {+ classes, modes := mcpEnums(t)+ require.Empty(t, checkEveryClassHasAServingDecision(+ mcpClassificationsFromDescriptors(t), mcpServingClasses, mcpDeniedClasses, classes, modes))+}++// TestLintRefusedClassesMatchTheServingTable is what lets a second package+// decide what to advertise without carrying a copy of the serving rules. The+// MCP OpenAPI index hides an endpoint no ceiling serves, and it asks+// auth.MCPClassIsRefused, which cannot see this table. This holds the two+// against each other over the whole class vocabulary, so a mode that starts+// serving a class cannot leave discovery hiding it — or the reverse, which is+// the one that would offer an agent work it can never do.+func TestLintRefusedClassesMatchTheServingTable(t *testing.T) {+ served := map[v1pb.MCPMethodClass]bool{}+ for _, classes := range mcpServingClasses {+ for _, class := range classes {+ served[class] = true+ }+ }+ values := v1pb.MCPMethodClass(0).Descriptor().Values()+ for i := range values.Len() {+ class := v1pb.MCPMethodClass(values.Get(i).Number())+ require.Equal(t, !served[class], auth.MCPClassIsRefused(class),+ "%v: the serving table and auth.MCPClassIsRefused disagree about whether any ceiling serves it", class)+ }+}++// TestMCPCapabilityEnumsAgree is what lets the lint above read one enum and the+// gate read the other. The settings API writes the v1 ceiling, the setting row+// stores the store ceiling, and the conversion between them is by number+// (setting_service_converter.go). If the two ever disagree — a mode added to+// one, a number reused — a customer could set a ceiling the gate would read as+// something else entirely, and every serving decision above would be about the+// wrong vocabulary.+func TestMCPCapabilityEnumsAgree(t *testing.T) {+ v1Values := v1pb.WorkspaceProfileSetting_MCPCapability(0).Descriptor().Values()+ storeValues := storepb.WorkspaceProfileSetting_MCPCapability(0).Descriptor().Values()++ byNumber := func(values protoreflect.EnumValueDescriptors) map[int32]string {+ out := map[int32]string{}+ for i := range values.Len() {+ value := values.Get(i)+ out[int32(value.Number())] = string(value.Name())+ }+ return out+ }+ require.Equal(t, byNumber(v1Values), byNumber(storeValues),+ "the API ceiling enum and the stored ceiling enum must name the same numbers; "++ "they convert by number and the gate reads the stored one")+}++// TestLintClausesFireWhenBroken is the RED half: one mutation per clause,+// asserting the clause catches it. Without these the clauses above are three+// functions that have only ever been shown to return nothing.+func TestLintClausesFireWhenBroken(t *testing.T) {+ t.Run("an unclassified method fails", func(t *testing.T) {+ // The shape a new RPC arrives in: defined, annotated with nothing.+ // TestLintEveryMethodIsClassified owns the claim that the real+ // descriptor set is clean; this owns the claim that the clause fires.+ broken := append(slices.Clone(mcpClassificationsFromDescriptors(t)),+ mcpClassification{procedure: "/bytebase.v1.NewService/NewMethod"})+ require.Contains(t, checkEveryMethodIsClassified(broken),+ "/bytebase.v1.NewService/NewMethod: carries no mcp_method_class")+ })++ t.Run("a refused method with no reason fails", func(t *testing.T) {+ broken := []mcpClassification{+ {procedure: "/p", class: v1pb.MCPMethodClass_FORBIDDEN},+ {procedure: "/q", class: v1pb.MCPMethodClass_EXCLUDED},+ }+ require.Equal(t, []string{+ "/p: is FORBIDDEN and records no mcp_denial_reason",+ "/q: is EXCLUDED and records no mcp_denial_reason",+ }, checkReasonsMatchTheClass(broken, mcpDenialReasons))+ })++ t.Run("a reason with no wording fails", func(t *testing.T) {+ broken := []mcpClassification{{+ procedure: "/p",+ class: v1pb.MCPMethodClass_FORBIDDEN,+ reason: v1pb.MCPDenialReason(9999),+ }}+ require.Equal(t, []string{"/p: is refused for 9999, which has no sentence to say so"},+ checkReasonsMatchTheClass(broken, mcpDenialReasons))+ })++ t.Run("a reason belonging to the other refused class fails", func(t *testing.T) {+ // The one real mistake the merged enum leaves representable, and the+ // reason each row of the wording table carries its class. Both+ // directions, because a FORBIDDEN method explaining itself as a scope+ // decision and an EXCLUDED one claiming a boundary-breaking mechanism+ // mislead an operator in opposite directions.+ broken := []mcpClassification{+ {procedure: "/p", class: v1pb.MCPMethodClass_FORBIDDEN, reason: v1pb.MCPDenialReason_ADMINISTERS_THE_WORKSPACE},+ {procedure: "/q", class: v1pb.MCPMethodClass_EXCLUDED, reason: v1pb.MCPDenialReason_MINTS_CREDENTIAL},+ }+ require.Equal(t, []string{+ "/p: is FORBIDDEN but records ADMINISTERS_THE_WORKSPACE, which is a EXCLUDED reason",+ "/q: is EXCLUDED but records MINTS_CREDENTIAL, which is a FORBIDDEN reason",+ }, checkReasonsMatchTheClass(broken, mcpDenialReasons))+ })++ t.Run("a served method carrying a denial reason fails", func(t *testing.T) {+ broken := []mcpClassification{+ {procedure: "/p", class: v1pb.MCPMethodClass_READ, reason: v1pb.MCPDenialReason_MINTS_CREDENTIAL},+ {procedure: "/q", class: v1pb.MCPMethodClass_WRITE, reason: v1pb.MCPDenialReason_ADMINISTERS_THE_WORKSPACE},+ }+ require.Equal(t, []string{+ "/p: records MINTS_CREDENTIAL, a denial reason, but is not refused",+ "/q: records ADMINISTERS_THE_WORKSPACE, a denial reason, but is not refused",+ }, checkReasonsMatchTheClass(broken, mcpDenialReasons))+ })++ // The serving-decision clause is over the vocabulary, so its mutations are+ // vocabulary mutations: a class that two decisions claim, a class no decision+ // claims, a ceiling mode nobody wrote a row for, and a row reaching a class+ // the tables skipped.+ classes, modes := mcpEnums(t)++ t.Run("a class both served and denied fails once, not once per method", func(t *testing.T) {+ widened := map[storepb.WorkspaceProfileSetting_MCPCapability][]v1pb.MCPMethodClass{+ storepb.WorkspaceProfileSetting_DISABLED: {},+ storepb.WorkspaceProfileSetting_READ_ONLY: {v1pb.MCPMethodClass_READ, v1pb.MCPMethodClass_EXCLUDED},+ storepb.WorkspaceProfileSetting_READ_WRITE: {+ v1pb.MCPMethodClass_READ, v1pb.MCPMethodClass_WRITE, v1pb.MCPMethodClass_EXCLUDED,+ },+ }+ // The real rows are passed deliberately: 93 of them carry EXCLUDED, and+ // the diagnosis worth reading is the one about the table, not ninety-three+ // about methods whose annotation is fine. Two modes, so the mode list in+ // the message is only stable because servedBy is sorted.+ require.Equal(t, []string{"EXCLUDED is denied and served by [READ_ONLY READ_WRITE]"},+ checkEveryClassHasAServingDecision(mcpClassificationsFromDescriptors(t), widened, mcpDeniedClasses, classes, modes))+ })++ t.Run("a class nobody decided fails, and takes its rows with it", func(t *testing.T) {+ // The damage from dropping a class out of the serving table is every+ // method annotated with it, so the clause reports every method too.+ rows := []mcpClassification{+ {procedure: "/p", class: v1pb.MCPMethodClass_WRITE},+ {procedure: "/q", class: v1pb.MCPMethodClass_READ},+ }+ require.Equal(t, []string{+ "/p: carries WRITE, which has no serving decision",+ "WRITE is neither served by a mode nor denied",+ }, checkEveryClassHasAServingDecision(rows, map[storepb.WorkspaceProfileSetting_MCPCapability][]v1pb.MCPMethodClass{+ storepb.WorkspaceProfileSetting_DISABLED: {},+ storepb.WorkspaceProfileSetting_READ_ONLY: {v1pb.MCPMethodClass_READ},+ storepb.WorkspaceProfileSetting_READ_WRITE: {v1pb.MCPMethodClass_READ},+ }, mcpDeniedClasses, classes, modes))+ })++ t.Run("a ceiling mode with no serving row fails", func(t *testing.T) {+ require.Equal(t, []string{"ceiling mode DISABLED does not say which classes it serves"},+ checkEveryClassHasAServingDecision(nil, map[storepb.WorkspaceProfileSetting_MCPCapability][]v1pb.MCPMethodClass{+ storepb.WorkspaceProfileSetting_READ_ONLY: {v1pb.MCPMethodClass_READ},+ storepb.WorkspaceProfileSetting_READ_WRITE: {v1pb.MCPMethodClass_READ, v1pb.MCPMethodClass_WRITE},+ }, mcpDeniedClasses, classes, modes))+ })++ t.Run("a row carrying an undecided class fails", func(t *testing.T) {+ rows := []mcpClassification{{procedure: "/p", class: v1pb.MCPMethodClass(9999)}}+ require.Equal(t, []string{"/p: carries 9999, which has no serving decision"},+ checkEveryClassHasAServingDecision(rows, mcpServingClasses, mcpDeniedClasses, classes, modes))+ })+}++// TestForbiddenClassLeavesReadsAlone pins the other half of the second batch's+// ruling, which is the half a later change could quietly widen: the reads of+// the services whose writes were forbidden are not themselves refused. This PR+// classifies most of them EXCLUDED — identity and credential administration —+// which is a scope decision a future admin-capable ceiling can revisit. What+// they must never become is FORBIDDEN, and that is what this pins.+//+// They carry no credential. Every identity-provider read goes through the one+// conversion that blanks the client secret and the LDAP bind password+// (idp_service.go, three "SECURITY: We do not expose" lines), service-account+// reads never populate ServiceKey (only create and the rotation branch do), and+// workload-identity reads return issuer, audience and subject pattern —+// configuration, not a secret. ListIdentityProviders is additionally+// allow_without_credential, the endpoint the login page calls unauthenticated,+// so forbidding it would cost an agent legitimate work while protecting nothing+// an anonymous client could not already read.+func TestForbiddenClassLeavesReadsAlone(t *testing.T) {+ got := forbiddenProceduresFromDescriptors(t)+ for _, procedure := range []string{+ v1connect.IdentityProviderServiceGetIdentityProviderProcedure,+ v1connect.IdentityProviderServiceListIdentityProvidersProcedure,+ v1connect.WorkloadIdentityServiceGetWorkloadIdentityProcedure,+ v1connect.WorkloadIdentityServiceListWorkloadIdentitiesProcedure,+ v1connect.ServiceAccountServiceGetServiceAccountProcedure,+ v1connect.ServiceAccountServiceListServiceAccountsProcedure,+ } {+ require.NotContains(t, got, procedure,+ "%s is a read that carries no credential; forbidding it is scope this batch did not take", procedure)+ }+}++// TestExcludedOnlyForALeak pins the population that is excluded for a defect+// rather than for what the method is. Every row here is an ordinary read that+// belongs in a serving class on its merits, and is out only because its+// response carries a stored secret the product already redacts elsewhere. The+// leak is the thing to fix; when one is fixed its row leaves this test and+// becomes READ, which is a reviewed widening rather than a silent one.+//+// Each entry names the leak and the redaction that closes it:+//+// - The four project reads share convertToProject+// (project_service_converter.go:264), which copies the incoming-webhook URL+// out verbatim. That URL is a bearer credential — whoever holds it posts+// into the customer's Slack, Feishu, WeCom or Teams as Bytebase — and this+// repo already treats it as one: redactWebhook masks it in audit rows+// (audit.go:914) beside the OIDC client secret and the LDAP bind password.+// ListProjects pages the whole workspace, so one call takes the lot.+//+// - The two instance reads and ListInstanceRoles share InstanceRole.Attribute+// (instance_service_converter.go:57), which is the raw SHOW GRANTS text the+// MySQL driver stores (plugin/db/mysql/role.go:38). On MariaDB that text+// carries "IDENTIFIED BY PASSWORD '<hash>'", so the response hands over+// every database account's password hash. The data-source half of the very+// same converter gets this right and says so: "We don't return the password+// and SSLs on reads" (instance_service_converter.go:253).+//+// - GetCurrentUser returns temp_otp_secret and temp_recovery_codes whenever+// the subject is the caller (user_service.go:742), so a session reading its+// own profile during an MFA-setup window captures the TOTP seed. The window+// is opened by the human in the console, not by the agent — UpdateUser,+// which starts it, is FORBIDDEN — which makes this the narrowest of the+// three and still a stored secret in a response body.+func TestExcludedOnlyForALeak(t *testing.T) {+ want := []string{+ v1connect.ProjectServiceGetProjectProcedure,+ v1connect.ProjectServiceListProjectsProcedure,+ v1connect.ProjectServiceBatchGetProjectsProcedure,+ v1connect.ProjectServiceSearchProjectsProcedure,+ v1connect.InstanceServiceGetInstanceProcedure,+ v1connect.InstanceServiceListInstancesProcedure,+ v1connect.InstanceRoleServiceListInstanceRolesProcedure,+ v1connect.UserServiceGetCurrentUserProcedure,+ }+ var got []string+ for _, row := range mcpClassificationsFromDescriptors(t) {+ if row.reason == v1pb.MCPDenialReason_RETURNS_A_STORED_SECRET {+ got = append(got, row.procedure)+ }+ }+ slices.Sort(want)+ slices.Sort(got)+ require.Equal(t, want, got,+ "this population is excluded for a leak, not for what the method is; adding or removing one is a deliberate decision")+}++// TestDeprecatedSQLServiceAliasesMatchTheirCanonicalMethod pins the three+// query-history RPCs that SQLService still carries as deprecated aliases of+// QueryHistoryService. They have no HTTP binding, but the MCP surface indexes+// every POST path in its generated spec (mcp/openapi_index.go), so call_api+// resolves them by operation ID. An alias classified more permissively than the+// method it forwards to is a straight bypass of that method's classification.+func TestDeprecatedSQLServiceAliasesMatchTheirCanonicalMethod(t *testing.T) {+ class := map[string]v1pb.MCPMethodClass{}+ for _, row := range mcpClassificationsFromDescriptors(t) {+ class[row.procedure] = row.class+ }+ for alias, canonical := range map[string]string{+ v1connect.SQLServiceListQueryHistoriesProcedure: v1connect.QueryHistoryServiceListQueryHistoriesProcedure,+ v1connect.SQLServiceGetQueryHistoryProcedure: v1connect.QueryHistoryServiceGetQueryHistoryProcedure,+ v1connect.SQLServiceSearchQueryHistoriesProcedure: v1connect.QueryHistoryServiceSearchQueryHistoriesProcedure,+ } {+ require.Equal(t, class[canonical], class[alias],+ "%s is a deprecated alias of %s and must not be reachable where the canonical method is not", alias, canonical)+ }+}++// mcpInventoryPath holds a rendering of the annotations, committed so a+// reviewer can read the whole classification as one table instead of across+// thirty proto files. It is a rendering and not the source of truth: the+// annotations are, this file is regenerated from them, and nothing reads it at+// runtime.+const mcpInventoryPath = "testdata/mcp_method_classification.md"++const mcpInventoryRegenerate = "MCP_INVENTORY=write go test ./backend/api/v1/ -run TestMCPClassificationInventory"++func renderMCPInventory(rows []mcpClassification) string {+ var b strings.Builder+ b.WriteString("# MCP method classification\n\n")+ b.WriteString("Rendered from the `bytebase.v1.mcp_method_class` and `mcp_denial_reason`\n")+ b.WriteString("annotations on the v1 RPCs. The annotations are the source of\n")+ b.WriteString("truth; this file is a reviewable view of them and nothing reads it at runtime.\n\n")+ b.WriteString("Regenerate with:\n\n```\n" + mcpInventoryRegenerate + "\n```\n\n")+ b.WriteString("Every class is enforced by the MCP gate. READ and WRITE are the serving classes a\n")+ b.WriteString("workspace's MCP capability ceiling selects between; EXCLUDED and FORBIDDEN are\n")+ b.WriteString("served by no ceiling.\n\n")++ counts := map[v1pb.MCPMethodClass]int{}+ for _, row := range rows {+ counts[row.class]+++ }+ b.WriteString("| Class | Methods | Meaning |\n|---|---|---|\n")+ for _, line := range []struct {+ class v1pb.MCPMethodClass+ meaning string+ }{+ {v1pb.MCPMethodClass_READ, "served to a read-only session and above"},+ {v1pb.MCPMethodClass_WRITE, "served to a read-write session only"},+ {v1pb.MCPMethodClass_EXCLUDED, "served by no ceiling this phase ships"},+ {v1pb.MCPMethodClass_FORBIDDEN, "never served, whatever the ceiling"},+ {v1pb.MCPMethodClass_MCP_METHOD_CLASS_UNSPECIFIED, "unclassified — CI rejects this, and the gate refuses it"},+ } {+ fmt.Fprintf(&b, "| %v | %d | %s |\n", line.class, counts[line.class], line.meaning)+ }+ fmt.Fprintf(&b, "| **total** | **%d** | |\n\n", len(rows))++ b.WriteString("| Method | Class | Reason | Permission |\n|---|---|---|---|\n")+ for _, row := range rows {+ reason := ""+ if row.reason != v1pb.MCPDenialReason_MCP_DENIAL_REASON_UNSPECIFIED {+ reason = row.reason.String()+ }+ permission := row.permission+ if permission == "" {+ permission = "—"+ }+ if reason == "" {+ reason = "—"+ }+ fmt.Fprintf(&b, "| %s | %v | %s | %s |\n",+ strings.TrimPrefix(row.procedure, "/bytebase.v1."), row.class, reason, permission)+ }+ return b.String()+}++// TestMCPClassificationInventory keeps the committed rendering in step with the+// annotations. It fails on a stale file rather than regenerating silently, so a+// classification change shows up in the diff a reviewer reads.+func TestMCPClassificationInventory(t *testing.T) {+ rendered := renderMCPInventory(mcpClassificationsFromDescriptors(t))+ if os.Getenv("MCP_INVENTORY") == "write" {+ require.NoError(t, os.WriteFile(mcpInventoryPath, []byte(rendered), 0o600))+ return+ }+ committed, err := os.ReadFile(mcpInventoryPath)+ require.NoError(t, err)+ require.Equal(t, string(committed), rendered, "the inventory is stale; regenerate with: %s", mcpInventoryRegenerate)+}++// --- the gate ---++// mcpGateStore stands in for the workspace's stored ceiling. A READ_ONLY+// ceiling cannot be reached end to end yet — mcpConnectionAllowed still refuses+// the connection until 1b-3 lands the SQL clamp — so the only way to exercise+// the read-only half of the rule today is here.+type mcpGateStore struct {+ ceiling storepb.WorkspaceProfileSetting_MCPCapability+ err error+}++func (s mcpGateStore) GetMCPCapabilityUncached(context.Context, string) (storepb.WorkspaceProfileSetting_MCPCapability, error) {+ return s.ceiling, s.err+}++func readWriteCeiling() mcpGateStore {+ return mcpGateStore{ceiling: storepb.WorkspaceProfileSetting_READ_WRITE}+}++func readOnlyCeiling() mcpGateStore {+ return mcpGateStore{ceiling: storepb.WorkspaceProfileSetting_READ_ONLY}+}++type mcpGateResult struct {+ dispatched bool+ auditMarked bool+ err error+}++// invokeMCPGate runs one request through the gate alone. auditMarked is what+// the audit interceptor reads when the request comes back out; standing in for+// it here keeps the class rules provable without a database, and+// TestMCPGateDenialIsAuditedWithoutAnAuditAnnotation proves the real+// interceptor honors the mark.+func invokeMCPGate(t *testing.T, stores mcpCeilingReader, authCtx *common.AuthContext, procedure string, req connect.AnyRequest) mcpGateResult {+ t.Helper()+ out := mcpGateResult{}+ next := func(_ context.Context, _ connect.AnyRequest) (connect.AnyResponse, error) {+ out.dispatched = true+ return connect.NewResponse(&v1pb.User{}), nil+ }+ ctx := context.Background()+ if authCtx != nil {+ ctx = context.WithValue(ctx, common.AuthContextKey, authCtx)+ }+ ctx = context.WithValue(ctx, common.WorkspaceIDContextKey, auditTestWorkspace)+ ctx = common.WithSetMCPPolicyDenied(ctx, func() { out.auditMarked = true })+ _, out.err = NewInternalMCPGateInterceptor(stores).WrapUnary(next)(ctx,+ &specRequest{AnyRequest: req, procedure: procedure})+ return out+}++func classContext(class v1pb.MCPMethodClass) *common.AuthContext {+ return &common.AuthContext{MCPMethodClass: class}+}++// TestMCPGateRefusesTheDeniedClasses walks every method the annotations refuse+// outright and proves the gate refuses it under the most permissive ceiling+// there is. FORBIDDEN was already enforced; EXCLUDED is what this PR turns from+// a recorded classification into a denial, and it is the larger population by+// far — 93 methods the console and the public API serve today.+func TestMCPGateRefusesTheDeniedClasses(t *testing.T) {+ for _, row := range mcpClassificationsFromDescriptors(t) {+ if row.class != v1pb.MCPMethodClass_FORBIDDEN && row.class != v1pb.MCPMethodClass_EXCLUDED {+ continue+ }+ wantReason := mcpDenialReasons[row.reason].sentence+ t.Run(row.procedure, func(t *testing.T) {+ got := invokeMCPGate(t, readWriteCeiling(), &common.AuthContext{+ MCPMethodClass: row.class,+ MCPDenialReason: row.reason,+ }, row.procedure, connect.NewRequest(&v1pb.GetUserRequest{}))++ require.Error(t, got.err, "a %v method must never reach its handler", row.class)+ require.False(t, got.dispatched, "the denial must land before dispatch, so no handler side effect can")+ require.Equal(t, connect.CodePermissionDenied, connect.CodeOf(got.err))+ require.Contains(t, got.err.Error(), row.procedure, "the message must name the method the agent called")+ require.NotEmpty(t, wantReason, "every refused method's reason must have wording")+ require.Contains(t, got.err.Error(), wantReason, "the message must name why, so the agent can act on it")+ require.True(t, got.auditMarked, "every denial is an audited outcome")+ })+ }+}++// TestMCPGateServesTheAdmittedClasses is the other half: under a read-write+// ceiling both serving classes reach their handler, and the gate grants+// nothing on its own — ACL runs after it, unchanged.+func TestMCPGateServesTheAdmittedClasses(t *testing.T) {+ for _, class := range []v1pb.MCPMethodClass{v1pb.MCPMethodClass_READ, v1pb.MCPMethodClass_WRITE} {+ t.Run(class.String(), func(t *testing.T) {+ got := invokeMCPGate(t, readWriteCeiling(), classContext(class),+ v1connect.DatabaseServiceGetDatabaseProcedure, connect.NewRequest(&v1pb.GetDatabaseRequest{}))+ require.NoError(t, got.err)+ require.True(t, got.dispatched)+ require.False(t, got.auditMarked)+ })+ }+}++// TestMCPGateUnderAReadOnlyCeiling is the rule this PR exists for: the same+// session that reaches a WRITE method under read-write is refused it under+// read-only, while its reads keep working. It is unit-level because READ_ONLY+// cannot connect until 1b-3: TestMCPConnectionAllowed and the ws-readonly row+// of TestMCPCeilingStoredValueFailsClosed (backend/api/mcp) are the pins that+// the cutover has not moved.+func TestMCPGateUnderAReadOnlyCeiling(t *testing.T) {+ t.Run("a READ method is served", func(t *testing.T) {+ got := invokeMCPGate(t, readOnlyCeiling(), classContext(v1pb.MCPMethodClass_READ),+ v1connect.DatabaseServiceGetDatabaseProcedure, connect.NewRequest(&v1pb.GetDatabaseRequest{}))+ require.NoError(t, got.err)+ require.True(t, got.dispatched)+ })++ t.Run("a WRITE method is refused, naming the ceiling and the way out", func(t *testing.T) {+ // A WRITE method with no request-shape rule of its own, so the refusal+ // can only be the ceiling's.+ got := invokeMCPGate(t, readOnlyCeiling(), classContext(v1pb.MCPMethodClass_WRITE),+ v1connect.SheetServiceCreateSheetProcedure, connect.NewRequest(&v1pb.CreateSheetRequest{}))+ require.Error(t, got.err)+ require.False(t, got.dispatched)+ require.Equal(t, connect.CodePermissionDenied, connect.CodeOf(got.err))+ require.Contains(t, got.err.Error(), "READ_ONLY", "the denial must name the ceiling in force")+ require.Contains(t, got.err.Error(), "raise the MCP ceiling", "the denial must name the way out")+ require.True(t, got.auditMarked)+ })+}++// TestMCPGateFailsClosedOnTheCeiling covers the two states where the workspace+// has a ceiling the gate cannot act on. Both refuse: a policy that cannot be+// read is not a policy that permits.+func TestMCPGateFailsClosedOnTheCeiling(t *testing.T) {+ t.Run("a failed read refuses, as an outage rather than a verdict", func(t *testing.T) {+ got := invokeMCPGate(t, mcpGateStore{err: errors.New("db unreachable")},+ classContext(v1pb.MCPMethodClass_READ),+ v1connect.DatabaseServiceGetDatabaseProcedure, connect.NewRequest(&v1pb.GetDatabaseRequest{}))+ require.Error(t, got.err)+ require.False(t, got.dispatched, "an unknown policy never permits")+ require.Equal(t, connect.CodeUnavailable, connect.CodeOf(got.err),+ "a database blip is not an authorization decision about the caller, and a client must be able to retry it")+ require.NotContains(t, got.err.Error(), "db unreachable",+ "the agent gets the outcome, not the workspace's storage state")+ require.False(t, got.auditMarked,+ "the denial rows an operator filters on must be denials; an outage is not one")+ })++ t.Run("a stored value this build cannot interpret is a policy refusal", func(t *testing.T) {+ // The opposite half of the same failure. No retry fixes a mistyped+ // ceiling, so promising one would be a lie, and an admin has to act —+ // which makes it a denial, and an audited one. The /mcp connection+ // gate splits the same two the same way.+ got := invokeMCPGate(t, mcpGateStore{err: errors.Wrap(store.ErrMCPCapabilityUnreadable, "READ_WRTIE")},+ classContext(v1pb.MCPMethodClass_READ),+ v1connect.DatabaseServiceGetDatabaseProcedure, connect.NewRequest(&v1pb.GetDatabaseRequest{}))+ require.Error(t, got.err)+ require.False(t, got.dispatched)+ require.Equal(t, connect.CodePermissionDenied, connect.CodeOf(got.err))+ require.NotContains(t, got.err.Error(), "READ_WRTIE",+ "the agent gets the outcome, not the workspace's storage state")+ require.True(t, got.auditMarked)+ })++ t.Run("a DISABLED ceiling is an ordinary denial", func(t *testing.T) {+ // DISABLED refuses the connection, so this arm is not reachable end to+ // end — but the serving table carries an explicit empty list for it+ // precisely so that a ceiling which decided to serve nothing reads as a+ // denial rather than as the unknown-ceiling error, and that distinction+ // is only real if something exercises it.+ got := invokeMCPGate(t, mcpGateStore{ceiling: storepb.WorkspaceProfileSetting_DISABLED},+ classContext(v1pb.MCPMethodClass_READ),+ v1connect.DatabaseServiceGetDatabaseProcedure, connect.NewRequest(&v1pb.GetDatabaseRequest{}))+ require.Error(t, got.err)+ require.False(t, got.dispatched)+ require.Equal(t, connect.CodePermissionDenied, connect.CodeOf(got.err))+ require.Contains(t, got.err.Error(), "serves no method",+ "an empty serving list is a mode that serves nothing, not a mode nobody decided about")+ require.NotContains(t, got.err.Error(), "not one this build serves")+ require.True(t, got.auditMarked)+ })++ t.Run("a stored ceiling this build does not serve refuses", func(t *testing.T) {+ // The reserved number 2, which was METADATA_ONLY before the tier was+ // dropped. It survives protojson as an unknown enum number, so unlike+ // an unknown NAME it reaches the gate intact — and no mode serves it.+ got := invokeMCPGate(t, mcpGateStore{ceiling: storepb.WorkspaceProfileSetting_MCPCapability(2)},+ classContext(v1pb.MCPMethodClass_READ),+ v1connect.DatabaseServiceGetDatabaseProcedure, connect.NewRequest(&v1pb.GetDatabaseRequest{}))+ require.Error(t, got.err)+ require.False(t, got.dispatched)+ require.Equal(t, connect.CodePermissionDenied, connect.CodeOf(got.err))+ require.True(t, got.auditMarked)+ })++ t.Run("no workspace on the request refuses", func(t *testing.T) {+ // The internal auth interceptor puts one on every request it admits, so+ // this is the reordered-chain case: a bug in this process rather than a+ // verdict about the caller or a passing outage.+ out := mcpGateResult{}+ next := func(_ context.Context, _ connect.AnyRequest) (connect.AnyResponse, error) {+ out.dispatched = true+ return connect.NewResponse(&v1pb.User{}), nil+ }+ ctx := context.WithValue(context.Background(), common.AuthContextKey, classContext(v1pb.MCPMethodClass_READ))+ _, err := NewInternalMCPGateInterceptor(readWriteCeiling()).WrapUnary(next)(ctx, &specRequest{+ AnyRequest: connect.NewRequest(&v1pb.GetDatabaseRequest{}),+ procedure: v1connect.DatabaseServiceGetDatabaseProcedure,+ })+ require.Error(t, err)+ require.False(t, out.dispatched)+ require.Equal(t, connect.CodeInternal, connect.CodeOf(err))+ })+}++// TestMCPGateFailsClosedOnAnUnclassifiedMethod pins the arm CI is supposed to+// make unreachable. A new RPC arrives unannotated, which is UNSPECIFIED; the+// lint fails the build on one, and if a build ever ships past that, the method+// is refused rather than served.+func TestMCPGateFailsClosedOnAnUnclassifiedMethod(t *testing.T) {+ got := invokeMCPGate(t, readWriteCeiling(), classContext(v1pb.MCPMethodClass_MCP_METHOD_CLASS_UNSPECIFIED),+ "/bytebase.v1.NewService/NewMethod", connect.NewRequest(&v1pb.GetUserRequest{}))+ require.Error(t, got.err)+ require.False(t, got.dispatched)+ require.Equal(t, connect.CodePermissionDenied, connect.CodeOf(got.err))+ require.Contains(t, got.err.Error(), "carries no MCP classification")+ require.True(t, got.auditMarked)+}++// TestMCPGateFallsBackToGenericWording pins that a refusal whose reason this+// build does not recognize still refuses. The class denies; the reason table+// only supplies a better sentence. This is the rolling-upgrade case, on both+// refused classes.+func TestMCPGateFallsBackToGenericWording(t *testing.T) {+ t.Run("forbidden", func(t *testing.T) {+ got := invokeMCPGate(t, readWriteCeiling(), &common.AuthContext{+ MCPMethodClass: v1pb.MCPMethodClass_FORBIDDEN,+ MCPDenialReason: v1pb.MCPDenialReason(9999),+ }, v1connect.AuthServiceLoginProcedure, connect.NewRequest(&v1pb.LoginRequest{}))+ require.Error(t, got.err)+ require.False(t, got.dispatched)+ require.Contains(t, got.err.Error(), reasonForbiddenClass)+ })++ t.Run("excluded", func(t *testing.T) {+ got := invokeMCPGate(t, readWriteCeiling(), &common.AuthContext{+ MCPMethodClass: v1pb.MCPMethodClass_EXCLUDED,+ MCPDenialReason: v1pb.MCPDenialReason(9999),+ }, v1connect.UserServiceListUsersProcedure, connect.NewRequest(&v1pb.ListUsersRequest{}))+ require.Error(t, got.err)+ require.False(t, got.dispatched)+ require.Contains(t, got.err.Error(), reasonExcludedClass)+ })+}++// TestMCPGateFailsClosedWithoutAnAuthContext pins that the gate does not guess.+func TestMCPGateFailsClosedWithoutAnAuthContext(t *testing.T) {+ got := invokeMCPGate(t, readWriteCeiling(), nil,+ v1connect.AuthServiceLoginProcedure, connect.NewRequest(&v1pb.LoginRequest{}))+ require.Error(t, got.err, "without a resolved classification the interceptor must not guess")+ require.False(t, got.dispatched)+ require.Equal(t, connect.CodeInternal, connect.CodeOf(got.err))+}++// TestMCPGateRefusesGrantIssues pins the one refusal a per-method class cannot+// express. CreateIssue is WRITE for the database-change issue an agent exists+// to compose; the grant types complete on creation and hand out access with no+// human step. UpdateIssue is the same method under another name whenever+// allow_missing is set.+func TestMCPGateRefusesGrantIssues(t *testing.T) {+ write := classContext(v1pb.MCPMethodClass_WRITE)++ t.Run("an ordinary change issue is served", func(t *testing.T) {+ got := invokeMCPGate(t, readWriteCeiling(), write, v1connect.IssueServiceCreateIssueProcedure,+ connect.NewRequest(&v1pb.CreateIssueRequest{+ Parent: "projects/p",+ Issue: &v1pb.Issue{Type: v1pb.Issue_DATABASE_CHANGE, Plan: "projects/p/plans/1"},+ }))+ require.NoError(t, got.err)+ require.True(t, got.dispatched)+ })++ for _, issueType := range []v1pb.Issue_Type{+ v1pb.Issue_ROLE_GRANT,+ v1pb.Issue_ACCESS_GRANT,+ } {+ t.Run("CreateIssue refuses "+issueType.String(), func(t *testing.T) {+ got := invokeMCPGate(t, readWriteCeiling(), write, v1connect.IssueServiceCreateIssueProcedure,+ connect.NewRequest(&v1pb.CreateIssueRequest{+ Parent: "projects/p",+ Issue: &v1pb.Issue{Type: issueType},+ }))+ require.Error(t, got.err)+ require.False(t, got.dispatched)+ require.Equal(t, connect.CodePermissionDenied, connect.CodeOf(got.err))+ require.Contains(t, got.err.Error(), issueType.String())+ require.True(t, got.auditMarked)+ })+ }++ t.Run("an issue type this build does not know is refused", func(t *testing.T) {+ // The allow-list's whole point: a type added after this build shipped+ // is refused rather than served, without anyone remembering to come+ // back here.+ got := invokeMCPGate(t, readWriteCeiling(), write, v1connect.IssueServiceCreateIssueProcedure,+ connect.NewRequest(&v1pb.CreateIssueRequest{+ Parent: "projects/p",+ Issue: &v1pb.Issue{Type: v1pb.Issue_Type(9999)},+ }))+ require.Error(t, got.err)+ require.False(t, got.dispatched)+ require.Equal(t, connect.CodePermissionDenied, connect.CodeOf(got.err))+ })++ t.Run("an unset type is left to the handler", func(t *testing.T) {+ // Nothing can be created from an unspecified type — buildIssueMessage+ // rejects it as an invalid argument — so refusing it here would protect+ // nothing while telling the caller a mechanism that does not apply to+ // its call. UpdateIssue below is where that costs something real.+ got := invokeMCPGate(t, readWriteCeiling(), write, v1connect.IssueServiceCreateIssueProcedure,+ connect.NewRequest(&v1pb.CreateIssueRequest{+ Parent: "projects/p",+ Issue: &v1pb.Issue{Type: v1pb.Issue_TYPE_UNSPECIFIED},+ }))+ require.NoError(t, got.err)+ require.True(t, got.dispatched)+ })++ // UpdateIssue reaches the gate unrefused whatever its body says, including+ // allow_missing with a grant type. The gate cannot tell an upsert that+ // creates from one that edits — "the issue does not exist" is not a field+ // of the request — and an AIP upsert sends the complete resource, so a+ // caller PATCHing an existing ROLE_GRANT issue carries that type in a body+ // the handler ignores. rejectMCPOriginatedGrantIssue guards the creation+ // where the creation happens; TestMCPGateRefusesGrantIssues (backend/tests)+ // is the end-to-end proof that the bypass stays closed.+ for name, request := range map[string]*v1pb.UpdateIssueRequest{+ "allow_missing with a grant type": {+ Issue: &v1pb.Issue{Name: "projects/p/issues/1", Type: v1pb.Issue_ROLE_GRANT},+ AllowMissing: true,+ },+ "allow_missing with no type": {+ Issue: &v1pb.Issue{Name: "projects/p/issues/1", Title: "retitled"},+ AllowMissing: true,+ },+ "an ordinary edit": {+ Issue: &v1pb.Issue{Name: "projects/p/issues/1", Type: v1pb.Issue_ROLE_GRANT},+ },+ } {+ t.Run("UpdateIssue is served: "+name, func(t *testing.T) {+ got := invokeMCPGate(t, readWriteCeiling(), write, v1connect.IssueServiceUpdateIssueProcedure,+ connect.NewRequest(request))+ require.NoError(t, got.err)+ require.True(t, got.dispatched)+ })+ }++ t.Run("a request the table cannot read refuses", func(t *testing.T) {+ // A wiring bug — the table keyed by a procedure whose request type is+ // something else — fails closed rather than waving the call through.+ got := invokeMCPGate(t, readWriteCeiling(), write, v1connect.IssueServiceCreateIssueProcedure,+ connect.NewRequest(&v1pb.GetUserRequest{}))+ require.Error(t, got.err)+ require.False(t, got.dispatched)+ })+}++// TestMCPGateDenialIsAuditedWithoutAnAuditAnnotation is the typed+// policy-denial record, end to end through the real audit interceptor and a+// real store. Every method below is refused and carries no audit annotation, so+// its denial produced nothing at all before the gate started marking its own+// refusals: needAudit reads the annotation and nothing else.+//+// The first four are the FORBIDDEN half of that population, which was the whole+// of it while the gate refused FORBIDDEN alone. Enforcing EXCLUDED raises it to+// 47, and TestWebhook is the fifth case here because it is the member the wider+// population added whose request carries a credential.+//+// Each request below carries a secret or an unbounded body, which is why the+// rows are checked for what they wrote as well as that they wrote. The gate+// refuses before dispatch, so nothing in them was ever used — recording one+// verbatim would turn a silent denial into a worse one.+func TestMCPGateDenialIsAuditedWithoutAnAuditAnnotation(t *testing.T) {+ st := newAuditLiveStore(t)+ auditIn := NewAuditInterceptor(st, "test-secret", &config.Profile{})+ gate := NewInternalMCPGateInterceptor(readWriteCeiling())++ invoke := func(t *testing.T, correlationID, procedure string, req connect.AnyRequest) {+ t.Helper()+ authCtx := &common.AuthContext{+ // No audit annotation: the point of the test.+ Audit: false,+ AuthMethod: common.AuthMethodCustom,+ MCPMethodClass: v1pb.MCPMethodClass_FORBIDDEN,+ MCPDenialReason: v1pb.MCPDenialReason_MINTS_CREDENTIAL_FOR_OTHERS,+ DelegatedGrant: &common.DelegatedGrant{CorrelationID: correlationID, Scope: "mcp:read-write"},+ }+ handlerReached := false+ handler := func(_ context.Context, _ connect.AnyRequest) (connect.AnyResponse, error) {+ handlerReached = true+ return connect.NewResponse(&v1pb.User{}), nil+ }+ // The internal chain's order: audit outside, gate inside.+ chain := auditIn.WrapUnary(gate.WrapUnary(handler))+ _, err := chain(newAuditTestContext(authCtx), &specRequest{AnyRequest: req, procedure: procedure})+ require.Error(t, err)+ require.Equal(t, connect.CodePermissionDenied, connect.CodeOf(err))+ require.False(t, handlerReached)+ }++ assertOneDeniedRow := func(t *testing.T, correlationID, procedure string) *storepb.AuditLog {+ t.Helper()+ rows := findRowsByCorrelation(t, st, correlationID)+ require.Len(t, rows, 1, "a policy denial must be recorded even where the method asks for no audit row")+ row := rows[0].Payload+ require.Equal(t, procedure, row.Method)+ require.Equal(t, int32(connect.CodePermissionDenied), row.GetStatus().GetCode())+ require.Equal(t, "workspaces/"+auditTestWorkspace, row.Parent)+ require.Equal(t, "mcp:read-write", row.GetMcpDelegation().GetScope(),+ "the row must carry the MCP provenance an operator filters on")+ return row+ }++ t.Run("Refresh", func(t *testing.T) {+ invoke(t, "corr-refresh", v1connect.AuthServiceRefreshProcedure, connect.NewRequest(&v1pb.RefreshRequest{}))+ assertOneDeniedRow(t, "corr-refresh", v1connect.AuthServiceRefreshProcedure)+ })++ t.Run("SwitchWorkspace", func(t *testing.T) {+ // All three MFA proofs, not just the one: each is a separate masking+ // statement, and a test that populates one field cannot notice the+ // other two being dropped.+ otp, recovery, temp := "otp-123456", "recovery-abcdef", "mfa-temp-token"+ invoke(t, "corr-switch", v1connect.AuthServiceSwitchWorkspaceProcedure,+ connect.NewRequest(&v1pb.SwitchWorkspaceRequest{+ Workspace: "workspaces/other",+ OtpCode: &otp,+ RecoveryCode: &recovery,+ MfaTempToken: &temp,+ }))+ row := assertOneDeniedRow(t, "corr-switch", v1connect.AuthServiceSwitchWorkspaceProcedure)+ for _, proof := range []string{otp, recovery, temp} {+ require.NotContains(t, row.Request, proof, "an MFA proof must not be transcribed into the row")+ }+ })++ // One subtest per oneof arm: each arm masks a different credential, and+ // only the arm the request carries runs.+ idpRequest := func() *v1pb.TestIdentityProviderRequest {+ return &v1pb.TestIdentityProviderRequest{+ IdentityProvider: &v1pb.IdentityProvider{+ Config: &v1pb.IdentityProviderConfig{+ Config: &v1pb.IdentityProviderConfig_OidcConfig{+ OidcConfig: &v1pb.OIDCIdentityProviderConfig{ClientSecret: "idp-client-secret"},+ },+ },+ },+ }+ }+ oidc, oauth2, ldap := idpRequest(), idpRequest(), idpRequest()+ oidc.Context = &v1pb.TestIdentityProviderRequest_OidcContext{+ OidcContext: &v1pb.OIDCIdentityProviderTestRequestContext{Code: "oidc-authorization-code"},+ }+ oauth2.Context = &v1pb.TestIdentityProviderRequest_Oauth2Context{+ Oauth2Context: &v1pb.OAuth2IdentityProviderTestRequestContext{Code: "oauth2-authorization-code"},+ }+ ldap.Context = &v1pb.TestIdentityProviderRequest_LdapContext{+ LdapContext: &v1pb.LDAPIdentityProviderTestRequestContext{Username: "svc", Password: "directory-password"},+ }+ for name, arm := range map[string]struct {+ request *v1pb.TestIdentityProviderRequest+ secret string+ }{+ "oidc": {oidc, "oidc-authorization-code"},+ "oauth2": {oauth2, "oauth2-authorization-code"},+ "ldap": {ldap, "directory-password"},+ } {+ t.Run("TestIdentityProvider/"+name, func(t *testing.T) {+ correlationID := "corr-idp-" + name+ invoke(t, correlationID, v1connect.IdentityProviderServiceTestIdentityProviderProcedure,+ connect.NewRequest(arm.request))+ row := assertOneDeniedRow(t, correlationID, v1connect.IdentityProviderServiceTestIdentityProviderProcedure)+ require.NotContains(t, row.Request, "idp-client-secret")+ require.NotContains(t, row.Request, arm.secret)+ })+ }++ t.Run("TestIdentityProvider/empty context arm", func(t *testing.T) {+ // A oneof wrapper set with a nil payload. It cannot arrive over JSON,+ // but the audit path must not panic on a message shape the type system+ // permits — a panic here costs the row the gate exists to write.+ invoke(t, "corr-idp-nil", v1connect.IdentityProviderServiceTestIdentityProviderProcedure,+ connect.NewRequest(&v1pb.TestIdentityProviderRequest{+ Context: &v1pb.TestIdentityProviderRequest_LdapContext{},+ }))+ assertOneDeniedRow(t, "corr-idp-nil", v1connect.IdentityProviderServiceTestIdentityProviderProcedure)+ })++ t.Run("TestWebhook", func(t *testing.T) {+ // EXCLUDED rather than FORBIDDEN, and the member the wider refused+ // population adds whose request carries a credential: an incoming+ // webhook URL posts into the customer's Slack as Bytebase, which is+ // why the audit path already masks it on AddWebhook.+ invoke(t, "corr-webhook", v1connect.ProjectServiceTestWebhookProcedure,+ connect.NewRequest(&v1pb.TestWebhookRequest{+ Project: "projects/p",+ Webhook: &v1pb.Webhook{Url: "https://hooks.example.com/T000/B000/secret-token"},+ }))+ row := assertOneDeniedRow(t, "corr-webhook", v1connect.ProjectServiceTestWebhookProcedure)+ require.NotContains(t, row.Request, "secret-token",+ "the webhook URL is a bearer credential and must not be transcribed into the row")+ })++ aiChatBody := "the whole conversation the caller sent"+ t.Run("AIService/Chat", func(t *testing.T) {+ // Not a secret but an unbounded body, and the audit row stores it+ // whole — the size cap applies to the stdout logger only. A denial+ // needs the fact of the call, not the transcript.+ invoke(t, "corr-ai", v1connect.AIServiceChatProcedure,+ connect.NewRequest(&v1pb.AIChatRequest{+ Messages: []*v1pb.AIChatMessage{{Content: &aiChatBody}},+ }))+ row := assertOneDeniedRow(t, "corr-ai", v1connect.AIServiceChatProcedure)+ require.NotContains(t, row.Request, aiChatBody)+ })++ t.Run("TestEmailSetting", func(t *testing.T) {+ invoke(t, "corr-email", v1connect.SettingServiceTestEmailSettingProcedure,+ connect.NewRequest(&v1pb.TestEmailSettingRequest{+ Parent: "workspaces/" + auditTestWorkspace,+ To: "[email protected]",+ EmailSetting: &v1pb.EmailSetting{+ Config: &v1pb.EmailSetting_Smtp{+ Smtp: &v1pb.EmailSetting_SMTPConfig{Host: "smtp.attacker.example", Password: "relay-password"},+ },+ },+ }))+ row := assertOneDeniedRow(t, "corr-email", v1connect.SettingServiceTestEmailSettingProcedure)+ require.NotContains(t, row.Request, "relay-password")+ require.Contains(t, row.Request, "smtp.attacker.example",+ "the host the agent named is the point of the row and stays readable")+ })+}++// mcpDenialRequestReview is one recorded decision: which fields of a request+// were looked at, and what audit.go does with them.+type mcpDenialRequestReview struct {+ fields []string+ decision string+}++// mcpDenialRequestsUnderReview is the population the redaction sweep has to+// consider: every method carrying NO audit annotation whose request holds+// anything beyond the AIP vocabulary below. Before the gate, none of these+// produced an audit row at all; now a denial writes one, so whatever the+// request holds is what lands in the audit_log table.+//+// It covers READ and WRITE as well as the refused classes, because the gate can+// refuse those too — an uninterpretable stored ceiling refuses whatever the+// method's class is, and that refusal is a policy denial like any other.+//+// The decision is keyed on (method, field), not on the field name alone. A name+// exempted globally is an exemption for every future method that happens to+// reuse it, which is the same silent admission the exercise is trying to close:+// `schema` looks inert next to `name` and `parent`, and on DiffSchema it is the+// caller's entire DDL body.+//+// This exists because the first sweep was done by reading, and reading missed+// ListInstanceDatabase — whose request carries an entire Instance, and with it+// every data-source credential the product stores. A list nobody can add to+// silently is the only version of that sweep worth trusting.+var mcpDenialRequestsUnderReview = map[string]mcpDenialRequestReview{+ // Masked. Each carries a credential that a sibling audited method already+ // masks, and the gate refuses before dispatch, so it was never even used.+ v1connect.AIServiceChatProcedure: {+ []string{"messages", "tool_definitions"},+ "redactAIChatRequest drops the conversation body, which is unbounded and stored untruncated",+ },+ v1connect.AuthServiceSwitchWorkspaceProcedure: {+ []string{"mfa_temp_token", "otp_code", "recovery_code", "web", "workspace"},+ "redactSwitchWorkspaceRequest masks the three MFA proofs; the workspace it targeted and the cookie flag stay",+ },+ v1connect.IdentityProviderServiceTestIdentityProviderProcedure: {+ []string{"identity_provider", "ldap_context", "oauth2_context", "oidc_context"},+ "redactTestIdentityProviderRequest masks the provider secret and the test credential",+ },+ v1connect.InstanceServiceListInstanceDatabaseProcedure: {+ []string{"instance"},+ "redactInstance masks every data-source credential; pinned by TestAuditRedactsEveryInputOnlyDataSourceField",+ },+ v1connect.ProjectServiceTestWebhookProcedure: {+ []string{"project", "webhook"},+ "redactWebhook masks the URL, which is a bearer credential; the project stays",+ },+ v1connect.SettingServiceTestEmailSettingProcedure: {+ []string{"email_setting", "to"},+ "redactEmailSetting masks the SMTP password; the address the agent chose to mail stays, which is the point of the row",+ },++ // Recorded as sent. None of it is a credential, and what the row keeps is+ // what the agent actually attempted: the schema it proposed, the CEL it+ // wrote, the resources it named, the flags it set.+ v1connect.CelServiceBatchParseProcedure: {+ []string{"expressions"}, "recorded: CEL the caller wrote",+ },+ v1connect.CelServiceBatchDeparseProcedure: {+ []string{"expressions"}, "recorded: CEL the caller wrote",+ },+ v1connect.DatabaseServiceDiffMetadataProcedure: {+ []string{"target_metadata"},+ "recorded: the caller's own proposed schema, which is the subject of the call",+ },+ v1connect.DatabaseServiceDiffSchemaProcedure: {+ []string{"changelog", "schema"},+ "recorded: the caller's own proposed schema, or the changelog it named",+ },+ v1connect.DatabaseServiceGetSchemaStringProcedure: {+ []string{"metadata", "object", "schema", "type"},+ "recorded: the caller's own proposed schema",+ },+ v1connect.DatabaseServiceGetDatabaseMetadataProcedure: {+ []string{"limit"}, "recorded: a row limit",+ },+ v1connect.DatabaseServiceGetDatabaseSDLSchemaProcedure: {+ []string{"format"}, "recorded: an output format",+ },+ v1connect.InstanceServiceBatchSyncInstancesProcedure: {+ []string{"requests"},+ "recorded: a batch of instance names and a full-sync flag, nothing more",+ },+ v1connect.InstanceServiceSyncInstanceProcedure: {+ []string{"enable_full_sync"}, "recorded: a sync flag",+ },+ v1connect.InstanceRoleServiceListInstanceRolesProcedure: {+ []string{"refresh"}, "recorded: a refresh flag",+ },+ v1connect.OrgPolicyServiceListPoliciesProcedure: {+ []string{"policy_type"}, "recorded: which policy kind was asked for",+ },+ v1connect.ReleaseServiceCheckReleaseProcedure: {+ []string{"custom_rules", "release", "targets", "vcs_user"},+ "recorded: the caller's own release files, the same way an audited Query records its statement",+ },+ v1connect.SavedQueryServiceUpdateSavedQueryStarProcedure: {+ []string{"starred"}, "recorded: a star flag",+ },+ v1connect.SubscriptionServiceVerifyCheckoutSessionProcedure: {+ []string{"session_id"},+ "recorded: an opaque checkout id the caller supplied; reaching the payment provider with it needs Bytebase's own key",+ },+ v1connect.DatabaseServiceBatchGetDatabasesProcedure: {+ []string{"names"}, "recorded: resource names",+ },+ v1connect.DatabaseServiceBatchSyncDatabasesProcedure: {+ []string{"names"}, "recorded: resource names",+ },+ v1connect.GroupServiceBatchGetGroupsProcedure: {+ []string{"names"}, "recorded: resource names",+ },+ v1connect.ProjectServiceBatchGetProjectsProcedure: {+ []string{"names"}, "recorded: resource names",+ },+ v1connect.UserServiceBatchGetUsersProcedure: {+ []string{"names"}, "recorded: resource names",+ },++ v1connect.IssueServiceListIssuesProcedure: {+ []string{"query"}, "recorded: the caller's own search text",+ },+ v1connect.IssueServiceSearchIssuesProcedure: {+ []string{"query"}, "recorded: the caller's own search text",+ },+ v1connect.AuthServiceGetAuthenticationRestrictionProcedure: {+ []string{"workspace"}, "recorded: a workspace resource name",+ },+ v1connect.IssueServiceGetIssueProcedure: {+ []string{"force"}, "recorded: a refresh flag",+ },+ v1connect.SheetServiceGetSheetProcedure: {+ []string{"raw"}, "recorded: a flag asking for untruncated content",+ },+}++// mcpAIPRequestFields are the standard method-signature fields whose meaning is+// fixed by AIP rather than by whoever writes the next RPC: a resource name, a+// parent, the paging and filtering vocabulary, the update controls. They are+// exempt globally because their semantics cannot drift into carrying a payload+// — `page_token` is an opaque cursor on every method that has one, by+// definition.+//+// Nothing else is exempt by name, and the near misses are the reason. `schema`+// looks like vocabulary and is DiffSchema's entire DDL body; `query` looks like+// `filter` and is free text the caller wrote. A field means whatever its own+// RPC decided, so it is reviewed per method above.+var mcpAIPRequestFields = map[string]bool{+ "name": true, "parent": true, "filter": true, "order_by": true,+ "page_size": true, "page_token": true, "show_deleted": true, "view": true,+ "update_mask": true, "etag": true, "allow_missing": true, "validate_only": true,+ // The IAM-policy resource, standard on Get/SetIamPolicy.+ "resource": true,+}++// mcpRequestFieldNeedsReview reports whether a request field could carry more+// into an audit row than the AIP vocabulary does: a nested message, whose whole+// subtree travels, or any scalar the RPC named for itself.+func mcpRequestFieldNeedsReview(field protoreflect.FieldDescriptor) bool {+ if field.Kind() == protoreflect.MessageKind || field.Kind() == protoreflect.GroupKind {+ return true+ }+ return !mcpAIPRequestFields[string(field.Name())]+}++// TestLintDenialRequestsAreReviewedForRedaction fails when a method, or a field+// on one, joins the population above without anyone deciding what its denial+// row may carry.+//+// It cannot check that a redactor exists — getRequestString's type switch is+// not readable from here — so it checks the thing that failed twice: that+// somebody looked, at each field rather than at the method as a whole. A new+// unaudited RPC, or a new field on one already reviewed, breaks the build; the+// fix is a redactor plus a row here, or a row here saying why none is needed.+func TestLintDenialRequestsAreReviewedForRedaction(t *testing.T) {+ needsReview := map[string][]string{}+ for _, row := range mcpClassificationsFromDescriptors(t) {+ if row.audit {+ continue+ }+ fields := row.request.Fields()+ for i := range fields.Len() {+ if field := fields.Get(i); mcpRequestFieldNeedsReview(field) {+ needsReview[row.procedure] = append(needsReview[row.procedure], string(field.Name()))+ }+ }+ slices.Sort(needsReview[row.procedure])+ }++ var undecided []string+ for procedure, fields := range needsReview {+ reviewed, ok := mcpDenialRequestsUnderReview[procedure]+ if !ok {+ undecided = append(undecided, fmt.Sprintf("%s holds %v, and nobody has decided about it", procedure, fields))+ continue+ }+ if !slices.Equal(fields, reviewed.fields) {+ undecided = append(undecided, fmt.Sprintf(+ "%s holds %v; the recorded decision covers %v", procedure, fields, reviewed.fields))+ }+ }+ slices.Sort(undecided)+ require.Empty(t, undecided,+ "these methods are unaudited and the gate can refuse them, so a denial writes their request into an "++ "audit row: decide what may be recorded and record it in mcpDenialRequestsUnderReview")++ var stale []string+ for procedure := range mcpDenialRequestsUnderReview {+ if _, ok := needsReview[procedure]; !ok {+ stale = append(stale, procedure)+ }+ }+ slices.Sort(stale)+ require.Empty(t, stale, "these no longer need a redaction decision; drop them so the list keeps meaning something")+}++// TestRejectMCPOriginatedGrantIssue pins the guard that sits at the creation+// rather than at the gate, and in particular pins the half that makes putting+// MCP policy inside a service handler safe: a human in the console is a request+// with no delegated grant, and must be untouched by it.+//+// The gate cannot take this decision. UpdateIssue creates only when the issue is+// missing, which is not a field of the request, and an AIP upsert sends the+// complete resource — so a caller PATCHing an existing ROLE_GRANT issue carries+// that type in a body the handler ignores. Refusing on the request shape there+// would refuse an ordinary edit for a mechanism that is not running.+func TestRejectMCPOriginatedGrantIssue(t *testing.T) {+ mcpSession := context.WithValue(context.Background(), common.AuthContextKey,+ &common.AuthContext{DelegatedGrant: &common.DelegatedGrant{CorrelationID: "corr-issue"}})+ console := context.WithValue(context.Background(), common.AuthContextKey, &common.AuthContext{})++ for name, tt := range map[string]struct {+ ctx context.Context+ issueType v1pb.Issue_Type+ refused bool+ }{+ "an MCP session may not create a role grant": {mcpSession, v1pb.Issue_ROLE_GRANT, true},+ "an MCP session may not create an access grant": {mcpSession, v1pb.Issue_ACCESS_GRANT, true},+ "an MCP session may not create an unknown type": {mcpSession, v1pb.Issue_Type(9999), true},+ "an MCP session composes database changes": {mcpSession, v1pb.Issue_DATABASE_CHANGE, false},+ "the console creates a role grant": {console, v1pb.Issue_ROLE_GRANT, false},+ "a request with no auth context at all": {context.Background(), v1pb.Issue_ROLE_GRANT, false},+ } {+ t.Run(name, func(t *testing.T) {+ err := rejectMCPOriginatedGrantIssue(tt.ctx, tt.issueType)+ if !tt.refused {+ require.NoError(t, err, "this guard binds MCP sessions and nothing else")+ return+ }+ require.Error(t, err)+ require.Equal(t, connect.CodePermissionDenied, connect.CodeOf(err))+ require.Contains(t, err.Error(), tt.issueType.String(), "the denial must name the type it refused")+ })+ }+}diff --git a/backend/api/v1/rollout_service.go b/backend/api/v1/rollout_service.goindex 6781df4da8..c73c041acc 100644--- a/backend/api/v1/rollout_service.go+++ b/backend/api/v1/rollout_service.go@@ -288,6 +288,9 @@ func (s *RolloutService) CreateRollout(ctx context.Context, req *connect.Requestreturn nil, connect.NewError(connect.CodePermissionDenied, errors.New("permission denied to create rollout"))}+ if err := rejectMCPOriginatedIssuelessRollout(ctx, project, issue, "create a rollout"); err != nil {+ return nil, err+ }if project.Setting.RequireIssueApproval && issue != nil {approved, err := utils.CheckIssueApprovedForPlan(issue, plan)if err != nil {@@ -829,6 +832,9 @@ func (s *RolloutService) BatchRunTasks(ctx context.Context, req *connect.Requestreturn nil, connect.NewError(connect.CodePermissionDenied, errors.New("Not allowed to run tasks"))}+ if err := rejectMCPOriginatedIssuelessRollout(ctx, project, issueN, "run tasks"); err != nil {+ return nil, err+ }// Check if issue approval is required according to the project settingsif project.Setting.RequireIssueApproval && issueN != nil {approved, err := utils.CheckIssueApprovedForPlan(issueN, plan)@@ -1362,3 +1368,48 @@ func (s *RolloutService) canUserRunEnvironmentTasks(ctx context.Context, user *sfunc (s *RolloutService) canUserCancelEnvironmentTaskRun(ctx context.Context, user *store.UserMessage, project *store.ProjectMessage, issue *store.IssueMessage, environment string, creator string) (bool, error) {return s.canUserRunEnvironmentTasks(ctx, user, project, issue, environment, creator)}++// rejectMCPOriginatedIssuelessRollout refuses an MCP session driving a change+// to execution when the project requires issue approval and the plan carries no+// linked issue.+//+// Both approval checks on this path are guarded on a linked issue existing, so+// a plan created without one reaches task creation with no approval whatever+// require_issue_approval says. That is not a defect for every caller — the+// shipped GitOps Service Agent role holds no issue permission at all, so+// issueless deployment is a supported product contract, and READ_WRITE+// preserves supported contracts. It is a defect for an MCP session, because+// without this rule the three FORBIDDEN approval methods are decorative in the+// change lane: an agent that cannot clear the gate can skip it instead, which+// is the same end state the self-approval guard exists to prevent. The rule is+// the one rollout_service.proto states the gate PR owes.+//+// It cannot live in the ceiling gate. "The plan has no linked issue" is not a+// field of either request, so the interceptor would have to read the store to+// find out — a lookup it has no business doing and one that would race the+// handler's own. The guard sits where the fact is already loaded.+//+// It must bite BEFORE the rollout exists: once an issueless rollout is created,+// approval finding refuses outright ("rollout already started"), so a rule that+// only covered BatchRunTasks would leave the change stranded rather than+// gated. Hence both callers, CreateRollout first.+//+// Presence of the delegated grant is the MCP-origin marker, never a field value+// (common.DelegatedGrant), so the console and the GitOps agent are untouched.+// BOT-71 tracks whether the product should close this for every caller; if it+// does, this guard becomes redundant rather than wrong.+func rejectMCPOriginatedIssuelessRollout(ctx context.Context, project *store.ProjectMessage, issue *store.IssueMessage, action string) error {+ authCtx, ok := common.GetAuthContextFromContext(ctx)+ if !ok || authCtx.DelegatedGrant == nil {+ return nil+ }+ if !project.Setting.GetRequireIssueApproval() || issue != nil {+ // With an issue linked, the approval check beside this one decides,+ // and it refuses an unapproved one.+ return nil+ }+ return connect.NewError(connect.CodePermissionDenied, errors.Errorf(+ "an MCP session may not %s for a plan with no issue: this project requires issue approval, and a "++ "rollout created without an issue never meets that gate. Create an issue for the plan and have it "++ "approved, or perform this action signed in to the Bytebase console instead", action))+}diff --git a/backend/api/v1/testdata/mcp_method_classification.md b/backend/api/v1/testdata/mcp_method_classification.mdindex 20dfbd3fb7..1fa26fd37d 100644--- a/backend/api/v1/testdata/mcp_method_classification.md+++ b/backend/api/v1/testdata/mcp_method_classification.md@@ -1,7 +1,7 @@# MCP method classification-Rendered from the `bytebase.v1.mcp_method_class`, `mcp_forbidden_reason` and-`mcp_exclusion_reason` annotations on the v1 RPCs. The annotations are the source of+Rendered from the `bytebase.v1.mcp_method_class` and `mcp_denial_reason`+annotations on the v1 RPCs. The annotations are the source oftruth; this file is a reviewable view of them and nothing reads it at runtime.Regenerate with:@@ -10,16 +10,17 @@ Regenerate with:MCP_INVENTORY=write go test ./backend/api/v1/ -run TestMCPClassificationInventory```-Only FORBIDDEN is enforced today. READ, WRITE and EXCLUDED record where a method-belongs; the gate that acts on them is a later change.+Every class is enforced by the MCP gate. READ and WRITE are the serving classes a+workspace's MCP capability ceiling selects between; EXCLUDED and FORBIDDEN are+served by no ceiling.| Class | Methods | Meaning ||---|---|---|| READ | 48 | served to a read-only session and above || WRITE | 40 | served to a read-write session only |-| EXCLUDED | 93 | served by no mode this phase ships |-| FORBIDDEN | 28 | never served, enforced today |-| MCP_METHOD_CLASS_UNSPECIFIED | 0 | unclassified — CI rejects this |+| EXCLUDED | 93 | served by no ceiling this phase ships |+| FORBIDDEN | 28 | never served, whatever the ceiling |+| MCP_METHOD_CLASS_UNSPECIFIED | 0 | unclassified — CI rejects this, and the gate refuses it || **total** | **209** | || Method | Class | Reason | Permission |diff --git a/backend/common/context.go b/backend/common/context.goindex 28580b01be..00253c83da 100644--- a/backend/common/context.go+++ b/backend/common/context.go@@ -19,6 +19,7 @@ const (ServiceDataKeyWorkspaceIDContextKeyAuditWorkspaceIDKey+ MCPPolicyDenialKey)func WithSetServiceData(ctx context.Context, setServiceData func(a *anypb.Any)) context.Context {@@ -53,6 +54,31 @@ func SetAuditWorkspaceID(ctx context.Context, workspaceID string) {setter(workspaceID)}+// WithSetMCPPolicyDenied registers a callback the MCP ceiling gate uses to tell+// the audit interceptor that it refused this request. The gate runs inside the+// audit interceptor, so a value it puts on the context cannot travel back out;+// this is the same setter shape WithSetAuditWorkspaceID already uses for the+// same reason.+//+// The signal is needed because the audit interceptor otherwise writes a row+// only when the method's own audit annotation asks for one, and 47 of the+// methods the gate refuses carry no such annotation. A denial nobody can see is+// the outcome an operator most needs to see.+func WithSetMCPPolicyDenied(ctx context.Context, setMCPPolicyDenied func()) context.Context {+ return context.WithValue(ctx, MCPPolicyDenialKey, setMCPPolicyDenied)+}++// SetMCPPolicyDenied records that the MCP ceiling gate refused the current+// request, if the audit interceptor registered a setter on the context. Safe to+// call when it did not: the public chain never runs the gate at all.+func SetMCPPolicyDenied(ctx context.Context) {+ setter, ok := ctx.Value(MCPPolicyDenialKey).(func())+ if !ok {+ return+ }+ setter()+}+// GetWorkspaceIDFromContext returns the workspace ID from the request context.func GetWorkspaceIDFromContext(ctx context.Context) string {if v, ok := ctx.Value(WorkspaceIDContextKey).(string); ok {@@ -132,17 +158,19 @@ type AuthContext struct {AuthMethod AuthMethod// MCPMethodClass is the method's bytebase.v1.mcp_method_class annotation.// The effective authorization of an MCP session is this classification- // intersected with the caller's own RBAC — it only ever narrows. Only- // FORBIDDEN is enforced today; READ and WRITE are the serving classes- // P1b's ceiling modes select between, and UNSPECIFIED means "not yet- // classified" rather than "safe".+ // intersected with the caller's own RBAC — it only ever narrows. The MCP+ // gate enforces every value: READ and WRITE are the serving classes the+ // workspace ceiling selects between, EXCLUDED and FORBIDDEN are served by+ // no ceiling, and UNSPECIFIED means "not yet classified" rather than+ // "safe", so it is refused too.MCPMethodClass v1pb.MCPMethodClass- // MCPForbiddenReason is the method's bytebase.v1.mcp_forbidden_reason- // annotation: which mechanism made it FORBIDDEN, so the denial can say- // why. Meaningful only when MCPMethodClass is FORBIDDEN, and UNSPECIFIED- // costs wording rather than enforcement — the class is what denies.- MCPForbiddenReason v1pb.MCPForbiddenReason- Resources []*Resource+ // MCPDenialReason is the method's bytebase.v1.mcp_denial_reason+ // annotation: which mechanism or scope decision refuses it, so the denial+ // can say why. Meaningful only when MCPMethodClass is FORBIDDEN or+ // EXCLUDED, and UNSPECIFIED costs wording rather than enforcement — the+ // class is what denies.+ MCPDenialReason v1pb.MCPDenialReason+ Resources []*Resource// DelegatedGrant carries the grant state of the delegated MCP credential// on internal-chain requests; nil on the public chain. Presence, not any// field value, marks a request as MCP-originated.diff --git a/backend/generated-go/store/setting.pb.go b/backend/generated-go/store/setting.pb.goindex f8642be656..b385baf74f 100644--- a/backend/generated-go/store/setting.pb.go+++ b/backend/generated-go/store/setting.pb.go@@ -625,7 +625,9 @@ type WorkspaceProfileSetting struct {// The maximum capability available to MCP (Model Context Protocol) sessions in// this workspace, acting as an admin-set ceiling. Unset is treated as// READ_WRITE for backward compatibility; DISABLED rejects all MCP- // connections. Enforced server-side by the /mcp endpoint.+ // connections. Enforced server-side at two points: the /mcp endpoint decides+ // whether a connection is admitted at all, and the ceiling gate on the+ // internal MCP chain decides, per request, which method classes are served.McpCapability WorkspaceProfileSetting_MCPCapability `protobuf:"varint,26,opt,name=mcp_capability,json=mcpCapability,proto3,enum=bytebase.store.WorkspaceProfileSetting_MCPCapability" json:"mcp_capability,omitempty"`// Hex-encoded SHA-256 of the SCIM directory sync token. The plaintext is shown// once at rotation and never stored. SHA-256 rather than a slow KDF because thediff --git a/backend/generated-go/v1/access_grant_service.pb.go b/backend/generated-go/v1/access_grant_service.pb.goindex cfc0e2ba2f..8ec1417da0 100644--- a/backend/generated-go/v1/access_grant_service.pb.go+++ b/backend/generated-go/v1/access_grant_service.pb.go@@ -857,11 +857,11 @@ const file_v1_access_grant_service_proto_rawDesc = "" +"\raccess_grants\x18\x01 \x03(\v2\x18.bytebase.v1.AccessGrantR\faccessGrants\x12&\n" +"\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken2\x9c\t\n" +"\x12AccessGrantService\x12\xa6\x01\n" +- "\x0eGetAccessGrant\x12\".bytebase.v1.GetAccessGrantRequest\x1a\x18.bytebase.v1.AccessGrant\"V\xdaA\x04name\x8a\xea0\x13bb.accessGrants.get\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02&\x12$/v1/{name=projects/*/accessGrants/*}\x12\xba\x01\n" +- "\x10ListAccessGrants\x12$.bytebase.v1.ListAccessGrantsRequest\x1a%.bytebase.v1.ListAccessGrantsResponse\"Y\xdaA\x06parent\x8a\xea0\x14bb.accessGrants.list\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02&\x12$/v1/{parent=projects/*}/accessGrants\x12\xd0\x01\n" +- "\x11CreateAccessGrant\x12%.bytebase.v1.CreateAccessGrantRequest\x1a\x18.bytebase.v1.AccessGrant\"z\xdaA\x13parent,access_grant\x8a\xea0\x16bb.accessGrants.create\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x024:\faccess_grant\"$/v1/{parent=projects/*}/accessGrants\x12\xc5\x01\n" +- "\x13ActivateAccessGrant\x12'.bytebase.v1.ActivateAccessGrantRequest\x1a\x18.bytebase.v1.AccessGrant\"k\xdaA\x04name\x8a\xea0\x18bb.accessGrants.activate\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x022:\x01*\"-/v1/{name=projects/*/accessGrants/*}:activate\x12\xbd\x01\n" +- "\x11RevokeAccessGrant\x12%.bytebase.v1.RevokeAccessGrantRequest\x1a\x18.bytebase.v1.AccessGrant\"g\xdaA\x04name\x8a\xea0\x16bb.accessGrants.revoke\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x020:\x01*\"+/v1/{name=projects/*/accessGrants/*}:revoke\x12\xc4\x01\n" ++ "\x0eGetAccessGrant\x12\".bytebase.v1.GetAccessGrantRequest\x1a\x18.bytebase.v1.AccessGrant\"V\xdaA\x04name\x8a\xea0\x13bb.accessGrants.get\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02&\x12$/v1/{name=projects/*/accessGrants/*}\x12\xba\x01\n" ++ "\x10ListAccessGrants\x12$.bytebase.v1.ListAccessGrantsRequest\x1a%.bytebase.v1.ListAccessGrantsResponse\"Y\xdaA\x06parent\x8a\xea0\x14bb.accessGrants.list\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02&\x12$/v1/{parent=projects/*}/accessGrants\x12\xd0\x01\n" ++ "\x11CreateAccessGrant\x12%.bytebase.v1.CreateAccessGrantRequest\x1a\x18.bytebase.v1.AccessGrant\"z\xdaA\x13parent,access_grant\x8a\xea0\x16bb.accessGrants.create\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x024:\faccess_grant\"$/v1/{parent=projects/*}/accessGrants\x12\xc5\x01\n" ++ "\x13ActivateAccessGrant\x12'.bytebase.v1.ActivateAccessGrantRequest\x1a\x18.bytebase.v1.AccessGrant\"k\xdaA\x04name\x8a\xea0\x18bb.accessGrants.activate\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x022:\x01*\"-/v1/{name=projects/*/accessGrants/*}:activate\x12\xbd\x01\n" ++ "\x11RevokeAccessGrant\x12%.bytebase.v1.RevokeAccessGrantRequest\x1a\x18.bytebase.v1.AccessGrant\"g\xdaA\x04name\x8a\xea0\x16bb.accessGrants.revoke\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x020:\x01*\"+/v1/{name=projects/*/accessGrants/*}:revoke\x12\xc4\x01\n" +"\x14SearchMyAccessGrants\x12(.bytebase.v1.SearchMyAccessGrantsRequest\x1a).bytebase.v1.SearchMyAccessGrantsResponse\"W\x8a\xea0\x13bb.accessGrants.get\x90\xea0\x02\xa0\xea0\x01\x82\xd3\xe4\x93\x022:\x01*\"-/v1/{parent=projects/*}/accessGrants:searchMyB\xad\x01\n" +"\x0fcom.bytebase.v1B\x17AccessGrantServiceProtoP\x01Z4github.com/bytebase/bytebase/backend/generated-go/v1\xa2\x02\x03BXX\xaa\x02\vBytebase.V1\xca\x02\vBytebase\\V1\xe2\x02\x17Bytebase\\V1\\GPBMetadata\xea\x02\fBytebase::V1b\x06proto3"diff --git a/backend/generated-go/v1/actuator_service.pb.go b/backend/generated-go/v1/actuator_service.pb.goindex 1a9709b889..977780a473 100644--- a/backend/generated-go/v1/actuator_service.pb.go+++ b/backend/generated-go/v1/actuator_service.pb.go@@ -301,7 +301,7 @@ const file_v1_actuator_service_proto_rawDesc = "" +"\x10\vJ\x04\b\f\x10\rJ\x04\b\x0e\x10\x0fJ\x04\b\x10\x10\x14J\x04\b\x19\x10\x1a2\x97\x02\n" +"\x0fActuatorService\x12s\n" +"\x0fGetActuatorInfo\x12#.bytebase.v1.GetActuatorInfoRequest\x1a\x19.bytebase.v1.ActuatorInfo\" \xdaA\x00\xa0\xea0\x01\x82\xd3\xe4\x93\x02\x13\x12\x11/v1/actuator/info\x12\x8e\x01\n" +- "\vSetupSample\x12\x1f.bytebase.v1.SetupSampleRequest\x1a\x16.google.protobuf.Empty\"F\x8a\xea0\x12bb.projects.create\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x1a\"\x18/v1/actuator:setupSampleB\xaa\x01\n" ++ "\vSetupSample\x12\x1f.bytebase.v1.SetupSampleRequest\x1a\x16.google.protobuf.Empty\"F\x8a\xea0\x12bb.projects.create\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x1a\"\x18/v1/actuator:setupSampleB\xaa\x01\n" +"\x0fcom.bytebase.v1B\x14ActuatorServiceProtoP\x01Z4github.com/bytebase/bytebase/backend/generated-go/v1\xa2\x02\x03BXX\xaa\x02\vBytebase.V1\xca\x02\vBytebase\\V1\xe2\x02\x17Bytebase\\V1\\GPBMetadata\xea\x02\fBytebase::V1b\x06proto3"var (diff --git a/backend/generated-go/v1/ai_service.pb.go b/backend/generated-go/v1/ai_service.pb.goindex 09f8115edc..f0a8b318b5 100644--- a/backend/generated-go/v1/ai_service.pb.go+++ b/backend/generated-go/v1/ai_service.pb.go@@ -504,7 +504,7 @@ const file_v1_ai_service_proto_rawDesc = "" +"\x1eAI_CHAT_MESSAGE_ROLE_ASSISTANT\x10\x03\x12\x1d\n" +"\x19AI_CHAT_MESSAGE_ROLE_TOOL\x10\x042p\n" +"\tAIService\x12c\n" +- "\x04Chat\x12\x1a.bytebase.v1.AIChatRequest\x1a\x1b.bytebase.v1.AIChatResponse\"\"\x90\xea0\x02\xa0\xea0\x04\xb0\xea0\x04\x82\xd3\xe4\x93\x02\x10:\x01*\"\v/v1/ai/chatB\xa4\x01\n" ++ "\x04Chat\x12\x1a.bytebase.v1.AIChatRequest\x1a\x1b.bytebase.v1.AIChatResponse\"\"\x90\xea0\x02\xa0\xea0\x04\xa8\xea0\f\x82\xd3\xe4\x93\x02\x10:\x01*\"\v/v1/ai/chatB\xa4\x01\n" +"\x0fcom.bytebase.v1B\x0eAiServiceProtoP\x01Z4github.com/bytebase/bytebase/backend/generated-go/v1\xa2\x02\x03BXX\xaa\x02\vBytebase.V1\xca\x02\vBytebase\\V1\xe2\x02\x17Bytebase\\V1\\GPBMetadata\xea\x02\fBytebase::V1b\x06proto3"var (diff --git a/backend/generated-go/v1/annotation.pb.go b/backend/generated-go/v1/annotation.pb.goindex 99b5b941ce..d45cf2adb5 100644--- a/backend/generated-go/v1/annotation.pb.go+++ b/backend/generated-go/v1/annotation.pb.go@@ -79,18 +79,18 @@ func (AuthMethod) EnumDescriptor() ([]byte, []int) {// authorization of an MCP session is this classification intersected with the// caller's own RBAC: it can only ever narrow what the human could do, never// widen it.-// Only FORBIDDEN is enforced today. READ, WRITE and EXCLUDED are recorded-// classifications and nothing reads them at request time yet — the gate that-// selects between them is a later change. A method annotated READ or WRITE is-// therefore served exactly as it is today; the annotation states where it-// belongs, not where the boundary currently sits. FORBIDDEN is the exception-// and is enforced the moment it is annotated.+// Every value is enforced, at the gate on the internal MCP chain. READ and+// WRITE are the serving classes the workspace's MCP capability ceiling selects+// between, EXCLUDED and FORBIDDEN are served by no ceiling, and an unclassified+// method is refused rather than served. Annotating a method is therefore a+// change to what an MCP session can reach, taking effect on the next request.type MCPMethodClass int32const (- // Not yet classified. Reaches its handler, subject to RBAC as usual. CI- // rejects this value on any v1 RPC, so it survives only inside a build that- // has not been linted: a new RPC is classified before it can ship.+ // Not yet classified, and refused. CI rejects this value on any v1 RPC, so+ // it survives only inside a build that has not been linted: a new RPC is+ // classified before it can ship, and one that somehow reaches an MCP session+ // unclassified is denied rather than guessed at.MCPMethodClass_MCP_METHOD_CLASS_UNSPECIFIED MCPMethodClass = 0// Served to a read-only MCP session and above.MCPMethodClass_READ MCPMethodClass = 1@@ -104,9 +104,10 @@ const (// merely exercising a permission: a human with the permission uses the// console; an agent acting for them does not get to.MCPMethodClass_FORBIDDEN MCPMethodClass = 3- // Served by no MCP mode this phase ships, and not a durable never. These are- // workspace administration, plus the handful of methods that do something- // materially worse than the plain read permission they share suggests.+ // Served by no MCP capability ceiling this phase ships, and not a durable+ // never. These are workspace administration, plus the handful of methods+ // that do something materially worse than the plain read permission they+ // share suggests.//// The line against FORBIDDEN is reversibility. An admin-capable ceiling, if// one is ever built, could legitimately serve an EXCLUDED method — that is a@@ -162,130 +163,78 @@ func (MCPMethodClass) EnumDescriptor() ([]byte, []int) {return file_v1_annotation_proto_rawDescGZIP(), []int{1}}-// Why an RPC is FORBIDDEN to MCP sessions. The mechanism, not the wording:-// each value names what its methods actually do, and the serving side turns-// that into a sentence. A denial whose stated reason has drifted from the-// mechanism is worse than a bare refusal, because it is the thing the next-// reader trusts — so a method changing what it does changes its reason here.-type MCPForbiddenReason int32+// Why an MCP session may not call an RPC. The mechanism, not the wording: each+// value names what its methods actually do, and the serving side turns that+// into a sentence. A denial whose stated reason has drifted from the mechanism+// is worse than a bare refusal, because it is the thing the next reader trusts+// — so a method changing what it does changes its reason here.+//+// One enum covers both refused classes, and every value belongs to exactly one+// of them: values 1-8 name a mechanism that breaks the MCP boundary, which is+// what FORBIDDEN means, and values 9-13 name a scope decision this phase took,+// which is what EXCLUDED means. The distinction is real and lives on the class+// annotation — a FORBIDDEN mechanism is a durable never, an EXCLUDED scope+// decision is what a future admin-capable ceiling would argue with, one+// population at a time. Splitting it across two enums as well only made the+// nonsense states representable: a method could carry both, or carry the kind+// that contradicts its class. Neither is expressible now, and the one check+// left — the reason belongs to the class it is used on — is a table the gate+// already keeps for the wording.+type MCPDenialReason int32const (// No reason recorded. The method is still denied — mcp_method_class is what- // enforces — and the denial falls back to generic wording.- MCPForbiddenReason_MCP_FORBIDDEN_REASON_UNSPECIFIED MCPForbiddenReason = 0+ // enforces — and the denial falls back to generic wording. CI rejects this+ // on a method classified FORBIDDEN or EXCLUDED.+ MCPDenialReason_MCP_DENIAL_REASON_UNSPECIFIED MCPDenialReason = 0// Puts a token for the caller's own principal in the response body.- MCPForbiddenReason_MINTS_CREDENTIAL MCPForbiddenReason = 1+ MCPDenialReason_MINTS_CREDENTIAL MCPDenialReason = 1// Drives the out-of-band reset flow that sets or delivers the secret a// login accepts.- MCPForbiddenReason_RESETS_CREDENTIAL MCPForbiddenReason = 2+ MCPDenialReason_RESETS_CREDENTIAL MCPDenialReason = 2// Rewrites an account's own credentials, which would let the session log in// as that account.- MCPForbiddenReason_TAKES_OVER_ACCOUNT MCPForbiddenReason = 3+ MCPDenialReason_TAKES_OVER_ACCOUNT MCPDenialReason = 3// Destroys the human's own login session.- MCPForbiddenReason_ENDS_SESSION MCPForbiddenReason = 4+ MCPDenialReason_ENDS_SESSION MCPDenialReason = 4// Destroys the caller's own workspace membership and mints a plain// workspace token on the way out.- MCPForbiddenReason_ENDS_MEMBERSHIP MCPForbiddenReason = 5+ MCPDenialReason_ENDS_MEMBERSHIP MCPDenialReason = 5// Leaves someone holding a principal the caller is not — by issuing its// credential, carrying an existing one out to a host the caller named,// choosing what will later be trusted to mint one, or redirecting where one// gets delivered.- MCPForbiddenReason_MINTS_CREDENTIAL_FOR_OTHERS MCPForbiddenReason = 6+ MCPDenialReason_MINTS_CREDENTIAL_FOR_OTHERS MCPDenialReason = 6// Rewrites the workspace configuration that governs the session making the// call — the MCP switch itself, the sign-in and SSO settings, the mail// relay that carries credential resets, and the AI endpoint the stored API// key is sent to. A session that can widen its own ceiling is not bounded// by it.- MCPForbiddenReason_REWRITES_SESSION_BOUNDARY MCPForbiddenReason = 7+ MCPDenialReason_REWRITES_SESSION_BOUNDARY MCPDenialReason = 7// Works the human approval step that gates the change: recording the review// decision, or re-running the finding that sets it and can clear the issue// outright. An agent composes a change; it does not move its own change// through the gate.- MCPForbiddenReason_DRIVES_THE_APPROVAL_DECISION MCPForbiddenReason = 8-)--// Enum value maps for MCPForbiddenReason.-var (- MCPForbiddenReason_name = map[int32]string{- 0: "MCP_FORBIDDEN_REASON_UNSPECIFIED",- 1: "MINTS_CREDENTIAL",- 2: "RESETS_CREDENTIAL",- 3: "TAKES_OVER_ACCOUNT",- 4: "ENDS_SESSION",- 5: "ENDS_MEMBERSHIP",- 6: "MINTS_CREDENTIAL_FOR_OTHERS",- 7: "REWRITES_SESSION_BOUNDARY",- 8: "DRIVES_THE_APPROVAL_DECISION",- }- MCPForbiddenReason_value = map[string]int32{- "MCP_FORBIDDEN_REASON_UNSPECIFIED": 0,- "MINTS_CREDENTIAL": 1,- "RESETS_CREDENTIAL": 2,- "TAKES_OVER_ACCOUNT": 3,- "ENDS_SESSION": 4,- "ENDS_MEMBERSHIP": 5,- "MINTS_CREDENTIAL_FOR_OTHERS": 6,- "REWRITES_SESSION_BOUNDARY": 7,- "DRIVES_THE_APPROVAL_DECISION": 8,- }-)--func (x MCPForbiddenReason) Enum() *MCPForbiddenReason {- p := new(MCPForbiddenReason)- *p = x- return p-}--func (x MCPForbiddenReason) String() string {- return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))-}--func (MCPForbiddenReason) Descriptor() protoreflect.EnumDescriptor {- return file_v1_annotation_proto_enumTypes[2].Descriptor()-}--func (MCPForbiddenReason) Type() protoreflect.EnumType {- return &file_v1_annotation_proto_enumTypes[2]-}--func (x MCPForbiddenReason) Number() protoreflect.EnumNumber {- return protoreflect.EnumNumber(x)-}--// Deprecated: Use MCPForbiddenReason.Descriptor instead.-func (MCPForbiddenReason) EnumDescriptor() ([]byte, []int) {- return file_v1_annotation_proto_rawDescGZIP(), []int{2}-}--// Why an RPC is served by no MCP mode. Unlike MCPForbiddenReason, which names-// a mechanism that breaks the MCP boundary, these name a scope decision: the-// method is out because this phase ships two modes and neither is the right-// home for it. Each value is what a future admin-capable ceiling would have to-// argue with, one population at a time.-type MCPExclusionReason int32--const (- // No reason recorded. CI rejects this on a method classified EXCLUDED.- MCPExclusionReason_MCP_EXCLUSION_REASON_UNSPECIFIED MCPExclusionReason = 0+ MCPDenialReason_DRIVES_THE_APPROVAL_DECISION MCPDenialReason = 8// Administers the workspace rather than doing database work: identity,// credentials, access control, governance policy, billing, workspace and// instance configuration, project lifecycle, and the operator's own audit// trail. Reading is administration too where the read returns the privilege// topology or a stored secret rather than the state of a database.- MCPExclusionReason_ADMINISTERS_THE_WORKSPACE MCPExclusionReason = 1+ MCPDenialReason_ADMINISTERS_THE_WORKSPACE MCPDenialReason = 9// Returns SQL that other people wrote. The permission gating it reads as an// ordinary list permission, so the exclusion is per method rather than per// permission: these methods span the workspace or ignore the per-object// sharing that keeps a saved query private.- MCPExclusionReason_READS_OTHER_USERS_SQL MCPExclusionReason = 2+ MCPDenialReason_READS_OTHER_USERS_SQL MCPDenialReason = 10// Opens an admin-credentialed connection to the customer's database and// returns live session state from it — including other sessions' in-flight,// unmasked SQL. It shares a plain read permission with sibling methods that// only read Bytebase's own store.- MCPExclusionReason_OPENS_AN_ADMIN_CONNECTION MCPExclusionReason = 3+ MCPDenialReason_OPENS_AN_ADMIN_CONNECTION MCPDenialReason = 11// Spends a stored workspace credential on an outbound call to a third// party, which puts whatever the caller passes outside the product.- MCPExclusionReason_SENDS_DATA_TO_A_THIRD_PARTY MCPExclusionReason = 4+ MCPDenialReason_SENDS_DATA_TO_A_THIRD_PARTY MCPDenialReason = 12// Returns a stored secret in its response body today. These are ordinary// reads that belong in a serving class on their merits, and each is here// because of a leak that a redaction on the read path would close — the@@ -293,54 +242,70 @@ const (// therefore the one that is meant to go away: fixing the leak moves the// method to READ, as a reviewed widening, rather than leaving a quiet// exposure the moment the ceiling starts serving.- MCPExclusionReason_RETURNS_A_STORED_SECRET MCPExclusionReason = 5+ MCPDenialReason_RETURNS_A_STORED_SECRET MCPDenialReason = 13)-// Enum value maps for MCPExclusionReason.+// Enum value maps for MCPDenialReason.var (- MCPExclusionReason_name = map[int32]string{- 0: "MCP_EXCLUSION_REASON_UNSPECIFIED",- 1: "ADMINISTERS_THE_WORKSPACE",- 2: "READS_OTHER_USERS_SQL",- 3: "OPENS_AN_ADMIN_CONNECTION",- 4: "SENDS_DATA_TO_A_THIRD_PARTY",- 5: "RETURNS_A_STORED_SECRET",+ MCPDenialReason_name = map[int32]string{+ 0: "MCP_DENIAL_REASON_UNSPECIFIED",+ 1: "MINTS_CREDENTIAL",+ 2: "RESETS_CREDENTIAL",+ 3: "TAKES_OVER_ACCOUNT",+ 4: "ENDS_SESSION",+ 5: "ENDS_MEMBERSHIP",+ 6: "MINTS_CREDENTIAL_FOR_OTHERS",+ 7: "REWRITES_SESSION_BOUNDARY",+ 8: "DRIVES_THE_APPROVAL_DECISION",+ 9: "ADMINISTERS_THE_WORKSPACE",+ 10: "READS_OTHER_USERS_SQL",+ 11: "OPENS_AN_ADMIN_CONNECTION",+ 12: "SENDS_DATA_TO_A_THIRD_PARTY",+ 13: "RETURNS_A_STORED_SECRET",}- MCPExclusionReason_value = map[string]int32{- "MCP_EXCLUSION_REASON_UNSPECIFIED": 0,- "ADMINISTERS_THE_WORKSPACE": 1,- "READS_OTHER_USERS_SQL": 2,- "OPENS_AN_ADMIN_CONNECTION": 3,- "SENDS_DATA_TO_A_THIRD_PARTY": 4,- "RETURNS_A_STORED_SECRET": 5,+ MCPDenialReason_value = map[string]int32{+ "MCP_DENIAL_REASON_UNSPECIFIED": 0,+ "MINTS_CREDENTIAL": 1,+ "RESETS_CREDENTIAL": 2,+ "TAKES_OVER_ACCOUNT": 3,+ "ENDS_SESSION": 4,+ "ENDS_MEMBERSHIP": 5,+ "MINTS_CREDENTIAL_FOR_OTHERS": 6,+ "REWRITES_SESSION_BOUNDARY": 7,+ "DRIVES_THE_APPROVAL_DECISION": 8,+ "ADMINISTERS_THE_WORKSPACE": 9,+ "READS_OTHER_USERS_SQL": 10,+ "OPENS_AN_ADMIN_CONNECTION": 11,+ "SENDS_DATA_TO_A_THIRD_PARTY": 12,+ "RETURNS_A_STORED_SECRET": 13,})-func (x MCPExclusionReason) Enum() *MCPExclusionReason {- p := new(MCPExclusionReason)+func (x MCPDenialReason) Enum() *MCPDenialReason {+ p := new(MCPDenialReason)*p = xreturn p}-func (x MCPExclusionReason) String() string {+func (x MCPDenialReason) String() string {return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))}-func (MCPExclusionReason) Descriptor() protoreflect.EnumDescriptor {- return file_v1_annotation_proto_enumTypes[3].Descriptor()+func (MCPDenialReason) Descriptor() protoreflect.EnumDescriptor {+ return file_v1_annotation_proto_enumTypes[2].Descriptor()}-func (MCPExclusionReason) Type() protoreflect.EnumType {- return &file_v1_annotation_proto_enumTypes[3]+func (MCPDenialReason) Type() protoreflect.EnumType {+ return &file_v1_annotation_proto_enumTypes[2]}-func (x MCPExclusionReason) Number() protoreflect.EnumNumber {+func (x MCPDenialReason) Number() protoreflect.EnumNumber {return protoreflect.EnumNumber(x)}-// Deprecated: Use MCPExclusionReason.Descriptor instead.-func (MCPExclusionReason) EnumDescriptor() ([]byte, []int) {- return file_v1_annotation_proto_rawDescGZIP(), []int{3}+// Deprecated: Use MCPDenialReason.Descriptor instead.+func (MCPDenialReason) EnumDescriptor() ([]byte, []int) {+ return file_v1_annotation_proto_rawDescGZIP(), []int{2}}var file_v1_annotation_proto_extTypes = []protoimpl.ExtensionInfo{@@ -386,18 +351,10 @@ var file_v1_annotation_proto_extTypes = []protoimpl.ExtensionInfo{},{ExtendedType: (*descriptorpb.MethodOptions)(nil),- ExtensionType: (*MCPForbiddenReason)(nil),+ ExtensionType: (*MCPDenialReason)(nil),Field: 100005,- Name: "bytebase.v1.mcp_forbidden_reason",- Tag: "varint,100005,opt,name=mcp_forbidden_reason,enum=bytebase.v1.MCPForbiddenReason",- Filename: "v1/annotation.proto",- },- {- ExtendedType: (*descriptorpb.MethodOptions)(nil),- ExtensionType: (*MCPExclusionReason)(nil),- Field: 100006,- Name: "bytebase.v1.mcp_exclusion_reason",- Tag: "varint,100006,opt,name=mcp_exclusion_reason,enum=bytebase.v1.MCPExclusionReason",+ Name: "bytebase.v1.mcp_denial_reason",+ Tag: "varint,100005,opt,name=mcp_denial_reason,enum=bytebase.v1.MCPDenialReason",Filename: "v1/annotation.proto",},}@@ -424,20 +381,14 @@ var (//// optional bytebase.v1.MCPMethodClass mcp_method_class = 100004;E_McpMethodClass = &file_v1_annotation_proto_extTypes[4]- // Why the method is forbidden to MCP sessions. Meaningful only alongside- // mcp_method_class = FORBIDDEN; the denial names it so the agent, and the- // operator reading the audit row, learn why rather than just that it was- // refused.- //- // optional bytebase.v1.MCPForbiddenReason mcp_forbidden_reason = 100005;- E_McpForbiddenReason = &file_v1_annotation_proto_extTypes[5]- // Why the method is served by no MCP mode. Meaningful only alongside- // mcp_method_class = EXCLUDED, and required there: an exclusion whose reason- // nobody wrote down is one nobody can revisit, and these are the rows a- // later admin-capable ceiling has to re-decide one at a time.+ // Why an MCP session may not call the method. Meaningful only alongside+ // mcp_method_class = FORBIDDEN or EXCLUDED, and required on both: the denial+ // names it so the agent, and the operator reading the audit row, learn why+ // rather than just that it was refused, and an exclusion whose reason nobody+ // wrote down is one nobody can revisit.//- // optional bytebase.v1.MCPExclusionReason mcp_exclusion_reason = 100006;- E_McpExclusionReason = &file_v1_annotation_proto_extTypes[6]+ // optional bytebase.v1.MCPDenialReason mcp_denial_reason = 100005;+ E_McpDenialReason = &file_v1_annotation_proto_extTypes[5])var File_v1_annotation_proto protoreflect.FileDescriptor@@ -456,9 +407,9 @@ const file_v1_annotation_proto_rawDesc = "" +"\x04READ\x10\x01\x12\t\n" +"\x05WRITE\x10\x02\x12\r\n" +"\tFORBIDDEN\x10\x03\x12\f\n" +- "\bEXCLUDED\x10\x04*\x88\x02\n" +- "\x12MCPForbiddenReason\x12$\n" +- " MCP_FORBIDDEN_REASON_UNSPECIFIED\x10\x00\x12\x14\n" ++ "\bEXCLUDED\x10\x04*\x99\x03\n" ++ "\x0fMCPDenialReason\x12!\n" ++ "\x1dMCP_DENIAL_REASON_UNSPECIFIED\x10\x00\x12\x14\n" +"\x10MINTS_CREDENTIAL\x10\x01\x12\x15\n" +"\x11RESETS_CREDENTIAL\x10\x02\x12\x16\n" +"\x12TAKES_OVER_ACCOUNT\x10\x03\x12\x10\n" +@@ -466,14 +417,13 @@ const file_v1_annotation_proto_rawDesc = "" +"\x0fENDS_MEMBERSHIP\x10\x05\x12\x1f\n" +"\x1bMINTS_CREDENTIAL_FOR_OTHERS\x10\x06\x12\x1d\n" +"\x19REWRITES_SESSION_BOUNDARY\x10\a\x12 \n" +- "\x1cDRIVES_THE_APPROVAL_DECISION\x10\b*\xd1\x01\n" +- "\x12MCPExclusionReason\x12$\n" +- " MCP_EXCLUSION_REASON_UNSPECIFIED\x10\x00\x12\x1d\n" +- "\x19ADMINISTERS_THE_WORKSPACE\x10\x01\x12\x19\n" +- "\x15READS_OTHER_USERS_SQL\x10\x02\x12\x1d\n" +- "\x19OPENS_AN_ADMIN_CONNECTION\x10\x03\x12\x1f\n" +- "\x1bSENDS_DATA_TO_A_THIRD_PARTY\x10\x04\x12\x1b\n" +- "\x17RETURNS_A_STORED_SECRET\x10\x05:Z\n" ++ "\x1cDRIVES_THE_APPROVAL_DECISION\x10\b\x12\x1d\n" ++ "\x19ADMINISTERS_THE_WORKSPACE\x10\t\x12\x19\n" ++ "\x15READS_OTHER_USERS_SQL\x10\n" ++ "\x12\x1d\n" ++ "\x19OPENS_AN_ADMIN_CONNECTION\x10\v\x12\x1f\n" ++ "\x1bSENDS_DATA_TO_A_THIRD_PARTY\x10\f\x12\x1b\n" ++ "\x17RETURNS_A_STORED_SECRET\x10\r:Z\n" +"\x18allow_without_credential\x12\x1e.google.protobuf.MethodOptions\x18\xa0\x8d\x06 \x01(\bR\x16allowWithoutCredential:@\n" +"\n" +"permission\x12\x1e.google.protobuf.MethodOptions\x18\xa1\x8d\x06 \x01(\tR\n" +@@ -481,9 +431,8 @@ const file_v1_annotation_proto_rawDesc = "" +"\vauth_method\x12\x1e.google.protobuf.MethodOptions\x18\xa2\x8d\x06 \x01(\x0e2\x17.bytebase.v1.AuthMethodR\n" +"authMethod:6\n" +"\x05audit\x12\x1e.google.protobuf.MethodOptions\x18\xa3\x8d\x06 \x01(\bR\x05audit:g\n" +- "\x10mcp_method_class\x12\x1e.google.protobuf.MethodOptions\x18\xa4\x8d\x06 \x01(\x0e2\x1b.bytebase.v1.MCPMethodClassR\x0emcpMethodClass:s\n" +- "\x14mcp_forbidden_reason\x12\x1e.google.protobuf.MethodOptions\x18\xa5\x8d\x06 \x01(\x0e2\x1f.bytebase.v1.MCPForbiddenReasonR\x12mcpForbiddenReason:s\n" +- "\x14mcp_exclusion_reason\x12\x1e.google.protobuf.MethodOptions\x18\xa6\x8d\x06 \x01(\x0e2\x1f.bytebase.v1.MCPExclusionReasonR\x12mcpExclusionReasonB\xa5\x01\n" ++ "\x10mcp_method_class\x12\x1e.google.protobuf.MethodOptions\x18\xa4\x8d\x06 \x01(\x0e2\x1b.bytebase.v1.MCPMethodClassR\x0emcpMethodClass:j\n" ++ "\x11mcp_denial_reason\x12\x1e.google.protobuf.MethodOptions\x18\xa5\x8d\x06 \x01(\x0e2\x1c.bytebase.v1.MCPDenialReasonR\x0fmcpDenialReasonB\xa5\x01\n" +"\x0fcom.bytebase.v1B\x0fAnnotationProtoP\x01Z4github.com/bytebase/bytebase/backend/generated-go/v1\xa2\x02\x03BXX\xaa\x02\vBytebase.V1\xca\x02\vBytebase\\V1\xe2\x02\x17Bytebase\\V1\\GPBMetadata\xea\x02\fBytebase::V1b\x06proto3"var (@@ -498,31 +447,28 @@ func file_v1_annotation_proto_rawDescGZIP() []byte {return file_v1_annotation_proto_rawDescData}-var file_v1_annotation_proto_enumTypes = make([]protoimpl.EnumInfo, 4)+var file_v1_annotation_proto_enumTypes = make([]protoimpl.EnumInfo, 3)var file_v1_annotation_proto_goTypes = []any{(AuthMethod)(0), // 0: bytebase.v1.AuthMethod(MCPMethodClass)(0), // 1: bytebase.v1.MCPMethodClass- (MCPForbiddenReason)(0), // 2: bytebase.v1.MCPForbiddenReason- (MCPExclusionReason)(0), // 3: bytebase.v1.MCPExclusionReason- (*descriptorpb.MethodOptions)(nil), // 4: google.protobuf.MethodOptions+ (MCPDenialReason)(0), // 2: bytebase.v1.MCPDenialReason+ (*descriptorpb.MethodOptions)(nil), // 3: google.protobuf.MethodOptions}var file_v1_annotation_proto_depIdxs = []int32{- 4, // 0: bytebase.v1.allow_without_credential:extendee -> google.protobuf.MethodOptions- 4, // 1: bytebase.v1.permission:extendee -> google.protobuf.MethodOptions- 4, // 2: bytebase.v1.auth_method:extendee -> google.protobuf.MethodOptions- 4, // 3: bytebase.v1.audit:extendee -> google.protobuf.MethodOptions- 4, // 4: bytebase.v1.mcp_method_class:extendee -> google.protobuf.MethodOptions- 4, // 5: bytebase.v1.mcp_forbidden_reason:extendee -> google.protobuf.MethodOptions- 4, // 6: bytebase.v1.mcp_exclusion_reason:extendee -> google.protobuf.MethodOptions- 0, // 7: bytebase.v1.auth_method:type_name -> bytebase.v1.AuthMethod- 1, // 8: bytebase.v1.mcp_method_class:type_name -> bytebase.v1.MCPMethodClass- 2, // 9: bytebase.v1.mcp_forbidden_reason:type_name -> bytebase.v1.MCPForbiddenReason- 3, // 10: bytebase.v1.mcp_exclusion_reason:type_name -> bytebase.v1.MCPExclusionReason- 11, // [11:11] is the sub-list for method output_type- 11, // [11:11] is the sub-list for method input_type- 7, // [7:11] is the sub-list for extension type_name- 0, // [0:7] is the sub-list for extension extendee- 0, // [0:0] is the sub-list for field type_name+ 3, // 0: bytebase.v1.allow_without_credential:extendee -> google.protobuf.MethodOptions+ 3, // 1: bytebase.v1.permission:extendee -> google.protobuf.MethodOptions+ 3, // 2: bytebase.v1.auth_method:extendee -> google.protobuf.MethodOptions+ 3, // 3: bytebase.v1.audit:extendee -> google.protobuf.MethodOptions+ 3, // 4: bytebase.v1.mcp_method_class:extendee -> google.protobuf.MethodOptions+ 3, // 5: bytebase.v1.mcp_denial_reason:extendee -> google.protobuf.MethodOptions+ 0, // 6: bytebase.v1.auth_method:type_name -> bytebase.v1.AuthMethod+ 1, // 7: bytebase.v1.mcp_method_class:type_name -> bytebase.v1.MCPMethodClass+ 2, // 8: bytebase.v1.mcp_denial_reason:type_name -> bytebase.v1.MCPDenialReason+ 9, // [9:9] is the sub-list for method output_type+ 9, // [9:9] is the sub-list for method input_type+ 6, // [6:9] is the sub-list for extension type_name+ 0, // [0:6] is the sub-list for extension extendee+ 0, // [0:0] is the sub-list for field type_name}func init() { file_v1_annotation_proto_init() }@@ -535,9 +481,9 @@ func file_v1_annotation_proto_init() {File: protoimpl.DescBuilder{GoPackagePath: reflect.TypeOf(x{}).PkgPath(),RawDescriptor: unsafe.Slice(unsafe.StringData(file_v1_annotation_proto_rawDesc), len(file_v1_annotation_proto_rawDesc)),- NumEnums: 4,+ NumEnums: 3,NumMessages: 0,- NumExtensions: 7,+ NumExtensions: 6,NumServices: 0,},GoTypes: file_v1_annotation_proto_goTypes,diff --git a/backend/generated-go/v1/audit_log_service.pb.go b/backend/generated-go/v1/audit_log_service.pb.goindex 79e627064b..f0e05da272 100644--- a/backend/generated-go/v1/audit_log_service.pb.go+++ b/backend/generated-go/v1/audit_log_service.pb.go@@ -828,8 +828,8 @@ const file_v1_audit_log_service_proto_rawDesc = "" +"\tclient_id\x18\x03 \x01(\tR\bclientId\x12%\n" +"\x0ecorrelation_id\x18\x04 \x01(\tR\rcorrelationId2\xb9\x03\n" +"\x0fAuditLogService\x12\xcf\x01\n" +- "\x0fSearchAuditLogs\x12#.bytebase.v1.SearchAuditLogsRequest\x1a$.bytebase.v1.SearchAuditLogsResponse\"q\x8a\xea0\x13bb.auditLogs.search\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02H:\x01*Z\x19:\x01*\"\x14/v1/auditLogs:search\"(/v1/{parent=projects/*}/auditLogs:search\x12\xd3\x01\n" +- "\x0fExportAuditLogs\x12#.bytebase.v1.ExportAuditLogsRequest\x1a$.bytebase.v1.ExportAuditLogsResponse\"u\x8a\xea0\x13bb.auditLogs.export\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02H:\x01*Z\x19:\x01*\"\x14/v1/auditLogs:export\"(/v1/{parent=projects/*}/auditLogs:exportB\xaa\x01\n" ++ "\x0fSearchAuditLogs\x12#.bytebase.v1.SearchAuditLogsRequest\x1a$.bytebase.v1.SearchAuditLogsResponse\"q\x8a\xea0\x13bb.auditLogs.search\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02H:\x01*Z\x19:\x01*\"\x14/v1/auditLogs:search\"(/v1/{parent=projects/*}/auditLogs:search\x12\xd3\x01\n" ++ "\x0fExportAuditLogs\x12#.bytebase.v1.ExportAuditLogsRequest\x1a$.bytebase.v1.ExportAuditLogsResponse\"u\x8a\xea0\x13bb.auditLogs.export\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02H:\x01*Z\x19:\x01*\"\x14/v1/auditLogs:export\"(/v1/{parent=projects/*}/auditLogs:exportB\xaa\x01\n" +"\x0fcom.bytebase.v1B\x14AuditLogServiceProtoP\x01Z4github.com/bytebase/bytebase/backend/generated-go/v1\xa2\x02\x03BXX\xaa\x02\vBytebase.V1\xca\x02\vBytebase\\V1\xe2\x02\x17Bytebase\\V1\\GPBMetadata\xea\x02\fBytebase::V1b\x06proto3"var (diff --git a/backend/generated-go/v1/database_catalog_service.pb.go b/backend/generated-go/v1/database_catalog_service.pb.goindex 49c5878b10..ce48139d48 100644--- a/backend/generated-go/v1/database_catalog_service.pb.go+++ b/backend/generated-go/v1/database_catalog_service.pb.go@@ -796,7 +796,7 @@ const file_v1_database_catalog_service_proto_rawDesc = "" +"\x04kind2\xc5\x04\n" +"\x16DatabaseCatalogService\x12\xf2\x01\n" +"\x12GetDatabaseCatalog\x12&.bytebase.v1.GetDatabaseCatalogRequest\x1a\x1c.bytebase.v1.DatabaseCatalog\"\x95\x01\xdaA\x04name\x8a\xea0\x17bb.databaseCatalogs.get\x90\xea0\x01\xa0\xea0\x01\x82\xd3\xe4\x93\x02eZ7\x125/v1/{name=projects/*/instances/*/databases/*/catalog}\x12*/v1/{name=instances/*/databases/*/catalog}\x12\xb5\x02\n" +- "\x15UpdateDatabaseCatalog\x12).bytebase.v1.UpdateDatabaseCatalogRequest\x1a\x1c.bytebase.v1.DatabaseCatalog\"\xd2\x01\xdaA\x13catalog,update_mask\x8a\xea0\x1abb.databaseCatalogs.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x87\x01:\acatalogZH:\acatalog2=/v1/{catalog.name=projects/*/instances/*/databases/*/catalog}22/v1/{catalog.name=instances/*/databases/*/catalog}B\xb1\x01\n" ++ "\x15UpdateDatabaseCatalog\x12).bytebase.v1.UpdateDatabaseCatalogRequest\x1a\x1c.bytebase.v1.DatabaseCatalog\"\xd2\x01\xdaA\x13catalog,update_mask\x8a\xea0\x1abb.databaseCatalogs.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x87\x01:\acatalogZH:\acatalog2=/v1/{catalog.name=projects/*/instances/*/databases/*/catalog}22/v1/{catalog.name=instances/*/databases/*/catalog}B\xb1\x01\n" +"\x0fcom.bytebase.v1B\x1bDatabaseCatalogServiceProtoP\x01Z4github.com/bytebase/bytebase/backend/generated-go/v1\xa2\x02\x03BXX\xaa\x02\vBytebase.V1\xca\x02\vBytebase\\V1\xe2\x02\x17Bytebase\\V1\\GPBMetadata\xea\x02\fBytebase::V1b\x06proto3"var (diff --git a/backend/generated-go/v1/group_service.pb.go b/backend/generated-go/v1/group_service.pb.goindex 8c70c49b54..faf9b1173e 100644--- a/backend/generated-go/v1/group_service.pb.go+++ b/backend/generated-go/v1/group_service.pb.go@@ -730,15 +730,15 @@ const file_v1_group_service_proto_rawDesc = "" +"\x05email\x18\x06 \x01(\tR\x05email:'\xeaA$\n" +"\x12bytebase.com/Group\x12\x0egroups/{group}2\xec\x06\n" +"\fGroupService\x12}\n" +- "\bGetGroup\x12\x1c.bytebase.v1.GetGroupRequest\x1a\x12.bytebase.v1.Group\"?\xdaA\x04name\x8a\xea0\rbb.groups.get\x90\xea0\x02\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x15\x12\x13/v1/{name=groups/*}\x12\x93\x01\n" +- "\x0eBatchGetGroups\x12\".bytebase.v1.BatchGetGroupsRequest\x1a#.bytebase.v1.BatchGetGroupsResponse\"8\x8a\xea0\rbb.groups.get\x90\xea0\x02\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x15\x12\x13/v1/groups:batchGet\x12\x82\x01\n" ++ "\bGetGroup\x12\x1c.bytebase.v1.GetGroupRequest\x1a\x12.bytebase.v1.Group\"?\xdaA\x04name\x8a\xea0\rbb.groups.get\x90\xea0\x02\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x15\x12\x13/v1/{name=groups/*}\x12\x93\x01\n" ++ "\x0eBatchGetGroups\x12\".bytebase.v1.BatchGetGroupsRequest\x1a#.bytebase.v1.BatchGetGroupsResponse\"8\x8a\xea0\rbb.groups.get\x90\xea0\x02\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x15\x12\x13/v1/groups:batchGet\x12\x82\x01\n" +"\n" +- "ListGroups\x12\x1e.bytebase.v1.ListGroupsRequest\x1a\x1f.bytebase.v1.ListGroupsResponse\"3\xdaA\x00\x8a\xea0\x0ebb.groups.list\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\f\x12\n" ++ "ListGroups\x12\x1e.bytebase.v1.ListGroupsRequest\x1a\x1f.bytebase.v1.ListGroupsResponse\"3\xdaA\x00\x8a\xea0\x0ebb.groups.list\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\f\x12\n" +"/v1/groups\x12\x89\x01\n" +- "\vCreateGroup\x12\x1f.bytebase.v1.CreateGroupRequest\x1a\x12.bytebase.v1.Group\"E\xdaA\x05group\x8a\xea0\x10bb.groups.create\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x13:\x05group\"\n" ++ "\vCreateGroup\x12\x1f.bytebase.v1.CreateGroupRequest\x1a\x12.bytebase.v1.Group\"E\xdaA\x05group\x8a\xea0\x10bb.groups.create\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x13:\x05group\"\n" +"/v1/groups\x12\xa4\x01\n" +- "\vUpdateGroup\x12\x1f.bytebase.v1.UpdateGroupRequest\x1a\x12.bytebase.v1.Group\"`\xdaA\x11group,update_mask\x8a\xea0\x10bb.groups.update\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\":\x05group2\x19/v1/{group.name=groups/*}\x12\x8e\x01\n" +- "\vDeleteGroup\x12\x1f.bytebase.v1.DeleteGroupRequest\x1a\x16.google.protobuf.Empty\"F\xdaA\x04name\x8a\xea0\x10bb.groups.delete\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x15*\x13/v1/{name=groups/*}B\xa7\x01\n" ++ "\vUpdateGroup\x12\x1f.bytebase.v1.UpdateGroupRequest\x1a\x12.bytebase.v1.Group\"`\xdaA\x11group,update_mask\x8a\xea0\x10bb.groups.update\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\":\x05group2\x19/v1/{group.name=groups/*}\x12\x8e\x01\n" ++ "\vDeleteGroup\x12\x1f.bytebase.v1.DeleteGroupRequest\x1a\x16.google.protobuf.Empty\"F\xdaA\x04name\x8a\xea0\x10bb.groups.delete\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x15*\x13/v1/{name=groups/*}B\xa7\x01\n" +"\x0fcom.bytebase.v1B\x11GroupServiceProtoP\x01Z4github.com/bytebase/bytebase/backend/generated-go/v1\xa2\x02\x03BXX\xaa\x02\vBytebase.V1\xca\x02\vBytebase\\V1\xe2\x02\x17Bytebase\\V1\\GPBMetadata\xea\x02\fBytebase::V1b\x06proto3"var (diff --git a/backend/generated-go/v1/idp_service.pb.go b/backend/generated-go/v1/idp_service.pb.goindex 2ff92db44a..84e2ab2335 100644--- a/backend/generated-go/v1/idp_service.pb.go+++ b/backend/generated-go/v1/idp_service.pb.go@@ -1536,11 +1536,11 @@ const file_v1_idp_service_proto_rawDesc = "" +"\tIN_PARAMS\x10\x01\x12\r\n" +"\tIN_HEADER\x10\x022\x8f\t\n" +"\x17IdentityProviderService\x12\xa7\x01\n" +- "\x13GetIdentityProvider\x12'.bytebase.v1.GetIdentityProviderRequest\x1a\x1d.bytebase.v1.IdentityProvider\"H\xdaA\x04name\x8a\xea0\x18bb.identityProviders.get\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x13\x12\x11/v1/{name=idps/*}\x12\xb1\x01\n" +- "\x15ListIdentityProviders\x12).bytebase.v1.ListIdentityProvidersRequest\x1a*.bytebase.v1.ListIdentityProvidersResponse\"A\xdaA\x00\x80\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02,Z \x12\x1e/v1/{parent=workspaces/*}/idps\x12\b/v1/idps\x12\xba\x01\n" ++ "\x13GetIdentityProvider\x12'.bytebase.v1.GetIdentityProviderRequest\x1a\x1d.bytebase.v1.IdentityProvider\"H\xdaA\x04name\x8a\xea0\x18bb.identityProviders.get\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x13\x12\x11/v1/{name=idps/*}\x12\xb1\x01\n" ++ "\x15ListIdentityProviders\x12).bytebase.v1.ListIdentityProvidersRequest\x1a*.bytebase.v1.ListIdentityProvidersResponse\"A\xdaA\x00\x80\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02,Z \x12\x1e/v1/{parent=workspaces/*}/idps\x12\b/v1/idps\x12\xba\x01\n" +"\x16CreateIdentityProvider\x12*.bytebase.v1.CreateIdentityProviderRequest\x1a\x1d.bytebase.v1.IdentityProvider\"U\xdaA\x00\x8a\xea0\x1bbb.identityProviders.create\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x03\xa8\xea0\x06\x82\xd3\xe4\x93\x02\x1d:\x11identity_provider\"\b/v1/idps\x12\xf3\x01\n" +"\x16UpdateIdentityProvider\x12*.bytebase.v1.UpdateIdentityProviderRequest\x1a\x1d.bytebase.v1.IdentityProvider\"\x8d\x01\xdaA\x1didentity_provider,update_mask\x8a\xea0\x1bbb.identityProviders.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x03\xa8\xea0\x06\x82\xd3\xe4\x93\x028:\x11identity_provider2#/v1/{identity_provider.name=idps/*}\x12\xad\x01\n" +- "\x16DeleteIdentityProvider\x12*.bytebase.v1.DeleteIdentityProviderRequest\x1a\x16.google.protobuf.Empty\"O\xdaA\x04name\x8a\xea0\x1bbb.identityProviders.delete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x13*\x11/v1/{name=idps/*}\x12\xb2\x01\n" ++ "\x16DeleteIdentityProvider\x12*.bytebase.v1.DeleteIdentityProviderRequest\x1a\x16.google.protobuf.Empty\"O\xdaA\x04name\x8a\xea0\x1bbb.identityProviders.delete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x13*\x11/v1/{name=idps/*}\x12\xb2\x01\n" +"\x14TestIdentityProvider\x12(.bytebase.v1.TestIdentityProviderRequest\x1a).bytebase.v1.TestIdentityProviderResponse\"E\x8a\xea0\x1bbb.identityProviders.update\x90\xea0\x01\xa0\xea0\x03\xa8\xea0\x06\x82\xd3\xe4\x93\x02\x14:\x01*\"\x0f/v1/idps/*:testB\xa5\x01\n" +"\x0fcom.bytebase.v1B\x0fIdpServiceProtoP\x01Z4github.com/bytebase/bytebase/backend/generated-go/v1\xa2\x02\x03BXX\xaa\x02\vBytebase.V1\xca\x02\vBytebase\\V1\xe2\x02\x17Bytebase\\V1\\GPBMetadata\xea\x02\fBytebase::V1b\x06proto3"diff --git a/backend/generated-go/v1/instance_role_service.pb.go b/backend/generated-go/v1/instance_role_service.pb.goindex fd0fedabac..b6cbad41a1 100644--- a/backend/generated-go/v1/instance_role_service.pb.go+++ b/backend/generated-go/v1/instance_role_service.pb.go@@ -284,7 +284,7 @@ const file_v1_instance_role_service_proto_rawDesc = "" +"\n" +"_attribute2\xfe\x01\n" +"\x13InstanceRoleService\x12\xe6\x01\n" +- "\x11ListInstanceRoles\x12%.bytebase.v1.ListInstanceRolesRequest\x1a&.bytebase.v1.ListInstanceRolesResponse\"\x81\x01\xdaA\x06parent\x8a\xea0\x15bb.instanceRoles.list\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x05\x82\xd3\xe4\x93\x02MZ+\x12)/v1/{parent=projects/*/instances/*}/roles\x12\x1e/v1/{parent=instances/*}/rolesB\xae\x01\n" ++ "\x11ListInstanceRoles\x12%.bytebase.v1.ListInstanceRolesRequest\x1a&.bytebase.v1.ListInstanceRolesResponse\"\x81\x01\xdaA\x06parent\x8a\xea0\x15bb.instanceRoles.list\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\r\x82\xd3\xe4\x93\x02MZ+\x12)/v1/{parent=projects/*/instances/*}/roles\x12\x1e/v1/{parent=instances/*}/rolesB\xae\x01\n" +"\x0fcom.bytebase.v1B\x18InstanceRoleServiceProtoP\x01Z4github.com/bytebase/bytebase/backend/generated-go/v1\xa2\x02\x03BXX\xaa\x02\vBytebase.V1\xca\x02\vBytebase\\V1\xe2\x02\x17Bytebase\\V1\\GPBMetadata\xea\x02\fBytebase::V1b\x06proto3"var (diff --git a/backend/generated-go/v1/instance_service.pb.go b/backend/generated-go/v1/instance_service.pb.goindex 35ac35e5f0..776ccf39a3 100644--- a/backend/generated-go/v1/instance_service.pb.go+++ b/backend/generated-go/v1/instance_service.pb.go@@ -3361,18 +3361,18 @@ const file_v1_instance_service_proto_rawDesc = "" +"\x05ADMIN\x10\x01\x12\r\n" +"\tREAD_ONLY\x10\x022\xb8\x16\n" +"\x0fInstanceService\x12\xb1\x01\n" +- "\vGetInstance\x12\x1f.bytebase.v1.GetInstanceRequest\x1a\x15.bytebase.v1.Instance\"j\xdaA\x04name\x8a\xea0\x10bb.instances.get\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x05\x82\xd3\xe4\x93\x02=Z#\x12!/v1/{name=projects/*/instances/*}\x12\x16/v1/{name=instances/*}\x12\xb6\x01\n" +- "\rListInstances\x12!.bytebase.v1.ListInstancesRequest\x1a\".bytebase.v1.ListInstancesResponse\"^\xdaA\x00\x8a\xea0\x11bb.instances.list\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x05\x82\xd3\xe4\x93\x024Z#\x12!/v1/{parent=projects/*}/instances\x12\r/v1/instances\x12\xce\x01\n" +- "\x0eCreateInstance\x12\".bytebase.v1.CreateInstanceRequest\x1a\x15.bytebase.v1.Instance\"\x80\x01\xdaA\binstance\x8a\xea0\x13bb.instances.create\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02H:\binstanceZ-:\binstance\"!/v1/{parent=projects/*}/instances\"\r/v1/instances\x12\xf5\x01\n" +- "\x0eUpdateInstance\x12\".bytebase.v1.UpdateInstanceRequest\x1a\x15.bytebase.v1.Instance\"\xa7\x01\xdaA\x14instance,update_mask\x8a\xea0\x13bb.instances.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02c:\binstanceZ6:\binstance2*/v1/{instance.name=projects/*/instances/*}2\x1f/v1/{instance.name=instances/*}\x12\xbf\x01\n" +- "\x0eDeleteInstance\x12\".bytebase.v1.DeleteInstanceRequest\x1a\x16.google.protobuf.Empty\"q\xdaA\x04name\x8a\xea0\x13bb.instances.delete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02=Z#*!/v1/{name=projects/*/instances/*}*\x16/v1/{name=instances/*}\x12\xd6\x01\n" +- "\x10UndeleteInstance\x12$.bytebase.v1.UndeleteInstanceRequest\x1a\x15.bytebase.v1.Instance\"\x84\x01\x8a\xea0\x15bb.instances.undelete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02U:\x01*Z/:\x01*\"*/v1/{name=projects/*/instances/*}:undelete\"\x1f/v1/{name=instances/*}:undelete\x12\xc5\x01\n" ++ "\vGetInstance\x12\x1f.bytebase.v1.GetInstanceRequest\x1a\x15.bytebase.v1.Instance\"j\xdaA\x04name\x8a\xea0\x10bb.instances.get\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\r\x82\xd3\xe4\x93\x02=Z#\x12!/v1/{name=projects/*/instances/*}\x12\x16/v1/{name=instances/*}\x12\xb6\x01\n" ++ "\rListInstances\x12!.bytebase.v1.ListInstancesRequest\x1a\".bytebase.v1.ListInstancesResponse\"^\xdaA\x00\x8a\xea0\x11bb.instances.list\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\r\x82\xd3\xe4\x93\x024Z#\x12!/v1/{parent=projects/*}/instances\x12\r/v1/instances\x12\xce\x01\n" ++ "\x0eCreateInstance\x12\".bytebase.v1.CreateInstanceRequest\x1a\x15.bytebase.v1.Instance\"\x80\x01\xdaA\binstance\x8a\xea0\x13bb.instances.create\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02H:\binstanceZ-:\binstance\"!/v1/{parent=projects/*}/instances\"\r/v1/instances\x12\xf5\x01\n" ++ "\x0eUpdateInstance\x12\".bytebase.v1.UpdateInstanceRequest\x1a\x15.bytebase.v1.Instance\"\xa7\x01\xdaA\x14instance,update_mask\x8a\xea0\x13bb.instances.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02c:\binstanceZ6:\binstance2*/v1/{instance.name=projects/*/instances/*}2\x1f/v1/{instance.name=instances/*}\x12\xbf\x01\n" ++ "\x0eDeleteInstance\x12\".bytebase.v1.DeleteInstanceRequest\x1a\x16.google.protobuf.Empty\"q\xdaA\x04name\x8a\xea0\x13bb.instances.delete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02=Z#*!/v1/{name=projects/*/instances/*}*\x16/v1/{name=instances/*}\x12\xd6\x01\n" ++ "\x10UndeleteInstance\x12$.bytebase.v1.UndeleteInstanceRequest\x1a\x15.bytebase.v1.Instance\"\x84\x01\x8a\xea0\x15bb.instances.undelete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02U:\x01*Z/:\x01*\"*/v1/{name=projects/*/instances/*}:undelete\"\x1f/v1/{name=instances/*}:undelete\x12\xc5\x01\n" +"\fSyncInstance\x12 .bytebase.v1.SyncInstanceRequest\x1a!.bytebase.v1.SyncInstanceResponse\"p\x8a\xea0\x11bb.instances.sync\x90\xea0\x01\xa0\xea0\x02\x82\xd3\xe4\x93\x02M:\x01*Z+:\x01*\"&/v1/{name=projects/*/instances/*}:sync\"\x1b/v1/{name=instances/*}:sync\x12\xea\x01\n" +- "\x14ListInstanceDatabase\x12(.bytebase.v1.ListInstanceDatabaseRequest\x1a).bytebase.v1.ListInstanceDatabaseResponse\"}\x8a\xea0\x10bb.instances.get\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02W:\x01*Z0:\x01*\"+/v1/{name=projects/*/instances/*}:databases\" /v1/{name=instances/*}:databases\x12\xd8\x01\n" ++ "\x14ListInstanceDatabase\x12(.bytebase.v1.ListInstanceDatabaseRequest\x1a).bytebase.v1.ListInstanceDatabaseResponse\"}\x8a\xea0\x10bb.instances.get\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02W:\x01*Z0:\x01*\"+/v1/{name=projects/*/instances/*}:databases\" /v1/{name=instances/*}:databases\x12\xd8\x01\n" +"\x12BatchSyncInstances\x12&.bytebase.v1.BatchSyncInstancesRequest\x1a'.bytebase.v1.BatchSyncInstancesResponse\"q\x8a\xea0\x11bb.instances.sync\x90\xea0\x01\xa0\xea0\x02\x82\xd3\xe4\x93\x02N:\x01*Z0:\x01*\"+/v1/{parent=projects/*}/instances:batchSync\"\x17/v1/instances:batchSync\x12\xec\x01\n" +- "\x14BatchUpdateInstances\x12(.bytebase.v1.BatchUpdateInstancesRequest\x1a).bytebase.v1.BatchUpdateInstancesResponse\"\x7f\x8a\xea0\x13bb.instances.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02R:\x01*Z2:\x01*\"-/v1/{parent=projects/*}/instances:batchUpdate\"\x19/v1/instances:batchUpdate\x12\xd8\x01\n" +- "\rAddDataSource\x12!.bytebase.v1.AddDataSourceRequest\x1a\x15.bytebase.v1.Instance\"\x8c\x01\x8a\xea0\x13bb.instances.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02_:\x01*Z4:\x01*\"//v1/{name=projects/*/instances/*}:addDataSource\"$/v1/{name=instances/*}:addDataSource\x12\xe4\x01\n" +- "\x10RemoveDataSource\x12$.bytebase.v1.RemoveDataSourceRequest\x1a\x15.bytebase.v1.Instance\"\x92\x01\x8a\xea0\x13bb.instances.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02e:\x01*Z7:\x01*\"2/v1/{name=projects/*/instances/*}:removeDataSource\"'/v1/{name=instances/*}:removeDataSource\x12\x92\x02\n" ++ "\x14BatchUpdateInstances\x12(.bytebase.v1.BatchUpdateInstancesRequest\x1a).bytebase.v1.BatchUpdateInstancesResponse\"\x7f\x8a\xea0\x13bb.instances.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02R:\x01*Z2:\x01*\"-/v1/{parent=projects/*}/instances:batchUpdate\"\x19/v1/instances:batchUpdate\x12\xd8\x01\n" ++ "\rAddDataSource\x12!.bytebase.v1.AddDataSourceRequest\x1a\x15.bytebase.v1.Instance\"\x8c\x01\x8a\xea0\x13bb.instances.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02_:\x01*Z4:\x01*\"//v1/{name=projects/*/instances/*}:addDataSource\"$/v1/{name=instances/*}:addDataSource\x12\xe4\x01\n" ++ "\x10RemoveDataSource\x12$.bytebase.v1.RemoveDataSourceRequest\x1a\x15.bytebase.v1.Instance\"\x92\x01\x8a\xea0\x13bb.instances.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02e:\x01*Z7:\x01*\"2/v1/{name=projects/*/instances/*}:removeDataSource\"'/v1/{name=instances/*}:removeDataSource\x12\x92\x02\n" +"\x10UpdateDataSource\x12$.bytebase.v1.UpdateDataSourceRequest\x1a\x15.bytebase.v1.Instance\"\xc0\x01\xdaA\x17data_source,update_mask\x8a\xea0\x13bb.instances.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x03\xa8\xea0\x06\x82\xd3\xe4\x93\x02y:\vdata_sourceZA:\vdata_source22/v1/{name=projects/*/instances/*}:updateDataSource2'/v1/{name=instances/*}:updateDataSourceB\xaa\x01\n" +"\x0fcom.bytebase.v1B\x14InstanceServiceProtoP\x01Z4github.com/bytebase/bytebase/backend/generated-go/v1\xa2\x02\x03BXX\xaa\x02\vBytebase.V1\xca\x02\vBytebase\\V1\xe2\x02\x17Bytebase\\V1\\GPBMetadata\xea\x02\fBytebase::V1b\x06proto3"diff --git a/backend/generated-go/v1/org_policy_service.pb.go b/backend/generated-go/v1/org_policy_service.pb.goindex 69d5f81f61..17b11b9a59 100644--- a/backend/generated-go/v1/org_policy_service.pb.go+++ b/backend/generated-go/v1/org_policy_service.pb.go@@ -1184,11 +1184,11 @@ const file_v1_org_policy_service_proto_rawDesc = "" +"\aPROJECT\x10\x032\x90\n" +"\n" +"\x10OrgPolicyService\x12\xde\x01\n" +- "\tGetPolicy\x12\x1d.bytebase.v1.GetPolicyRequest\x1a\x13.bytebase.v1.Policy\"\x9c\x01\xdaA\x04name\x8a\xea0\x0fbb.policies.get\x90\xea0\x02\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02pZ\"\x12 /v1/{name=projects/*/policies/*}Z&\x12$/v1/{name=environments/*/policies/*}\x12\"/v1/{name=workspaces/*/policies/*}\x12\xef\x01\n" +- "\fListPolicies\x12 .bytebase.v1.ListPoliciesRequest\x1a!.bytebase.v1.ListPoliciesResponse\"\x99\x01\xdaA\x00\x8a\xea0\x10bb.policies.list\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02pZ\"\x12 /v1/{parent=projects/*}/policiesZ&\x12$/v1/{parent=environments/*}/policies\x12\"/v1/{parent=workspaces/*}/policies\x12\x8d\x02\n" +- "\fCreatePolicy\x12 .bytebase.v1.CreatePolicyRequest\x1a\x13.bytebase.v1.Policy\"\xc5\x01\xdaA\rparent,policy\x8a\xea0\x12bb.policies.create\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x88\x01:\x06policyZ*:\x06policy\" /v1/{parent=projects/*}/policiesZ.:\x06policy\"$/v1/{parent=environments/*}/policies\"\"/v1/{parent=workspaces/*}/policies\x12\xa7\x02\n" +- "\fUpdatePolicy\x12 .bytebase.v1.UpdatePolicyRequest\x1a\x13.bytebase.v1.Policy\"\xdf\x01\xdaA\x12policy,update_mask\x8a\xea0\x12bb.policies.update\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x9d\x01:\x06policyZ1:\x06policy2'/v1/{policy.name=projects/*/policies/*}Z5:\x06policy2+/v1/{policy.name=environments/*/policies/*}2)/v1/{policy.name=workspaces/*/policies/*}\x12\xee\x01\n" +- "\fDeletePolicy\x12 .bytebase.v1.DeletePolicyRequest\x1a\x16.google.protobuf.Empty\"\xa3\x01\xdaA\x04name\x8a\xea0\x12bb.policies.delete\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02pZ\"* /v1/{name=projects/*/policies/*}Z&*$/v1/{name=environments/*/policies/*}*\"/v1/{name=workspaces/*/policies/*}B\xab\x01\n" ++ "\tGetPolicy\x12\x1d.bytebase.v1.GetPolicyRequest\x1a\x13.bytebase.v1.Policy\"\x9c\x01\xdaA\x04name\x8a\xea0\x0fbb.policies.get\x90\xea0\x02\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02pZ\"\x12 /v1/{name=projects/*/policies/*}Z&\x12$/v1/{name=environments/*/policies/*}\x12\"/v1/{name=workspaces/*/policies/*}\x12\xef\x01\n" ++ "\fListPolicies\x12 .bytebase.v1.ListPoliciesRequest\x1a!.bytebase.v1.ListPoliciesResponse\"\x99\x01\xdaA\x00\x8a\xea0\x10bb.policies.list\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02pZ\"\x12 /v1/{parent=projects/*}/policiesZ&\x12$/v1/{parent=environments/*}/policies\x12\"/v1/{parent=workspaces/*}/policies\x12\x8d\x02\n" ++ "\fCreatePolicy\x12 .bytebase.v1.CreatePolicyRequest\x1a\x13.bytebase.v1.Policy\"\xc5\x01\xdaA\rparent,policy\x8a\xea0\x12bb.policies.create\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x88\x01:\x06policyZ*:\x06policy\" /v1/{parent=projects/*}/policiesZ.:\x06policy\"$/v1/{parent=environments/*}/policies\"\"/v1/{parent=workspaces/*}/policies\x12\xa7\x02\n" ++ "\fUpdatePolicy\x12 .bytebase.v1.UpdatePolicyRequest\x1a\x13.bytebase.v1.Policy\"\xdf\x01\xdaA\x12policy,update_mask\x8a\xea0\x12bb.policies.update\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x9d\x01:\x06policyZ1:\x06policy2'/v1/{policy.name=projects/*/policies/*}Z5:\x06policy2+/v1/{policy.name=environments/*/policies/*}2)/v1/{policy.name=workspaces/*/policies/*}\x12\xee\x01\n" ++ "\fDeletePolicy\x12 .bytebase.v1.DeletePolicyRequest\x1a\x16.google.protobuf.Empty\"\xa3\x01\xdaA\x04name\x8a\xea0\x12bb.policies.delete\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02pZ\"* /v1/{name=projects/*/policies/*}Z&*$/v1/{name=environments/*/policies/*}*\"/v1/{name=workspaces/*/policies/*}B\xab\x01\n" +"\x0fcom.bytebase.v1B\x15OrgPolicyServiceProtoP\x01Z4github.com/bytebase/bytebase/backend/generated-go/v1\xa2\x02\x03BXX\xaa\x02\vBytebase.V1\xca\x02\vBytebase\\V1\xe2\x02\x17Bytebase\\V1\\GPBMetadata\xea\x02\fBytebase::V1b\x06proto3"var (diff --git a/backend/generated-go/v1/project_service.pb.go b/backend/generated-go/v1/project_service.pb.goindex 87f93a2dfc..5528ad2e8a 100644--- a/backend/generated-go/v1/project_service.pb.go+++ b/backend/generated-go/v1/project_service.pb.go@@ -1690,22 +1690,22 @@ const file_v1_project_service_proto_rawDesc = "" +"\x0eISSUE_APPROVED\x10\x0f\"\x04\b\x01\x10\t2\x90\x13\n" +"\x0eProjectService\x12\x87\x01\n" +"\n" +- "GetProject\x12\x1e.bytebase.v1.GetProjectRequest\x1a\x14.bytebase.v1.Project\"C\xdaA\x04name\x8a\xea0\x0fbb.projects.get\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x05\x82\xd3\xe4\x93\x02\x17\x12\x15/v1/{name=projects/*}\x12\x9d\x01\n" +- "\x10BatchGetProjects\x12$.bytebase.v1.BatchGetProjectsRequest\x1a%.bytebase.v1.BatchGetProjectsResponse\"<\x8a\xea0\x0fbb.projects.get\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x05\x82\xd3\xe4\x93\x02\x17\x12\x15/v1/projects:batchGet\x12\x8c\x01\n" +- "\fListProjects\x12 .bytebase.v1.ListProjectsRequest\x1a!.bytebase.v1.ListProjectsResponse\"7\xdaA\x00\x8a\xea0\x10bb.projects.list\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x05\x82\xd3\xe4\x93\x02\x0e\x12\f/v1/projects\x12\x88\x01\n" +- "\x0eSearchProjects\x12\".bytebase.v1.SearchProjectsRequest\x1a#.bytebase.v1.SearchProjectsResponse\"-\xdaA\x00\x90\xea0\x02\xa0\xea0\x04\xb0\xea0\x05\x82\xd3\xe4\x93\x02\x18:\x01*\"\x13/v1/projects:search\x12\x90\x01\n" +- "\rCreateProject\x12!.bytebase.v1.CreateProjectRequest\x1a\x14.bytebase.v1.Project\"F\xdaA\x00\x8a\xea0\x12bb.projects.create\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x17:\aproject\"\f/v1/projects\x12\xb4\x01\n" +- "\rUpdateProject\x12!.bytebase.v1.UpdateProjectRequest\x1a\x14.bytebase.v1.Project\"j\xdaA\x13project,update_mask\x8a\xea0\x12bb.projects.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02(:\aproject2\x1d/v1/{project.name=projects/*}\x12\x96\x01\n" +- "\rDeleteProject\x12!.bytebase.v1.DeleteProjectRequest\x1a\x16.google.protobuf.Empty\"J\xdaA\x04name\x8a\xea0\x12bb.projects.delete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x17*\x15/v1/{name=projects/*}\x12\x9f\x01\n" +- "\x0fUndeleteProject\x12#.bytebase.v1.UndeleteProjectRequest\x1a\x14.bytebase.v1.Project\"Q\x8a\xea0\x14bb.projects.undelete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02#:\x01*\"\x1e/v1/{name=projects/*}:undelete\x12\xa1\x01\n" +- "\x13BatchDeleteProjects\x12'.bytebase.v1.BatchDeleteProjectsRequest\x1a\x16.google.protobuf.Empty\"I\x8a\xea0\x12bb.projects.delete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x1d:\x01*\"\x18/v1/projects:batchDelete\x12\xa0\x01\n" +- "\fGetIamPolicy\x12 .bytebase.v1.GetIamPolicyRequest\x1a\x16.bytebase.v1.IamPolicy\"V\x8a\xea0\x18bb.projects.getIamPolicy\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02(\x12&/v1/{resource=projects/*}:getIamPolicy\x12\xa7\x01\n" +- "\fSetIamPolicy\x12 .bytebase.v1.SetIamPolicyRequest\x1a\x16.bytebase.v1.IamPolicy\"]\x8a\xea0\x18bb.projects.setIamPolicy\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02+:\x01*\"&/v1/{resource=projects/*}:setIamPolicy\x12\x98\x01\n" ++ "GetProject\x12\x1e.bytebase.v1.GetProjectRequest\x1a\x14.bytebase.v1.Project\"C\xdaA\x04name\x8a\xea0\x0fbb.projects.get\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\r\x82\xd3\xe4\x93\x02\x17\x12\x15/v1/{name=projects/*}\x12\x9d\x01\n" ++ "\x10BatchGetProjects\x12$.bytebase.v1.BatchGetProjectsRequest\x1a%.bytebase.v1.BatchGetProjectsResponse\"<\x8a\xea0\x0fbb.projects.get\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\r\x82\xd3\xe4\x93\x02\x17\x12\x15/v1/projects:batchGet\x12\x8c\x01\n" ++ "\fListProjects\x12 .bytebase.v1.ListProjectsRequest\x1a!.bytebase.v1.ListProjectsResponse\"7\xdaA\x00\x8a\xea0\x10bb.projects.list\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\r\x82\xd3\xe4\x93\x02\x0e\x12\f/v1/projects\x12\x88\x01\n" ++ "\x0eSearchProjects\x12\".bytebase.v1.SearchProjectsRequest\x1a#.bytebase.v1.SearchProjectsResponse\"-\xdaA\x00\x90\xea0\x02\xa0\xea0\x04\xa8\xea0\r\x82\xd3\xe4\x93\x02\x18:\x01*\"\x13/v1/projects:search\x12\x90\x01\n" ++ "\rCreateProject\x12!.bytebase.v1.CreateProjectRequest\x1a\x14.bytebase.v1.Project\"F\xdaA\x00\x8a\xea0\x12bb.projects.create\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x17:\aproject\"\f/v1/projects\x12\xb4\x01\n" ++ "\rUpdateProject\x12!.bytebase.v1.UpdateProjectRequest\x1a\x14.bytebase.v1.Project\"j\xdaA\x13project,update_mask\x8a\xea0\x12bb.projects.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02(:\aproject2\x1d/v1/{project.name=projects/*}\x12\x96\x01\n" ++ "\rDeleteProject\x12!.bytebase.v1.DeleteProjectRequest\x1a\x16.google.protobuf.Empty\"J\xdaA\x04name\x8a\xea0\x12bb.projects.delete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x17*\x15/v1/{name=projects/*}\x12\x9f\x01\n" ++ "\x0fUndeleteProject\x12#.bytebase.v1.UndeleteProjectRequest\x1a\x14.bytebase.v1.Project\"Q\x8a\xea0\x14bb.projects.undelete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02#:\x01*\"\x1e/v1/{name=projects/*}:undelete\x12\xa1\x01\n" ++ "\x13BatchDeleteProjects\x12'.bytebase.v1.BatchDeleteProjectsRequest\x1a\x16.google.protobuf.Empty\"I\x8a\xea0\x12bb.projects.delete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x1d:\x01*\"\x18/v1/projects:batchDelete\x12\xa0\x01\n" ++ "\fGetIamPolicy\x12 .bytebase.v1.GetIamPolicyRequest\x1a\x16.bytebase.v1.IamPolicy\"V\x8a\xea0\x18bb.projects.getIamPolicy\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02(\x12&/v1/{resource=projects/*}:getIamPolicy\x12\xa7\x01\n" ++ "\fSetIamPolicy\x12 .bytebase.v1.SetIamPolicyRequest\x1a\x16.bytebase.v1.IamPolicy\"]\x8a\xea0\x18bb.projects.setIamPolicy\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02+:\x01*\"&/v1/{resource=projects/*}:setIamPolicy\x12\x98\x01\n" +"\n" +- "AddWebhook\x12\x1e.bytebase.v1.AddWebhookRequest\x1a\x14.bytebase.v1.Project\"T\x8a\xea0\x12bb.projects.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02(:\x01*\"#/v1/{project=projects/*}:addWebhook\x12\xce\x01\n" +- "\rUpdateWebhook\x12!.bytebase.v1.UpdateWebhookRequest\x1a\x14.bytebase.v1.Project\"\x83\x01\xdaA\x13webhook,update_mask\x8a\xea0\x12bb.projects.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02A:\awebhook26/v1/{webhook.name=projects/*/webhooks/*}:updateWebhook\x12\xb1\x01\n" +- "\rRemoveWebhook\x12!.bytebase.v1.RemoveWebhookRequest\x1a\x14.bytebase.v1.Project\"g\x8a\xea0\x12bb.projects.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02;:\x01*\"6/v1/{webhook.name=projects/*/webhooks/*}:removeWebhook\x12\xa3\x01\n" +- "\vTestWebhook\x12\x1f.bytebase.v1.TestWebhookRequest\x1a .bytebase.v1.TestWebhookResponse\"Q\x8a\xea0\x12bb.projects.update\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x04\x82\xd3\xe4\x93\x02):\x01*\"$/v1/{project=projects/*}:testWebhookB\xa9\x01\n" ++ "AddWebhook\x12\x1e.bytebase.v1.AddWebhookRequest\x1a\x14.bytebase.v1.Project\"T\x8a\xea0\x12bb.projects.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02(:\x01*\"#/v1/{project=projects/*}:addWebhook\x12\xce\x01\n" ++ "\rUpdateWebhook\x12!.bytebase.v1.UpdateWebhookRequest\x1a\x14.bytebase.v1.Project\"\x83\x01\xdaA\x13webhook,update_mask\x8a\xea0\x12bb.projects.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02A:\awebhook26/v1/{webhook.name=projects/*/webhooks/*}:updateWebhook\x12\xb1\x01\n" ++ "\rRemoveWebhook\x12!.bytebase.v1.RemoveWebhookRequest\x1a\x14.bytebase.v1.Project\"g\x8a\xea0\x12bb.projects.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02;:\x01*\"6/v1/{webhook.name=projects/*/webhooks/*}:removeWebhook\x12\xa3\x01\n" ++ "\vTestWebhook\x12\x1f.bytebase.v1.TestWebhookRequest\x1a .bytebase.v1.TestWebhookResponse\"Q\x8a\xea0\x12bb.projects.update\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\f\x82\xd3\xe4\x93\x02):\x01*\"$/v1/{project=projects/*}:testWebhookB\xa9\x01\n" +"\x0fcom.bytebase.v1B\x13ProjectServiceProtoP\x01Z4github.com/bytebase/bytebase/backend/generated-go/v1\xa2\x02\x03BXX\xaa\x02\vBytebase.V1\xca\x02\vBytebase\\V1\xe2\x02\x17Bytebase\\V1\\GPBMetadata\xea\x02\fBytebase::V1b\x06proto3"var (diff --git a/backend/generated-go/v1/query_history_service.pb.go b/backend/generated-go/v1/query_history_service.pb.goindex 9967f66078..b8249eaddb 100644--- a/backend/generated-go/v1/query_history_service.pb.go+++ b/backend/generated-go/v1/query_history_service.pb.go@@ -565,7 +565,8 @@ const file_v1_query_history_service_proto_rawDesc = "" +"\x06_error2\xa1\x04\n" +"\x13QueryHistoryService\x12\xb6\x01\n" +"\x14SearchQueryHistories\x12(.bytebase.v1.SearchQueryHistoriesRequest\x1a).bytebase.v1.SearchQueryHistoriesResponse\"I\xdaA\x06parent\x90\xea0\x02\xa0\xea0\x01\x82\xd3\xe4\x93\x022:\x01*\"-/v1/{parent=projects/*}/queryHistories:search\x12\xc4\x01\n" +- "\x12ListQueryHistories\x12&.bytebase.v1.ListQueryHistoriesRequest\x1a'.bytebase.v1.ListQueryHistoriesResponse\"]\xdaA\x06parent\x8a\xea0\x16bb.queryHistories.list\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x02\x82\xd3\xe4\x93\x02(\x12&/v1/{parent=projects/*}/queryHistories\x12\x89\x01\n" ++ "\x12ListQueryHistories\x12&.bytebase.v1.ListQueryHistoriesRequest\x1a'.bytebase.v1.ListQueryHistoriesResponse\"]\xdaA\x06parent\x8a\xea0\x16bb.queryHistories.list\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\n" ++ "\x82\xd3\xe4\x93\x02(\x12&/v1/{parent=projects/*}/queryHistories\x12\x89\x01\n" +"\x0fGetQueryHistory\x12#.bytebase.v1.GetQueryHistoryRequest\x1a\x19.bytebase.v1.QueryHistory\"6\x90\xea0\x02\xa0\xea0\x01\x82\xd3\xe4\x93\x02(\x12&/v1/{name=projects/*/queryHistories/*}B\xae\x01\n" +"\x0fcom.bytebase.v1B\x18QueryHistoryServiceProtoP\x01Z4github.com/bytebase/bytebase/backend/generated-go/v1\xa2\x02\x03BXX\xaa\x02\vBytebase.V1\xca\x02\vBytebase\\V1\xe2\x02\x17Bytebase\\V1\\GPBMetadata\xea\x02\fBytebase::V1b\x06proto3"diff --git a/backend/generated-go/v1/review_config_service.pb.go b/backend/generated-go/v1/review_config_service.pb.goindex 1d6aaf7104..55ae0be4a4 100644--- a/backend/generated-go/v1/review_config_service.pb.go+++ b/backend/generated-go/v1/review_config_service.pb.go@@ -1428,11 +1428,11 @@ const file_v1_review_config_service_proto_rawDesc = "" +"\"BUILTIN_STATEMENT_MAXIMUM_SQL_SIZE\x10p\"\x04\b \x10 \"\x04\b#\x10#\"\x04\b$\x10$\"\x04\b'\x10'\"\x04\b)\x10)\"\x04\b*\x10*\"\x04\b,\x10,B\t\n" +"\apayload2\x9a\a\n" +"\x13ReviewConfigService\x12\xaf\x01\n" +- "\x12CreateReviewConfig\x12&.bytebase.v1.CreateReviewConfigRequest\x1a\x19.bytebase.v1.ReviewConfig\"V\xdaA\x00\x8a\xea0\x17bb.reviewConfigs.create\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\":\rreview_config\"\x11/v1/reviewConfigs\x12\xa1\x01\n" ++ "\x12CreateReviewConfig\x12&.bytebase.v1.CreateReviewConfigRequest\x1a\x19.bytebase.v1.ReviewConfig\"V\xdaA\x00\x8a\xea0\x17bb.reviewConfigs.create\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\":\rreview_config\"\x11/v1/reviewConfigs\x12\xa1\x01\n" +"\x11ListReviewConfigs\x12%.bytebase.v1.ListReviewConfigsRequest\x1a&.bytebase.v1.ListReviewConfigsResponse\"=\xdaA\x00\x8a\xea0\x15bb.reviewConfigs.list\x90\xea0\x01\xa0\xea0\x01\x82\xd3\xe4\x93\x02\x13\x12\x11/v1/reviewConfigs\x12\x9c\x01\n" +"\x0fGetReviewConfig\x12#.bytebase.v1.GetReviewConfigRequest\x1a\x19.bytebase.v1.ReviewConfig\"I\xdaA\x04name\x8a\xea0\x14bb.reviewConfigs.get\x90\xea0\x01\xa0\xea0\x01\x82\xd3\xe4\x93\x02\x1c\x12\x1a/v1/{name=reviewConfigs/*}\x12\xe0\x01\n" +- "\x12UpdateReviewConfig\x12&.bytebase.v1.UpdateReviewConfigRequest\x1a\x19.bytebase.v1.ReviewConfig\"\x86\x01\xdaA\x19review_config,update_mask\x8a\xea0\x17bb.reviewConfigs.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x029:\rreview_config2(/v1/{review_config.name=reviewConfigs/*}\x12\xaa\x01\n" +- "\x12DeleteReviewConfig\x12&.bytebase.v1.DeleteReviewConfigRequest\x1a\x16.google.protobuf.Empty\"T\xdaA\x04name\x8a\xea0\x17bb.reviewConfigs.delete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x1c*\x1a/v1/{name=reviewConfigs/*}B\xae\x01\n" ++ "\x12UpdateReviewConfig\x12&.bytebase.v1.UpdateReviewConfigRequest\x1a\x19.bytebase.v1.ReviewConfig\"\x86\x01\xdaA\x19review_config,update_mask\x8a\xea0\x17bb.reviewConfigs.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x029:\rreview_config2(/v1/{review_config.name=reviewConfigs/*}\x12\xaa\x01\n" ++ "\x12DeleteReviewConfig\x12&.bytebase.v1.DeleteReviewConfigRequest\x1a\x16.google.protobuf.Empty\"T\xdaA\x04name\x8a\xea0\x17bb.reviewConfigs.delete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x1c*\x1a/v1/{name=reviewConfigs/*}B\xae\x01\n" +"\x0fcom.bytebase.v1B\x18ReviewConfigServiceProtoP\x01Z4github.com/bytebase/bytebase/backend/generated-go/v1\xa2\x02\x03BXX\xaa\x02\vBytebase.V1\xca\x02\vBytebase\\V1\xe2\x02\x17Bytebase\\V1\\GPBMetadata\xea\x02\fBytebase::V1b\x06proto3"var (diff --git a/backend/generated-go/v1/role_service.pb.go b/backend/generated-go/v1/role_service.pb.goindex b02d90432f..f013962862 100644--- a/backend/generated-go/v1/role_service.pb.go+++ b/backend/generated-go/v1/role_service.pb.go@@ -488,14 +488,14 @@ const file_v1_role_service_proto_rawDesc = "" +"\x06CUSTOM\x10\x02:$\xeaA!\n" +"\x11bytebase.com/Role\x12\froles/{role}2\xac\x05\n" +"\vRoleService\x12z\n" +- "\tListRoles\x12\x1d.bytebase.v1.ListRolesRequest\x1a\x1e.bytebase.v1.ListRolesResponse\".\x8a\xea0\rbb.roles.list\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\v\x12\t/v1/roles\x12x\n" +- "\aGetRole\x12\x1b.bytebase.v1.GetRoleRequest\x1a\x11.bytebase.v1.Role\"=\xdaA\x04name\x8a\xea0\fbb.roles.get\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x14\x12\x12/v1/{name=roles/*}\x12{\n" ++ "\tListRoles\x12\x1d.bytebase.v1.ListRolesRequest\x1a\x1e.bytebase.v1.ListRolesResponse\".\x8a\xea0\rbb.roles.list\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\v\x12\t/v1/roles\x12x\n" ++ "\aGetRole\x12\x1b.bytebase.v1.GetRoleRequest\x1a\x11.bytebase.v1.Role\"=\xdaA\x04name\x8a\xea0\fbb.roles.get\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x14\x12\x12/v1/{name=roles/*}\x12{\n" +"\n" +- "CreateRole\x12\x1e.bytebase.v1.CreateRoleRequest\x1a\x11.bytebase.v1.Role\":\x8a\xea0\x0fbb.roles.create\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x11:\x04role\"\t/v1/roles\x12\x9c\x01\n" ++ "CreateRole\x12\x1e.bytebase.v1.CreateRoleRequest\x1a\x11.bytebase.v1.Role\":\x8a\xea0\x0fbb.roles.create\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x11:\x04role\"\t/v1/roles\x12\x9c\x01\n" +"\n" +- "UpdateRole\x12\x1e.bytebase.v1.UpdateRoleRequest\x1a\x11.bytebase.v1.Role\"[\xdaA\x10role,update_mask\x8a\xea0\x0fbb.roles.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x1f:\x04role2\x17/v1/{role.name=roles/*}\x12\x8a\x01\n" ++ "UpdateRole\x12\x1e.bytebase.v1.UpdateRoleRequest\x1a\x11.bytebase.v1.Role\"[\xdaA\x10role,update_mask\x8a\xea0\x0fbb.roles.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x1f:\x04role2\x17/v1/{role.name=roles/*}\x12\x8a\x01\n" +"\n" +- "DeleteRole\x12\x1e.bytebase.v1.DeleteRoleRequest\x1a\x16.google.protobuf.Empty\"D\xdaA\x04name\x8a\xea0\x0fbb.roles.delete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x14*\x12/v1/{name=roles/*}B\xa6\x01\n" ++ "DeleteRole\x12\x1e.bytebase.v1.DeleteRoleRequest\x1a\x16.google.protobuf.Empty\"D\xdaA\x04name\x8a\xea0\x0fbb.roles.delete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x14*\x12/v1/{name=roles/*}B\xa6\x01\n" +"\x0fcom.bytebase.v1B\x10RoleServiceProtoP\x01Z4github.com/bytebase/bytebase/backend/generated-go/v1\xa2\x02\x03BXX\xaa\x02\vBytebase.V1\xca\x02\vBytebase\\V1\xe2\x02\x17Bytebase\\V1\\GPBMetadata\xea\x02\fBytebase::V1b\x06proto3"var (diff --git a/backend/generated-go/v1/rollout_service.pb.go b/backend/generated-go/v1/rollout_service.pb.goindex 314fbce8d5..77d2c2247e 100644--- a/backend/generated-go/v1/rollout_service.pb.go+++ b/backend/generated-go/v1/rollout_service.pb.go@@ -3568,7 +3568,7 @@ const file_v1_rollout_service_proto_rawDesc = "" +"\n" +"GetTaskRun\x12\x1e.bytebase.v1.GetTaskRunRequest\x1a\x14.bytebase.v1.TaskRun\"l\xdaA\x04name\x8a\xea0\x10bb.taskRuns.list\x90\xea0\x01\xa0\xea0\x01\x82\xd3\xe4\x93\x02C\x12A/v1/{name=projects/*/plans/*/rollout/stages/*/tasks/*/taskRuns/*}\x12\xc1\x01\n" +"\rGetTaskRunLog\x12!.bytebase.v1.GetTaskRunLogRequest\x1a\x17.bytebase.v1.TaskRunLog\"t\xdaA\x06parent\x8a\xea0\x10bb.taskRuns.list\x90\xea0\x01\xa0\xea0\x01\x82\xd3\xe4\x93\x02I\x12G/v1/{parent=projects/*/plans/*/rollout/stages/*/tasks/*/taskRuns/*}/log\x12\xd5\x01\n" +- "\x11GetTaskRunSession\x12%.bytebase.v1.GetTaskRunSessionRequest\x1a\x1b.bytebase.v1.TaskRunSession\"|\xdaA\x06parent\x8a\xea0\x10bb.taskRuns.list\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x03\x82\xd3\xe4\x93\x02M\x12K/v1/{parent=projects/*/plans/*/rollout/stages/*/tasks/*/taskRuns/*}/session\x12\xb7\x01\n" ++ "\x11GetTaskRunSession\x12%.bytebase.v1.GetTaskRunSessionRequest\x1a\x1b.bytebase.v1.TaskRunSession\"|\xdaA\x06parent\x8a\xea0\x10bb.taskRuns.list\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\v\x82\xd3\xe4\x93\x02M\x12K/v1/{parent=projects/*/plans/*/rollout/stages/*/tasks/*/taskRuns/*}/session\x12\xb7\x01\n" +"\rBatchRunTasks\x12!.bytebase.v1.BatchRunTasksRequest\x1a\".bytebase.v1.BatchRunTasksResponse\"_\xdaA\x06parent\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x02\x82\xd3\xe4\x93\x02D:\x01*\"?/v1/{parent=projects/*/plans/*/rollout/stages/*}/tasks:batchRun\x12\xbb\x01\n" +"\x0eBatchSkipTasks\x12\".bytebase.v1.BatchSkipTasksRequest\x1a#.bytebase.v1.BatchSkipTasksResponse\"`\xdaA\x06parent\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x02\x82\xd3\xe4\x93\x02E:\x01*\"@/v1/{parent=projects/*/plans/*/rollout/stages/*}/tasks:batchSkip\x12\xd7\x01\n" +"\x13BatchCancelTaskRuns\x12'.bytebase.v1.BatchCancelTaskRunsRequest\x1a(.bytebase.v1.BatchCancelTaskRunsResponse\"m\xdaA\x06parent\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x02\x82\xd3\xe4\x93\x02R:\x01*\"M/v1/{parent=projects/*/plans/*/rollout/stages/*/tasks/*}/taskRuns:batchCancel\x12\xf2\x01\n" +diff --git a/backend/generated-go/v1/saved_query_service.pb.go b/backend/generated-go/v1/saved_query_service.pb.goindex d2c6a3952d..b6ae388fff 100644--- a/backend/generated-go/v1/saved_query_service.pb.go+++ b/backend/generated-go/v1/saved_query_service.pb.go@@ -1303,15 +1303,16 @@ const file_v1_saved_query_service_proto_rawDesc = "" +"\x11SavedQueryService\x12\xc7\x01\n" +"\x10CreateSavedQuery\x12$.bytebase.v1.CreateSavedQueryRequest\x1a\x17.bytebase.v1.SavedQuery\"t\xdaA\x12parent,saved_query\x8a\xea0\x16bb.savedQueries.create\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x02\x82\xd3\xe4\x93\x023:\vsaved_query\"$/v1/{parent=projects/*}/savedQueries\x12\x88\x01\n" +"\rGetSavedQuery\x12!.bytebase.v1.GetSavedQueryRequest\x1a\x17.bytebase.v1.SavedQuery\";\xdaA\x04name\x90\xea0\x02\xa0\xea0\x01\x82\xd3\xe4\x93\x02&\x12$/v1/{name=projects/*/savedQueries/*}\x12\xba\x01\n" +- "\x10ListSavedQueries\x12$.bytebase.v1.ListSavedQueriesRequest\x1a%.bytebase.v1.ListSavedQueriesResponse\"Y\xdaA\x06parent\x8a\xea0\x14bb.savedQueries.list\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x02\x82\xd3\xe4\x93\x02&\x12$/v1/{parent=projects/*}/savedQueries\x12\xae\x01\n" ++ "\x10ListSavedQueries\x12$.bytebase.v1.ListSavedQueriesRequest\x1a%.bytebase.v1.ListSavedQueriesResponse\"Y\xdaA\x06parent\x8a\xea0\x14bb.savedQueries.list\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\n" ++ "\x82\xd3\xe4\x93\x02&\x12$/v1/{parent=projects/*}/savedQueries\x12\xae\x01\n" +"\x12SearchSavedQueries\x12&.bytebase.v1.SearchSavedQueriesRequest\x1a'.bytebase.v1.SearchSavedQueriesResponse\"G\xdaA\x06parent\x90\xea0\x02\xa0\xea0\x01\x82\xd3\xe4\x93\x020:\x01*\"+/v1/{parent=projects/*}/savedQueries:search\x12\xc4\x01\n" +"\x17SearchSavedQueryFolders\x12+.bytebase.v1.SearchSavedQueryFoldersRequest\x1a,.bytebase.v1.SearchSavedQueryFoldersResponse\"N\xdaA\x06parent\x90\xea0\x02\xa0\xea0\x01\x82\xd3\xe4\x93\x027:\x01*\"2/v1/{parent=projects/*}/savedQueries:searchFolders\x12\xbe\x01\n" +"\x10UpdateSavedQuery\x12$.bytebase.v1.UpdateSavedQueryRequest\x1a\x17.bytebase.v1.SavedQuery\"k\xdaA\x17saved_query,update_mask\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x02\x82\xd3\xe4\x93\x02?:\vsaved_query20/v1/{saved_query.name=projects/*/savedQueries/*}\x12\xac\x01\n" +"\x14UpdateSavedQueryStar\x12(.bytebase.v1.UpdateSavedQueryStarRequest\x1a\x17.bytebase.v1.SavedQuery\"Q\xdaA\fname,starred\x90\xea0\x02\xa0\xea0\x02\x82\xd3\xe4\x93\x024:\x01*\"//v1/{name=projects/*/savedQueries/*}:updateStar\x12\xce\x01\n" +"\x12MoveMySavedQueries\x12&.bytebase.v1.MoveMySavedQueriesRequest\x1a'.bytebase.v1.MoveMySavedQueriesResponse\"g\xdaA\"parent,source_folder,target_folder\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x02\x82\xd3\xe4\x93\x020:\x01*\"+/v1/{parent=projects/*}/savedQueries:moveMy\x12\x91\x01\n" +"\x10DeleteSavedQuery\x12$.bytebase.v1.DeleteSavedQueryRequest\x1a\x16.google.protobuf.Empty\"?\xdaA\x04name\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x02\x82\xd3\xe4\x93\x02&*$/v1/{name=projects/*/savedQueries/*}\x12\xb0\x01\n" +- "\x13GetSavedQueryPolicy\x12'.bytebase.v1.GetSavedQueryPolicyRequest\x1a\x1d.bytebase.v1.SavedQueryPolicy\"Q\xdaA\bresource\x90\xea0\x02\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x024\x122/v1/{resource=projects/*/savedQueries/*}:getPolicy\x12\xbe\x01\n" +- "\x13SetSavedQueryPolicy\x12'.bytebase.v1.SetSavedQueryPolicyRequest\x1a\x1d.bytebase.v1.SavedQueryPolicy\"_\xdaA\x0fresource,policy\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x027:\x01*\"2/v1/{resource=projects/*/savedQueries/*}:setPolicyB\xac\x01\n" ++ "\x13GetSavedQueryPolicy\x12'.bytebase.v1.GetSavedQueryPolicyRequest\x1a\x1d.bytebase.v1.SavedQueryPolicy\"Q\xdaA\bresource\x90\xea0\x02\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x024\x122/v1/{resource=projects/*/savedQueries/*}:getPolicy\x12\xbe\x01\n" ++ "\x13SetSavedQueryPolicy\x12'.bytebase.v1.SetSavedQueryPolicyRequest\x1a\x1d.bytebase.v1.SavedQueryPolicy\"_\xdaA\x0fresource,policy\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x027:\x01*\"2/v1/{resource=projects/*/savedQueries/*}:setPolicyB\xac\x01\n" +"\x0fcom.bytebase.v1B\x16SavedQueryServiceProtoP\x01Z4github.com/bytebase/bytebase/backend/generated-go/v1\xa2\x02\x03BXX\xaa\x02\vBytebase.V1\xca\x02\vBytebase\\V1\xe2\x02\x17Bytebase\\V1\\GPBMetadata\xea\x02\fBytebase::V1b\x06proto3"var (diff --git a/backend/generated-go/v1/service_account_service.pb.go b/backend/generated-go/v1/service_account_service.pb.goindex 10476ca202..b0e0d84d25 100644--- a/backend/generated-go/v1/service_account_service.pb.go+++ b/backend/generated-go/v1/service_account_service.pb.go@@ -593,11 +593,11 @@ const file_v1_service_account_service_proto_rawDesc = "" +"\n" +"\x15ServiceAccountService\x12\xb7\x02\n" +"\x14CreateServiceAccount\x12(.bytebase.v1.CreateServiceAccountRequest\x1a\x1b.bytebase.v1.ServiceAccount\"\xd7\x01\xdaA)parent,service_account,service_account_id\x8a\xea0\x19bb.serviceAccounts.create\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x03\xa8\xea0\x06\x82\xd3\xe4\x93\x02x:\x0fservice_accountZ<:\x0fservice_account\")/v1/{parent=workspaces/*}/serviceAccounts\"'/v1/{parent=projects/*}/serviceAccounts\x12\xaa\x01\n" +- "\x11GetServiceAccount\x12%.bytebase.v1.GetServiceAccountRequest\x1a\x1b.bytebase.v1.ServiceAccount\"Q\xdaA\x04name\x8a\xea0\x16bb.serviceAccounts.get\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x1e\x12\x1c/v1/{name=serviceAccounts/*}\x12\xf7\x01\n" +- "\x13ListServiceAccounts\x12'.bytebase.v1.ListServiceAccountsRequest\x1a(.bytebase.v1.ListServiceAccountsResponse\"\x8c\x01\xdaA\x06parent\x8a\xea0\x17bb.serviceAccounts.list\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02VZ+\x12)/v1/{parent=workspaces/*}/serviceAccounts\x12'/v1/{parent=projects/*}/serviceAccounts\x12\xf0\x01\n" ++ "\x11GetServiceAccount\x12%.bytebase.v1.GetServiceAccountRequest\x1a\x1b.bytebase.v1.ServiceAccount\"Q\xdaA\x04name\x8a\xea0\x16bb.serviceAccounts.get\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x1e\x12\x1c/v1/{name=serviceAccounts/*}\x12\xf7\x01\n" ++ "\x13ListServiceAccounts\x12'.bytebase.v1.ListServiceAccountsRequest\x1a(.bytebase.v1.ListServiceAccountsResponse\"\x8c\x01\xdaA\x06parent\x8a\xea0\x17bb.serviceAccounts.list\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02VZ+\x12)/v1/{parent=workspaces/*}/serviceAccounts\x12'/v1/{parent=projects/*}/serviceAccounts\x12\xf0\x01\n" +"\x14UpdateServiceAccount\x12(.bytebase.v1.UpdateServiceAccountRequest\x1a\x1b.bytebase.v1.ServiceAccount\"\x90\x01\xdaA\x1bservice_account,update_mask\x8a\xea0\x19bb.serviceAccounts.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x03\xa8\xea0\x06\x82\xd3\xe4\x93\x02?:\x0fservice_account2,/v1/{service_account.name=serviceAccounts/*}\x12\xb2\x01\n" +- "\x14DeleteServiceAccount\x12(.bytebase.v1.DeleteServiceAccountRequest\x1a\x16.google.protobuf.Empty\"X\xdaA\x04name\x8a\xea0\x19bb.serviceAccounts.delete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x1e*\x1c/v1/{name=serviceAccounts/*}\x12\xc2\x01\n" +- "\x16UndeleteServiceAccount\x12*.bytebase.v1.UndeleteServiceAccountRequest\x1a\x1b.bytebase.v1.ServiceAccount\"_\x8a\xea0\x1bbb.serviceAccounts.undelete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02*:\x01*\"%/v1/{name=serviceAccounts/*}:undeleteB\xb0\x01\n" ++ "\x14DeleteServiceAccount\x12(.bytebase.v1.DeleteServiceAccountRequest\x1a\x16.google.protobuf.Empty\"X\xdaA\x04name\x8a\xea0\x19bb.serviceAccounts.delete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x1e*\x1c/v1/{name=serviceAccounts/*}\x12\xc2\x01\n" ++ "\x16UndeleteServiceAccount\x12*.bytebase.v1.UndeleteServiceAccountRequest\x1a\x1b.bytebase.v1.ServiceAccount\"_\x8a\xea0\x1bbb.serviceAccounts.undelete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02*:\x01*\"%/v1/{name=serviceAccounts/*}:undeleteB\xb0\x01\n" +"\x0fcom.bytebase.v1B\x1aServiceAccountServiceProtoP\x01Z4github.com/bytebase/bytebase/backend/generated-go/v1\xa2\x02\x03BXX\xaa\x02\vBytebase.V1\xca\x02\vBytebase\\V1\xe2\x02\x17Bytebase\\V1\\GPBMetadata\xea\x02\fBytebase::V1b\x06proto3"var (diff --git a/backend/generated-go/v1/setting_service.pb.go b/backend/generated-go/v1/setting_service.pb.goindex 1c5be7a952..ccb4aa247c 100644--- a/backend/generated-go/v1/setting_service.pb.go+++ b/backend/generated-go/v1/setting_service.pb.go@@ -3728,9 +3728,9 @@ const file_v1_setting_service_proto_rawDesc = "" +"\n" +"\x06EDITOR\x10\x022\x82\x05\n" +"\x0eSettingService\x12\x8c\x01\n" +- "\fListSettings\x12 .bytebase.v1.ListSettingsRequest\x1a!.bytebase.v1.ListSettingsResponse\"7\xdaA\x00\x8a\xea0\x10bb.settings.list\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x0e\x12\f/v1/settings\x12\x87\x01\n" ++ "\fListSettings\x12 .bytebase.v1.ListSettingsRequest\x1a!.bytebase.v1.ListSettingsResponse\"7\xdaA\x00\x8a\xea0\x10bb.settings.list\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x0e\x12\f/v1/settings\x12\x87\x01\n" +"\n" +- "GetSetting\x12\x1e.bytebase.v1.GetSettingRequest\x1a\x14.bytebase.v1.Setting\"C\xdaA\x04name\x8a\xea0\x0fbb.settings.get\x90\xea0\x02\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x17\x12\x15/v1/{name=settings/*}\x12\x9b\x01\n" ++ "GetSetting\x12\x1e.bytebase.v1.GetSettingRequest\x1a\x14.bytebase.v1.Setting\"C\xdaA\x04name\x8a\xea0\x0fbb.settings.get\x90\xea0\x02\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x17\x12\x15/v1/{name=settings/*}\x12\x9b\x01\n" +"\rUpdateSetting\x12!.bytebase.v1.UpdateSettingRequest\x1a\x14.bytebase.v1.Setting\"Q\x8a\xea0\x0fbb.settings.set\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x03\xa8\xea0\a\x82\xd3\xe4\x93\x02(:\asetting2\x1d/v1/{setting.name=settings/*}\x12\xb8\x01\n" +"\x10TestEmailSetting\x12$.bytebase.v1.TestEmailSettingRequest\x1a%.bytebase.v1.TestEmailSettingResponse\"W\x8a\xea0\x0fbb.settings.set\x90\xea0\x01\xa0\xea0\x03\xa8\xea0\x06\x82\xd3\xe4\x93\x022:\x01*\"-/v1/{parent=workspaces/*}/settings/EMAIL:testB\xa9\x01\n" +"\x0fcom.bytebase.v1B\x13SettingServiceProtoP\x01Z4github.com/bytebase/bytebase/backend/generated-go/v1\xa2\x02\x03BXX\xaa\x02\vBytebase.V1\xca\x02\vBytebase\\V1\xe2\x02\x17Bytebase\\V1\\GPBMetadata\xea\x02\fBytebase::V1b\x06proto3"diff --git a/backend/generated-go/v1/sql_service.pb.go b/backend/generated-go/v1/sql_service.pb.goindex 68b4034360..69a9285315 100644--- a/backend/generated-go/v1/sql_service.pb.go+++ b/backend/generated-go/v1/sql_service.pb.go@@ -2228,9 +2228,10 @@ const file_v1_sql_service_proto_rawDesc = "" +"\n" +"SQLService\x12\x93\x01\n" +"\x05Query\x12\x19.bytebase.v1.QueryRequest\x1a\x1a.bytebase.v1.QueryResponse\"S\x8a\xea0\x10bb.databases.get\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x01\x82\xd3\xe4\x93\x02-:\x01*\"(/v1/{name=instances/*/databases/*}:query\x12\x91\x01\n" +- "\fAdminExecute\x12 .bytebase.v1.AdminExecuteRequest\x1a!.bytebase.v1.AdminExecuteResponse\"8\x8a\xea0\fbb.sql.admin\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x03\x82\xd3\xe4\x93\x02\x12\x12\x10/v1:adminExecute(\x010\x01\x12x\n" ++ "\fAdminExecute\x12 .bytebase.v1.AdminExecuteRequest\x1a!.bytebase.v1.AdminExecuteResponse\"8\x8a\xea0\fbb.sql.admin\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\v\x82\xd3\xe4\x93\x02\x12\x12\x10/v1:adminExecute(\x010\x01\x12x\n" +"\x14SearchQueryHistories\x12(.bytebase.v1.SearchQueryHistoriesRequest\x1a).bytebase.v1.SearchQueryHistoriesResponse\"\v\x90\xea0\x02\xa0\xea0\x01\x88\x02\x01\x12\x90\x01\n" +- "\x12ListQueryHistories\x12&.bytebase.v1.ListQueryHistoriesRequest\x1a'.bytebase.v1.ListQueryHistoriesResponse\")\x8a\xea0\x16bb.queryHistories.list\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x02\x88\x02\x01\x12^\n" ++ "\x12ListQueryHistories\x12&.bytebase.v1.ListQueryHistoriesRequest\x1a'.bytebase.v1.ListQueryHistoriesResponse\")\x8a\xea0\x16bb.queryHistories.list\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\n" ++ "\x88\x02\x01\x12^\n" +"\x0fGetQueryHistory\x12#.bytebase.v1.GetQueryHistoryRequest\x1a\x19.bytebase.v1.QueryHistory\"\v\x90\xea0\x02\xa0\xea0\x01\x88\x02\x01\x12\x97\x01\n" +"\x06Export\x12\x1a.bytebase.v1.ExportRequest\x1a\x1b.bytebase.v1.ExportResponse\"T\x8a\xea0\x10bb.databases.get\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x02\x82\xd3\xe4\x93\x02.:\x01*\")/v1/{name=instances/*/databases/*}:exportB\xa5\x01\n" +"\x0fcom.bytebase.v1B\x0fSqlServiceProtoP\x01Z4github.com/bytebase/bytebase/backend/generated-go/v1\xa2\x02\x03BXX\xaa\x02\vBytebase.V1\xca\x02\vBytebase\\V1\xe2\x02\x17Bytebase\\V1\\GPBMetadata\xea\x02\fBytebase::V1b\x06proto3"diff --git a/backend/generated-go/v1/subscription_service.pb.go b/backend/generated-go/v1/subscription_service.pb.goindex b0d33fc3ca..03109161d1 100644--- a/backend/generated-go/v1/subscription_service.pb.go+++ b/backend/generated-go/v1/subscription_service.pb.go@@ -1851,15 +1851,15 @@ const file_v1_subscription_service_proto_rawDesc = "" +"\x15FEATURE_EMAIL_SUPPORT\x10F\x12&\n" +"\"FEATURE_DEDICATED_SUPPORT_WITH_SLA\x10G2\xf1\v\n" +"\x13SubscriptionService\x12v\n" +- "\x0fGetSubscription\x12#.bytebase.v1.GetSubscriptionRequest\x1a\x19.bytebase.v1.Subscription\"#\xdaA\x00\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x12\x12\x10/v1/subscription\x12\xcc\x01\n" +- "\x16ExportVCSProviderUsers\x12*.bytebase.v1.ExportVCSProviderUsersRequest\x1a+.bytebase.v1.ExportVCSProviderUsersResponse\"Y\x8a\xea0\x16bb.subscription.manage\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02)\x12'/v1/subscription:vcsProviderUsersExport\x12\x9c\x01\n" +- "\rUploadLicense\x12!.bytebase.v1.UploadLicenseRequest\x1a\x19.bytebase.v1.Subscription\"M\x8a\xea0\x16bb.subscription.manage\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x1d:\x01*2\x18/v1/subscription/license\x12\xa3\x01\n" +- "\x0eCreatePurchase\x12\".bytebase.v1.CreatePurchaseRequest\x1a\x1d.bytebase.v1.PurchaseResponse\"N\x8a\xea0\x16bb.subscription.manage\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x1e:\x01*\"\x19/v1/subscription:purchase\x12\xa9\x01\n" +- "\x0eUpdatePurchase\x12\".bytebase.v1.UpdatePurchaseRequest\x1a\x1d.bytebase.v1.PurchaseResponse\"T\x8a\xea0\x16bb.subscription.manage\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02$:\x01*\"\x1f/v1/subscription:updatePurchase\x12\xa9\x01\n" +- "\x0eCancelPurchase\x12\".bytebase.v1.CancelPurchaseRequest\x1a\x1d.bytebase.v1.PurchaseResponse\"T\x8a\xea0\x16bb.subscription.manage\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02$:\x01*\"\x1f/v1/subscription:cancelPurchase\x12\x9a\x01\n" +- "\x0eGetPaymentInfo\x12\".bytebase.v1.GetPaymentInfoRequest\x1a\x18.bytebase.v1.PaymentInfo\"J\x8a\xea0\x16bb.subscription.manage\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x1e\x12\x1c/v1/subscription/paymentInfo\x12\xcb\x01\n" +- "\x15VerifyCheckoutSession\x12).bytebase.v1.VerifyCheckoutSessionRequest\x1a*.bytebase.v1.VerifyCheckoutSessionResponse\"[\x8a\xea0\x16bb.subscription.manage\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02/\x12-/v1/subscription/checkoutSession/{session_id}\x12\x8a\x01\n" +- "\x11ListPurchasePlans\x12%.bytebase.v1.ListPurchasePlansRequest\x1a&.bytebase.v1.ListPurchasePlansResponse\"&\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x18\x12\x16/v1/subscription/plansB\xae\x01\n" ++ "\x0fGetSubscription\x12#.bytebase.v1.GetSubscriptionRequest\x1a\x19.bytebase.v1.Subscription\"#\xdaA\x00\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x12\x12\x10/v1/subscription\x12\xcc\x01\n" ++ "\x16ExportVCSProviderUsers\x12*.bytebase.v1.ExportVCSProviderUsersRequest\x1a+.bytebase.v1.ExportVCSProviderUsersResponse\"Y\x8a\xea0\x16bb.subscription.manage\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02)\x12'/v1/subscription:vcsProviderUsersExport\x12\x9c\x01\n" ++ "\rUploadLicense\x12!.bytebase.v1.UploadLicenseRequest\x1a\x19.bytebase.v1.Subscription\"M\x8a\xea0\x16bb.subscription.manage\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x1d:\x01*2\x18/v1/subscription/license\x12\xa3\x01\n" ++ "\x0eCreatePurchase\x12\".bytebase.v1.CreatePurchaseRequest\x1a\x1d.bytebase.v1.PurchaseResponse\"N\x8a\xea0\x16bb.subscription.manage\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x1e:\x01*\"\x19/v1/subscription:purchase\x12\xa9\x01\n" ++ "\x0eUpdatePurchase\x12\".bytebase.v1.UpdatePurchaseRequest\x1a\x1d.bytebase.v1.PurchaseResponse\"T\x8a\xea0\x16bb.subscription.manage\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02$:\x01*\"\x1f/v1/subscription:updatePurchase\x12\xa9\x01\n" ++ "\x0eCancelPurchase\x12\".bytebase.v1.CancelPurchaseRequest\x1a\x1d.bytebase.v1.PurchaseResponse\"T\x8a\xea0\x16bb.subscription.manage\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02$:\x01*\"\x1f/v1/subscription:cancelPurchase\x12\x9a\x01\n" ++ "\x0eGetPaymentInfo\x12\".bytebase.v1.GetPaymentInfoRequest\x1a\x18.bytebase.v1.PaymentInfo\"J\x8a\xea0\x16bb.subscription.manage\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x1e\x12\x1c/v1/subscription/paymentInfo\x12\xcb\x01\n" ++ "\x15VerifyCheckoutSession\x12).bytebase.v1.VerifyCheckoutSessionRequest\x1a*.bytebase.v1.VerifyCheckoutSessionResponse\"[\x8a\xea0\x16bb.subscription.manage\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02/\x12-/v1/subscription/checkoutSession/{session_id}\x12\x8a\x01\n" ++ "\x11ListPurchasePlans\x12%.bytebase.v1.ListPurchasePlansRequest\x1a&.bytebase.v1.ListPurchasePlansResponse\"&\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x18\x12\x16/v1/subscription/plansB\xae\x01\n" +"\x0fcom.bytebase.v1B\x18SubscriptionServiceProtoP\x01Z4github.com/bytebase/bytebase/backend/generated-go/v1\xa2\x02\x03BXX\xaa\x02\vBytebase.V1\xca\x02\vBytebase\\V1\xe2\x02\x17Bytebase\\V1\\GPBMetadata\xea\x02\fBytebase::V1b\x06proto3"var (diff --git a/backend/generated-go/v1/user_service.pb.go b/backend/generated-go/v1/user_service.pb.goindex 7e97771b78..18422efca3 100644--- a/backend/generated-go/v1/user_service.pb.go+++ b/backend/generated-go/v1/user_service.pb.go@@ -899,17 +899,17 @@ const file_v1_user_service_proto_rawDesc = "" +"\x06source\x18\x03 \x01(\tR\x06source:%\xeaA\"\n" +"\x11bytebase.com/User\x12\rusers/{email}J\x04\b\x05\x10\x06J\x04\b\x0f\x10\x102\xac\t\n" +"\vUserService\x12x\n" +- "\aGetUser\x12\x1b.bytebase.v1.GetUserRequest\x1a\x11.bytebase.v1.User\"=\xdaA\x04name\x8a\xea0\fbb.users.get\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x14\x12\x12/v1/{name=users/*}\x12\x8e\x01\n" +- "\rBatchGetUsers\x12!.bytebase.v1.BatchGetUsersRequest\x1a\".bytebase.v1.BatchGetUsersResponse\"6\x8a\xea0\fbb.users.get\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x14\x12\x12/v1/users:batchGet\x12a\n" +- "\x0eGetCurrentUser\x12\x16.google.protobuf.Empty\x1a\x11.bytebase.v1.User\"$\x80\xea0\x01\x90\xea0\x02\xa0\xea0\x04\xb0\xea0\x05\x82\xd3\xe4\x93\x02\x0e\x12\f/v1/users/me\x12\x83\x01\n" +- "\tListUsers\x12\x1d.bytebase.v1.ListUsersRequest\x1a\x1e.bytebase.v1.ListUsersResponse\"7\xdaA\x06parent\x8a\xea0\rbb.users.list\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\v\x12\t/v1/users\x12\x82\x01\n" ++ "\aGetUser\x12\x1b.bytebase.v1.GetUserRequest\x1a\x11.bytebase.v1.User\"=\xdaA\x04name\x8a\xea0\fbb.users.get\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x14\x12\x12/v1/{name=users/*}\x12\x8e\x01\n" ++ "\rBatchGetUsers\x12!.bytebase.v1.BatchGetUsersRequest\x1a\".bytebase.v1.BatchGetUsersResponse\"6\x8a\xea0\fbb.users.get\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x14\x12\x12/v1/users:batchGet\x12a\n" ++ "\x0eGetCurrentUser\x12\x16.google.protobuf.Empty\x1a\x11.bytebase.v1.User\"$\x80\xea0\x01\x90\xea0\x02\xa0\xea0\x04\xa8\xea0\r\x82\xd3\xe4\x93\x02\x0e\x12\f/v1/users/me\x12\x83\x01\n" ++ "\tListUsers\x12\x1d.bytebase.v1.ListUsersRequest\x1a\x1e.bytebase.v1.ListUsersResponse\"7\xdaA\x06parent\x8a\xea0\rbb.users.list\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\v\x12\t/v1/users\x12\x82\x01\n" +"\n" +"CreateUser\x12\x1e.bytebase.v1.CreateUserRequest\x1a\x11.bytebase.v1.User\"A\xdaA\x04user\x8a\xea0\x0fbb.users.create\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x03\xa8\xea0\x06\x82\xd3\xe4\x93\x02\x11:\x04user\"\t/v1/users\x12\x89\x01\n" +"\n" +"UpdateUser\x12\x1e.bytebase.v1.UpdateUserRequest\x1a\x11.bytebase.v1.User\"H\xdaA\x10user,update_mask\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x03\xa8\xea0\x03\x82\xd3\xe4\x93\x02\x1f:\x04user2\x17/v1/{user.name=users/*}\x12w\n" +"\n" +- "DeleteUser\x12\x1e.bytebase.v1.DeleteUserRequest\x1a\x16.google.protobuf.Empty\"1\xdaA\x04name\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\x14*\x12/v1/{name=users/*}\x12{\n" +- "\fUndeleteUser\x12 .bytebase.v1.UndeleteUserRequest\x1a\x11.bytebase.v1.User\"6\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02 :\x01*\"\x1b/v1/{name=users/*}:undelete\x12\xa1\x01\n" ++ "DeleteUser\x12\x1e.bytebase.v1.DeleteUserRequest\x1a\x16.google.protobuf.Empty\"1\xdaA\x04name\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\x14*\x12/v1/{name=users/*}\x12{\n" ++ "\fUndeleteUser\x12 .bytebase.v1.UndeleteUserRequest\x1a\x11.bytebase.v1.User\"6\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02 :\x01*\"\x1b/v1/{name=users/*}:undelete\x12\xa1\x01\n" +"\vUpdateEmail\x12\x1f.bytebase.v1.UpdateEmailRequest\x1a\x11.bytebase.v1.User\"^\xdaA\n" +"name,email\x8a\xea0\x14bb.users.updateEmail\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x03\xa8\xea0\x06\x82\xd3\xe4\x93\x02#:\x01*\"\x1e/v1/{name=users/*}:updateEmailB\xa6\x01\n" +"\x0fcom.bytebase.v1B\x10UserServiceProtoP\x01Z4github.com/bytebase/bytebase/backend/generated-go/v1\xa2\x02\x03BXX\xaa\x02\vBytebase.V1\xca\x02\vBytebase\\V1\xe2\x02\x17Bytebase\\V1\\GPBMetadata\xea\x02\fBytebase::V1b\x06proto3"diff --git a/backend/generated-go/v1/workload_identity_service.pb.go b/backend/generated-go/v1/workload_identity_service.pb.goindex d3b98549ee..2a32a30c65 100644--- a/backend/generated-go/v1/workload_identity_service.pb.go+++ b/backend/generated-go/v1/workload_identity_service.pb.go@@ -726,11 +726,11 @@ const file_v1_workload_identity_service_proto_rawDesc = "" +"\x1dbytebase.com/WorkloadIdentityR\x04name2\xc5\v\n" +"\x17WorkloadIdentityService\x12\xcf\x02\n" +"\x16CreateWorkloadIdentity\x12*.bytebase.v1.CreateWorkloadIdentityRequest\x1a\x1d.bytebase.v1.WorkloadIdentity\"\xe9\x01\xdaA-parent,workload_identity,workload_identity_id\x8a\xea0\x1cbb.workloadIdentities.create\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x03\xa8\xea0\x06\x82\xd3\xe4\x93\x02\x82\x01:\x11workload_identityZA:\x11workload_identity\",/v1/{parent=workspaces/*}/workloadIdentities\"*/v1/{parent=projects/*}/workloadIdentities\x12\xb6\x01\n" +- "\x13GetWorkloadIdentity\x12'.bytebase.v1.GetWorkloadIdentityRequest\x1a\x1d.bytebase.v1.WorkloadIdentity\"W\xdaA\x04name\x8a\xea0\x19bb.workloadIdentities.get\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02!\x12\x1f/v1/{name=workloadIdentities/*}\x12\x89\x02\n" +- "\x16ListWorkloadIdentities\x12*.bytebase.v1.ListWorkloadIdentitiesRequest\x1a+.bytebase.v1.ListWorkloadIdentitiesResponse\"\x95\x01\xdaA\x06parent\x8a\xea0\x1abb.workloadIdentities.list\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02\\Z.\x12,/v1/{parent=workspaces/*}/workloadIdentities\x12*/v1/{parent=projects/*}/workloadIdentities\x12\x82\x02\n" ++ "\x13GetWorkloadIdentity\x12'.bytebase.v1.GetWorkloadIdentityRequest\x1a\x1d.bytebase.v1.WorkloadIdentity\"W\xdaA\x04name\x8a\xea0\x19bb.workloadIdentities.get\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02!\x12\x1f/v1/{name=workloadIdentities/*}\x12\x89\x02\n" ++ "\x16ListWorkloadIdentities\x12*.bytebase.v1.ListWorkloadIdentitiesRequest\x1a+.bytebase.v1.ListWorkloadIdentitiesResponse\"\x95\x01\xdaA\x06parent\x8a\xea0\x1abb.workloadIdentities.list\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02\\Z.\x12,/v1/{parent=workspaces/*}/workloadIdentities\x12*/v1/{parent=projects/*}/workloadIdentities\x12\x82\x02\n" +"\x16UpdateWorkloadIdentity\x12*.bytebase.v1.UpdateWorkloadIdentityRequest\x1a\x1d.bytebase.v1.WorkloadIdentity\"\x9c\x01\xdaA\x1dworkload_identity,update_mask\x8a\xea0\x1cbb.workloadIdentities.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x03\xa8\xea0\x06\x82\xd3\xe4\x93\x02F:\x11workload_identity21/v1/{workload_identity.name=workloadIdentities/*}\x12\xbc\x01\n" +- "\x16DeleteWorkloadIdentity\x12*.bytebase.v1.DeleteWorkloadIdentityRequest\x1a\x16.google.protobuf.Empty\"^\xdaA\x04name\x8a\xea0\x1cbb.workloadIdentities.delete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02!*\x1f/v1/{name=workloadIdentities/*}\x12\xce\x01\n" +- "\x18UndeleteWorkloadIdentity\x12,.bytebase.v1.UndeleteWorkloadIdentityRequest\x1a\x1d.bytebase.v1.WorkloadIdentity\"e\x8a\xea0\x1ebb.workloadIdentities.undelete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02-:\x01*\"(/v1/{name=workloadIdentities/*}:undeleteB\xb2\x01\n" ++ "\x16DeleteWorkloadIdentity\x12*.bytebase.v1.DeleteWorkloadIdentityRequest\x1a\x16.google.protobuf.Empty\"^\xdaA\x04name\x8a\xea0\x1cbb.workloadIdentities.delete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02!*\x1f/v1/{name=workloadIdentities/*}\x12\xce\x01\n" ++ "\x18UndeleteWorkloadIdentity\x12,.bytebase.v1.UndeleteWorkloadIdentityRequest\x1a\x1d.bytebase.v1.WorkloadIdentity\"e\x8a\xea0\x1ebb.workloadIdentities.undelete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02-:\x01*\"(/v1/{name=workloadIdentities/*}:undeleteB\xb2\x01\n" +"\x0fcom.bytebase.v1B\x1cWorkloadIdentityServiceProtoP\x01Z4github.com/bytebase/bytebase/backend/generated-go/v1\xa2\x02\x03BXX\xaa\x02\vBytebase.V1\xca\x02\vBytebase\\V1\xe2\x02\x17Bytebase\\V1\\GPBMetadata\xea\x02\fBytebase::V1b\x06proto3"var (diff --git a/backend/generated-go/v1/workspace_service.pb.go b/backend/generated-go/v1/workspace_service.pb.goindex 44f4631b06..7bdcef0669 100644--- a/backend/generated-go/v1/workspace_service.pb.go+++ b/backend/generated-go/v1/workspace_service.pb.go@@ -477,11 +477,11 @@ const file_v1_workspace_service_proto_rawDesc = "" +"\x10WorkspaceService\x12q\n" +"\fGetWorkspace\x12 .bytebase.v1.GetWorkspaceRequest\x1a\x16.bytebase.v1.Workspace\"'\x80\xea0\x01\xa0\xea0\x01\x82\xd3\xe4\x93\x02\x19\x12\x17/v1/{name=workspaces/*}\x12y\n" +"\x0eListWorkspaces\x12\".bytebase.v1.ListWorkspacesRequest\x1a#.bytebase.v1.ListWorkspacesResponse\"\x1e\x90\xea0\x02\xa0\xea0\x01\x82\xd3\xe4\x93\x02\x10\x12\x0e/v1/workspaces\x12\xa4\x01\n" +- "\x0fUpdateWorkspace\x12#.bytebase.v1.UpdateWorkspaceRequest\x1a\x16.bytebase.v1.Workspace\"T\x8a\xea0\x14bb.workspaces.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02&:\x01*2!/v1/{workspace.name=workspaces/*}\x12\xa4\x01\n" +- "\fGetIamPolicy\x12 .bytebase.v1.GetIamPolicyRequest\x1a\x16.bytebase.v1.IamPolicy\"Z\x8a\xea0\x1abb.workspaces.getIamPolicy\x90\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02*\x12(/v1/{resource=workspaces/*}:getIamPolicy\x12\x9b\x01\n" ++ "\x0fUpdateWorkspace\x12#.bytebase.v1.UpdateWorkspaceRequest\x1a\x16.bytebase.v1.Workspace\"T\x8a\xea0\x14bb.workspaces.update\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02&:\x01*2!/v1/{workspace.name=workspaces/*}\x12\xa4\x01\n" ++ "\fGetIamPolicy\x12 .bytebase.v1.GetIamPolicyRequest\x1a\x16.bytebase.v1.IamPolicy\"Z\x8a\xea0\x1abb.workspaces.getIamPolicy\x90\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02*\x12(/v1/{resource=workspaces/*}:getIamPolicy\x12\x9b\x01\n" +"\x0fDeleteWorkspace\x12#.bytebase.v1.DeleteWorkspaceRequest\x1a\x1a.bytebase.v1.LoginResponse\"G\x8a\xea0\x14bb.workspaces.delete\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x03\xa8\xea0\x05\x82\xd3\xe4\x93\x02\x19*\x17/v1/{name=workspaces/*}\x12\x8a\x01\n" +"\x0eLeaveWorkspace\x12\".bytebase.v1.LeaveWorkspaceRequest\x1a\x1a.bytebase.v1.LoginResponse\"8\x90\xea0\x02\x98\xea0\x01\xa0\xea0\x03\xa8\xea0\x05\x82\xd3\xe4\x93\x02\":\x01*\"\x1d/v1/{name=workspaces/*}:leave\x12\xab\x01\n" +- "\fSetIamPolicy\x12 .bytebase.v1.SetIamPolicyRequest\x1a\x16.bytebase.v1.IamPolicy\"a\x8a\xea0\x1abb.workspaces.setIamPolicy\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xb0\xea0\x01\x82\xd3\xe4\x93\x02-:\x01*\"(/v1/{resource=workspaces/*}:setIamPolicy\x12\xf5\x01\n" ++ "\fSetIamPolicy\x12 .bytebase.v1.SetIamPolicyRequest\x1a\x16.bytebase.v1.IamPolicy\"a\x8a\xea0\x1abb.workspaces.setIamPolicy\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x04\xa8\xea0\t\x82\xd3\xe4\x93\x02-:\x01*\"(/v1/{resource=workspaces/*}:setIamPolicy\x12\xf5\x01\n" +"\x18RotateDirectorySyncToken\x12,.bytebase.v1.RotateDirectorySyncTokenRequest\x1a-.bytebase.v1.RotateDirectorySyncTokenResponse\"|\xdaA\x04name\x8a\xea0&bb.workspaces.rotateDirectorySyncToken\x90\xea0\x01\x98\xea0\x01\xa0\xea0\x03\xa8\xea0\x06\x82\xd3\xe4\x93\x025:\x01*\"0/v1/{name=workspaces/*}:rotateDirectorySyncTokenB\xab\x01\n" +"\x0fcom.bytebase.v1B\x15WorkspaceServiceProtoP\x01Z4github.com/bytebase/bytebase/backend/generated-go/v1\xa2\x02\x03BXX\xaa\x02\vBytebase.V1\xca\x02\vBytebase\\V1\xe2\x02\x17Bytebase\\V1\\GPBMetadata\xea\x02\fBytebase::V1b\x06proto3"diff --git a/backend/server/grpc_routes.go b/backend/server/grpc_routes.goindex b7390cbd95..9e78834033 100644--- a/backend/server/grpc_routes.go+++ b/backend/server/grpc_routes.go@@ -205,18 +205,18 @@ func configureGrpcRouters(// annotation opts out of auditing stay unaudited for permitted and denied// calls alike (needAudit gates both).//- // The FORBIDDEN gate sits between them — inside audit, so a denial is- // recorded wherever the method's annotation asks for auditing at all, and- // outside ACL, because the class is refused whatever the caller's RBAC- // would have allowed. P1b's full ceiling gate takes this same slot, and- // brings the typed denial record for the unannotated methods with it.+ // The MCP ceiling gate sits between them — inside audit, so a denial is+ // recorded, and outside ACL, because the ceiling refuses whatever the+ // caller's RBAC would have allowed. It marks its denials so the audit+ // interceptor records them even on methods whose annotation asks for no+ // audit row at all.internalHandlerOpts := connect.WithHandlerOptions(connect.WithRecover(onPanic),connect.WithInterceptors(validateInterceptor,auth.NewInternalMCPAuthInterceptor(stores, secret, profile),apiv1.NewAuditInterceptor(stores, secret, profile),- apiv1.NewInternalMCPForbiddenInterceptor(),+ apiv1.NewInternalMCPGateInterceptor(stores),apiv1.NewACLInterceptor(stores, secret, iamManager, profile),),)diff --git a/backend/store/setting.go b/backend/store/setting.goindex c2e6b6c101..ac0c1a5b21 100644--- a/backend/store/setting.go+++ b/backend/store/setting.go@@ -3,6 +3,7 @@ package storeimport ("context""database/sql"+ "encoding/json""math""time"@@ -549,3 +550,95 @@ func (s *Store) DeleteSetting(ctx context.Context, workspace string, name storeps.settingCache.Remove(getSettingCacheKey(workspace, name))return nil}++// ErrMCPCapabilityUnreadable marks a stored MCP capability ceiling this build+// cannot interpret: an enum name it does not know, a wrong-typed value, a row+// that is not the JSON the profile expects. It is deliberately distinct from a+// failed READ, because the two are opposite outcomes for the caller. A read+// that failed is an outage and will likely succeed on retry; a value that+// cannot be interpreted will never succeed until an admin rewrites it, so+// telling the caller to retry would be a lie and telling it "policy" is the+// truth. Both refuse.+var ErrMCPCapabilityUnreadable = errors.New("the stored MCP capability ceiling cannot be interpreted")++// GetMCPCapabilityUncached reads the workspace's stored MCP capability ceiling+// straight from the database, bypassing the setting cache. The cache has no TTL+// and only in-process writes refresh it, so a ceiling flipped out of band —+// direct SQL, another replica — must still bite on the next request.+//+// It reads the row's JSON rather than taking the parsed message, because the+// shared unmarshaler discards unknown fields and that is the one case a ceiling+// must not swallow. A stored `{"mcpCapability":"READ_ONLYY"}` parses to the+// unset value, which resolves to READ_WRITE below, so a typo would+// silently reopen the workspace. An unknown enum NUMBER survives protojson and+// fails closed on its own — no mode serves it — and only an unknown NAME+// disappears, so the check is the raw key's presence against the parsed field+// and nothing else about the row is read strictly. Rejecting the whole row on+// any unknown field would let one field from a newer release disable MCP+// workspace-wide.+//+// The returned ceiling is the effective one, never UNSPECIFIED: a workspace+// that never set a ceiling resolves to READ_WRITE so existing workspaces are+// unaffected. Every state this cannot make sense of is an error instead, and+// every caller fails closed on one — so a caller has exactly one decision to+// take, and it is the same decision in both of them.+func (s *Store) GetMCPCapabilityUncached(ctx context.Context, workspace string) (storepb.WorkspaceProfileSetting_MCPCapability, error) {+ const unset = storepb.WorkspaceProfileSetting_MCP_CAPABILITY_UNSPECIFIED+ const whenUnset = storepb.WorkspaceProfileSetting_READ_WRITE++ q := qb.Q().Space(`+ SELECT value FROM setting WHERE workspace = ? AND name = ?+ `, workspace, storepb.SettingName_WORKSPACE_PROFILE.String())+ query, args, err := q.ToSQL()+ if err != nil {+ return unset, errors.Wrap(err, "failed to build sql")+ }+ var valueString string+ if err := s.GetDB().QueryRowContext(ctx, query, args...).Scan(&valueString); err != nil {+ if errors.Is(err, sql.ErrNoRows) {+ // No workspace profile row at all: the ceiling was never set.+ return whenUnset, nil+ }+ return unset, errors.Wrap(err, "failed to read the workspace profile setting")+ }++ profile := &storepb.WorkspaceProfileSetting{}+ if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(valueString), profile); err != nil {+ return unset, errors.Wrapf(ErrMCPCapabilityUnreadable, "the workspace profile setting does not parse: %v", err)+ }+ if capability := profile.GetMcpCapability(); capability != unset {+ return capability, nil+ }++ stored, err := storedMCPCapability(valueString)+ if err != nil {+ return unset, err+ }+ if stored != "" {+ return unset, errors.Wrapf(ErrMCPCapabilityUnreadable, "%s is not a value this build understands", stored)+ }+ return whenUnset, nil+}++// storedMCPCapability returns the workspace profile row's raw mcp_capability+// value, or "" when the row carries no such key. protojson accepts both the+// JSON name and the proto field name, so a hand-written row may use either.+//+// A key present alongside a parsed-unset field means the stored name is one+// this build does not know. An explicit MCP_CAPABILITY_UNSPECIFIED counts as+// that too, deliberately: protojson omits a zero enum when it writes, and the+// settings API rejects an explicit UNSPECIFIED, so no Bytebase write produces+// this key with that value — only a hand-edited row does, and there it is+// indistinguishable from a typo.+func storedMCPCapability(value string) (string, error) {+ var fields map[string]json.RawMessage+ if err := json.Unmarshal([]byte(value), &fields); err != nil {+ return "", errors.Wrapf(ErrMCPCapabilityUnreadable, "the workspace profile setting is not a JSON object: %v", err)+ }+ for _, key := range []string{"mcpCapability", "mcp_capability"} {+ if raw, ok := fields[key]; ok {+ return string(raw), nil+ }+ }+ return "", nil+}diff --git a/backend/tests/mcp_audit_provenance_test.go b/backend/tests/mcp_audit_provenance_test.goindex 6151e610af..6e51934f03 100644--- a/backend/tests/mcp_audit_provenance_test.go+++ b/backend/tests/mcp_audit_provenance_test.go@@ -2,6 +2,7 @@ package testsimport ("context"+ "encoding/base64""encoding/json""net/http""strings"@@ -82,26 +83,65 @@ func TestMCPAuditProvenance(t *testing.T) {return out.Status}- // Permitted audited call: creating a group needs bb.groups.create, which a- // workspace member does hold. (Self-updating the member's own title would- // read more naturally, but UpdateUser is FORBIDDEN to MCP sessions as a- // whole method — see backend/api/v1/mcp_forbidden.go.)- a.Equal(http.StatusOK, callAPI("GroupService/CreateGroup", map[string]any{- "group": map[string]any{"title": "agent driver group"},- "groupEmail": "[email protected]",+ // The permitted call has to be one the MCP ceiling serves AND the member is+ // allowed, and no audited READ or WRITE method is reachable on a plain+ // workspace membership alone — every one of them is project-scoped. So the+ // member owns a project. (Creating a group was the natural probe and is+ // EXCLUDED from the ceiling as workspace administration; self-updating the+ // member's title reads even better and is FORBIDDEN — see+ // backend/api/v1/mcp_gate.go.)+ const ownedProjectID = "mcp-audit-owned"+ ownedProject, err := ctl.projectServiceClient.CreateProject(ctx, connect.NewRequest(&v1pb.CreateProjectRequest{+ ProjectId: ownedProjectID,+ Project: &v1pb.Project{Title: "MCP audit owned"},+ }))+ a.NoError(err)+ ownedProjectName := ownedProject.Msg.Name+ ownedPolicy, err := ctl.projectServiceClient.GetIamPolicy(ctx, connect.NewRequest(&v1pb.GetIamPolicyRequest{+ Resource: ownedProjectName,+ }))+ a.NoError(err)+ policy := ownedPolicy.Msg+ policy.Bindings = append(policy.Bindings, &v1pb.Binding{+ Role: "roles/projectOwner",+ Members: []string{"user:" + memberEmail},+ })+ _, err = ctl.projectServiceClient.SetIamPolicy(ctx, connect.NewRequest(&v1pb.SetIamPolicyRequest{+ Resource: ownedProjectName,+ Policy: policy,+ }))+ a.NoError(err)++ // A second project the member has no role in, so the denial below is the+ // ACL's and lands on a resource the ACL validated.+ const otherProjectID = "mcp-audit-other"+ otherProject, err := ctl.projectServiceClient.CreateProject(ctx, connect.NewRequest(&v1pb.CreateProjectRequest{+ ProjectId: otherProjectID,+ Project: &v1pb.Project{Title: "MCP audit other"},+ }))+ a.NoError(err)+ otherProjectName := otherProject.Msg.Name++ // Permitted audited call: creating a sheet needs bb.sheets.create, which+ // the member holds on the project it owns.+ a.Equal(http.StatusOK, callAPI("SheetService/CreateSheet", map[string]any{+ "parent": ownedProjectName,+ "sheet": map[string]any{"content": base64.StdEncoding.EncodeToString([]byte("SELECT 1;"))},}))// Denied audited call: creating a user needs bb.users.create, which a- // workspace member does not hold — the ACL interceptor refuses it.+ // workspace member does not hold. CreateUser is also FORBIDDEN to MCP+ // sessions, so the refusal now comes from the ceiling gate rather than the+ // ACL — either way it is a workspace-parented denial the operator must see.a.Equal(http.StatusForbidden, callAPI("UserService/CreateUser", map[string]any{"user": map[string]any{"email": "[email protected]", "title": "sneaky", "password": memberPassword},}))- // The operator's view: both calls surface through the v1 audit-log read+ // The operator's view: the calls surface through the v1 audit-log read// API, attributed to the member.- searchMemberRows := func(method string) []*v1pb.AuditLog {+ searchMemberRows := func(parent, method string) []*v1pb.AuditLog {resp, err := ctl.auditLogServiceClient.SearchAuditLogs(ctx, connect.NewRequest(&v1pb.SearchAuditLogsRequest{- Parent: workspace,+ Parent: parent,Filter: `method == "` + method + `"`,OrderBy: "create_time desc",}))@@ -115,7 +155,7 @@ func TestMCPAuditProvenance(t *testing.T) {return rows}- permittedRows := searchMemberRows("/bytebase.v1.GroupService/CreateGroup")+ permittedRows := searchMemberRows(ownedProjectName, "/bytebase.v1.SheetService/CreateSheet")a.Len(permittedRows, 1, "the permitted MCP call must produce exactly one audit row")permitted := permittedRows[0]a.Nil(permitted.Status, "the permitted call's row keeps its success status")@@ -125,8 +165,8 @@ func TestMCPAuditProvenance(t *testing.T) {a.Equal(clientID, permitted.McpDelegation.ClientId)a.NotEmpty(permitted.McpDelegation.CorrelationId)- deniedRows := searchMemberRows("/bytebase.v1.UserService/CreateUser")- a.Len(deniedRows, 1, "an ACL-denied MCP call must still produce an audit row — it is exactly the event an operator investigating an agent needs")+ deniedRows := searchMemberRows(workspace, "/bytebase.v1.UserService/CreateUser")+ a.Len(deniedRows, 1, "a denied MCP call must still produce an audit row — it is exactly the event an operator investigating an agent needs")denied := deniedRows[0]a.NotNil(denied.Status, "the denied row must reflect the denial")a.Equal(int32(connect.CodePermissionDenied), denied.Status.Code)@@ -142,22 +182,23 @@ func TestMCPAuditProvenance(t *testing.T) {// UNVALIDATED resources — the workspace-mismatch arm — fall back to the// caller's workspace; an IAM denial's resources passed workspace-scoped// validation.)- projects, err := ctl.projectServiceClient.ListProjects(ctx, connect.NewRequest(&v1pb.ListProjectsRequest{}))- a.NoError(err)- a.NotEmpty(projects.Msg.Projects)- projectName := projects.Msg.Projects[0].Name- a.Equal(http.StatusForbidden, callAPI("ProjectService/SetIamPolicy", map[string]any{- "resource": projectName,- "policy": map[string]any{"bindings": []any{}},+ //+ // The probe is a WRITE method deliberately: the parent comes from the+ // resources the ACL interceptor validated, and the ceiling gate runs before+ // ACL. A method the ceiling refuses never reaches ACL, so its row falls+ // back to the caller's workspace and would prove nothing about parents.+ a.Equal(http.StatusForbidden, callAPI("PlanService/CreatePlan", map[string]any{+ "parent": otherProjectName,+ "plan": map[string]any{"title": "not mine to make"},}))projectDenied, err := ctl.auditLogServiceClient.SearchAuditLogs(ctx, connect.NewRequest(&v1pb.SearchAuditLogsRequest{- Parent: projectName,- Filter: `method == "/bytebase.v1.ProjectService/SetIamPolicy"`,+ Parent: otherProjectName,+ Filter: `method == "/bytebase.v1.PlanService/CreatePlan"`,}))a.NoError(err)a.Len(projectDenied.Msg.AuditLogs, 1, "the project-scoped denial must be audited under the project it targeted")projectRow := projectDenied.Msg.AuditLogs[0]- a.True(strings.HasPrefix(projectRow.Name, projectName+"/auditLogs/"))+ a.True(strings.HasPrefix(projectRow.Name, otherProjectName+"/auditLogs/"))a.Equal("users/"+memberEmail, projectRow.User)a.Equal(int32(connect.CodePermissionDenied), projectRow.Status.GetCode())a.Equal(permitted.McpDelegation.CorrelationId, projectRow.McpDelegation.GetCorrelationId())diff --git a/backend/tests/mcp_forbidden_credential_mints_test.go b/backend/tests/mcp_forbidden_credential_mints_test.goindex e572b66ada..34b1bbef8c 100644--- a/backend/tests/mcp_forbidden_credential_mints_test.go+++ b/backend/tests/mcp_forbidden_credential_mints_test.go@@ -12,6 +12,7 @@ import ("google.golang.org/protobuf/types/known/fieldmaskpb"v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"+ "github.com/bytebase/bytebase/backend/generated-go/v1/v1connect")// deniedMCPRows returns the audit rows an MCP session produced for one method.@@ -400,16 +401,25 @@ func TestMCPCannotWriteTrustAnchorsOrShipStoredSecrets(t *testing.T) {"%s must name this class's reason", name)}- // Nothing landed. The agent's own read answers this, which is the point of- // leaving it served: it is legitimate work, it carries no secret, and here- // it is also the instrument. Reading the listing rather than just its- // status is what discriminates a gate that refuses before dispatch from one- // that refuses after the identity provider is written.- idps := callAPIOnSession(ctx, t, session, "IdentityProviderService/ListIdentityProviders", map[string]any{})- a.Equal(http.StatusOK, idps.Status, "the read stays served — it blanks every secret before returning")- a.NotContains(idps.RawResponse, idpID, "the identity provider must never have been created")- a.NotContains(idps.RawResponse, "attacker.example.com",- "no part of the attacker's SSO config may have reached the store")+ // Nothing landed. Reading the listing rather than just the statuses above+ // is what discriminates a gate that refuses before dispatch from one that+ // refuses after the identity provider is written.+ //+ // The read is taken on the public chain rather than through the session.+ // It is not FORBIDDEN — TestForbiddenClassLeavesReadsAlone pins that it+ // never becomes so — but it is EXCLUDED as workspace administration, which+ // the ceiling gate refuses, so the agent's own read no longer answers this+ // question. The claim is about what reached the store either way.+ idpClient := v1connect.NewIdentityProviderServiceClient(ctl.client, ctl.rootURL,+ connect.WithInterceptors(&authInterceptor{token: ctl.authInterceptor.token}))+ idps, err := idpClient.ListIdentityProviders(ctx,+ connect.NewRequest(&v1pb.ListIdentityProvidersRequest{Parent: workspaceName}))+ a.NoError(err)+ for _, idp := range idps.Msg.IdentityProviders {+ a.NotContains(idp.Name, idpID, "the identity provider must never have been created")+ a.NotContains(idp.Domain, "attacker.example.com",+ "no part of the attacker's SSO config may have reached the store")+ }wis, err := ctl.workloadIdentityServiceClient.ListWorkloadIdentities(ctx, connect.NewRequest(&v1pb.ListWorkloadIdentitiesRequest{Parent: workspaceName,}))@@ -418,12 +428,20 @@ func TestMCPCannotWriteTrustAnchorsOrShipStoredSecrets(t *testing.T) {a.NotContains(wi.Email, wiID, "the workload identity must never have been written")}- // Four of the six carry the audit annotation and produce a denial row.+ // All six produce a denial row, and two of them only since 1b-2. Four carry+ // the audit annotation; TestIdentityProvider and TestEmailSetting carry+ // none, so until the gate started marking its own refusals they were+ // refused silently — the two methods in this batch that would have carried+ // a stored secret to an address the agent chose were the two that left no+ // trace. This assertion is what tells anyone who touches the marking that+ // the coverage is load-bearing.for method, label := range map[string]string{"/bytebase.v1.IdentityProviderService/CreateIdentityProvider": "CreateIdentityProvider","/bytebase.v1.IdentityProviderService/UpdateIdentityProvider": "UpdateIdentityProvider","/bytebase.v1.WorkloadIdentityService/CreateWorkloadIdentity": "CreateWorkloadIdentity","/bytebase.v1.WorkloadIdentityService/UpdateWorkloadIdentity": "UpdateWorkloadIdentity",+ "/bytebase.v1.IdentityProviderService/TestIdentityProvider": "TestIdentityProvider (no audit annotation)",+ "/bytebase.v1.SettingService/TestEmailSetting": "TestEmailSetting (no audit annotation)",} {rows := deniedMCPRows(ctx, t, ctl, workspaceName, method)a.Len(rows, 1, "the denied %s must produce exactly one audit row", label)@@ -431,21 +449,14 @@ func TestMCPCannotWriteTrustAnchorsOrShipStoredSecrets(t *testing.T) {"the %s row must record the denial", label)}- // The two Test methods do not, and that gap is worth stating rather than- // leaving to be discovered. needAudit reads the audit annotation and- // nothing else, and neither has one — so the two methods in this batch that- // would carry a stored secret to an address the agent chose are the two- // refused silently. Not fixed here: the typed policy-denial record that- // bypasses needAudit is 1b-2's, and when it lands these assertions are what- // tell whoever writes it that these methods are now covered.- //- // The zeroes are only meaningful because the four rows above came back from- // this same helper on this same workspace: the query works, and these two- // methods genuinely produced nothing.- a.Empty(deniedMCPRows(ctx, t, ctl, workspaceName, "/bytebase.v1.IdentityProviderService/TestIdentityProvider"),- "TestIdentityProvider carries no audit annotation, so its denial is silent — 1b-2's typed denial record closes this")- a.Empty(deniedMCPRows(ctx, t, ctl, workspaceName, "/bytebase.v1.SettingService/TestEmailSetting"),- "TestEmailSetting carries no audit annotation either — same gap, same fix")+ // What the row must NOT carry: TestIdentityProvider's request names the+ // stored client secret's destination and supplies a code, and recording a+ // denial verbatim would put both in a log the denial exists to protect.+ idpRow := deniedMCPRows(ctx, t, ctl, workspaceName,+ "/bytebase.v1.IdentityProviderService/TestIdentityProvider")[0]+ a.NotContains(idpRow.Request, "anything", "the supplied authorization code must be masked in the row")+ a.Contains(idpRow.Request, "collector.attacker.example.com",+ "the host the agent named is the point of the row and stays readable")}// TestMCPCannotRetargetADataSource covers the same "carry a stored secret to a@@ -765,15 +776,18 @@ func TestMCPCannotRewriteItsOwnCeiling(t *testing.T) {// comes only from what the HANDLER validated via common.SetAuditWorkspaceID,// and the ordinary workspace fallback is explicitly skipped for them.//-// The FORBIDDEN gate refuses before dispatch, so the handler never runs, so-// nothing ever calls SetAuditWorkspaceID, so there is no parent and no row.-// The workspace is not actually unknown here — the internal chain put a-// credential-verified one in the context — the carve-out just cannot use it.+// The gate refuses before dispatch, so the handler never runs, so nothing ever+// calls SetAuditWorkspaceID. That used to mean no parent and no row, which made+// the silent set seven rather than the four an annotation audit suggests.//-// So the silent set is seven, not the four an annotation audit would suggest.-// Closing it means letting the audit path use the delegated workspace, or the-// typed denial record: 1b-2's work, not this PR's. This test is the tripwire.-func TestMCPResetFlowDenialsAreSilent(t *testing.T) {+// 1b-2 closed it, and this test now pins the close. The workspace was never+// actually unknown here: the internal MCP chain put a credential-verified one+// in the context, and the carve-out simply could not use it. It can now, for+// requests carrying a delegated grant and only those — an unauthenticated+// public reset still gets its parent from the handler alone, because there the+// workspace IS caller-named and auditing against it would let anyone write+// rows into someone else'"'"'s.+func TestMCPResetFlowDenialsAreAudited(t *testing.T) {t.Parallel()a := require.New(t)ctx := context.Background()@@ -834,10 +848,13 @@ func TestMCPResetFlowDenialsAreSilent(t *testing.T) {"/bytebase.v1.AuthService/SendEmailLoginCode": "SendEmailLoginCode",} {rows := deniedMCPRows(ctx, t, ctl, workspaceName, method)- t.Logf("audit rows for denied %s: %d", label, len(rows))- a.Empty(rows,- "%s carries audit = true, yet its MCP denial writes no row: the audit parent for this "+- "method comes only from the handler, and the gate refuses before the handler runs", label)+ a.Len(rows, 1,+ "%s is refused before its handler runs, so it announces no workspace — the delegated "++ "credential's verified one stands in, and the denial is recorded like every other", label)+ a.Equal(int32(connect.CodePermissionDenied), rows[0].Status.GetCode(),+ "the %s row must record the denial", label)+ a.True(strings.HasPrefix(rows[0].Name, workspaceName+"/auditLogs/"),+ "the row is parented to the workspace the MCP credential was bound to, not one the caller named")}}@@ -859,53 +876,73 @@ func TestMCPCredentialMintsLeaveDiscovery(t *testing.T) {a.NoError(err)defer ctl.Close(ctx)+ workspace, err := ctl.workspaceServiceClient.GetWorkspace(ctx, connect.NewRequest(&v1pb.GetWorkspaceRequest{+ Name: "workspaces/-",+ }))+ a.NoError(err)+ workspaceName := workspace.Msg.Name+session := openMCPSession(ctx, t, ctl, ctl.authInterceptor.token)defer session.Close()- // Browsing the service must not list the forbidden methods, while the- // reads of that same service stay on offer — the assertion is that the- // classification is per method, not per service.+ // Browsing a service must not list a method the session can never call,+ // and the hiding is per method: a service keeping any served method stays+ // on the menu with that method on it.//- // Each row carries a `served` method as a positive control. Without one,+ // The positive control comes first and on the same tool: without one,// NotContains over an opaque text blob passes for the wrong reason as soon// as search_api returns anything that is not an endpoint listing — an- // unknown service name, an error string, an empty result — and a test that- // cannot fail is worse here than no test, because this is the assertion- // standing between an agent and a menu of work it can never do.+ // error string, an empty result — and a test that cannot fail is worse+ // here than no test, because this is the assertion standing between an+ // agent and a menu of work it can never do.+ servedListing := searchAPIOnSession(ctx, t, session, map[string]any{"service": "DatabaseService"})+ a.Contains(servedListing, "DatabaseService/ListDatabases",+ "positive control: a service the ceiling serves must really come back as an endpoint listing")++ // These services host the credential mints, and since the ceiling gate+ // refuses EXCLUDED as well as FORBIDDEN, every one of their methods is now+ // refused — the mints outright, their read siblings as workspace+ // administration. So they do not come back as a listing at all.for _, row := range []struct {- service string- forbidden []string- served string+ service string+ refused []string}{- {"ServiceAccountService", []string{"CreateServiceAccount", "UpdateServiceAccount"}, "GetServiceAccount"},- {"IdentityProviderService", []string{"CreateIdentityProvider", "UpdateIdentityProvider", "TestIdentityProvider"}, "GetIdentityProvider"},- {"WorkloadIdentityService", []string{"CreateWorkloadIdentity", "UpdateWorkloadIdentity"}, "GetWorkloadIdentity"},- {"UserService", []string{"CreateUser", "UpdateEmail"}, "GetUser"},- {"WorkspaceService", []string{"RotateDirectorySyncToken"}, "GetIamPolicy"},- {"SettingService", []string{"TestEmailSetting"}, "GetSetting"},+ {"ServiceAccountService", []string{"CreateServiceAccount", "UpdateServiceAccount", "GetServiceAccount"}},+ {"IdentityProviderService", []string{"CreateIdentityProvider", "UpdateIdentityProvider", "TestIdentityProvider"}},+ {"WorkloadIdentityService", []string{"CreateWorkloadIdentity", "UpdateWorkloadIdentity"}},+ {"UserService", []string{"CreateUser", "UpdateEmail", "GetUser"}},+ {"SettingService", []string{"TestEmailSetting", "GetSetting"}},} {listing := searchAPIOnSession(ctx, t, session, map[string]any{"service": row.service})- a.Contains(listing, row.service+"/"+row.served,- "positive control: %s must really be an endpoint listing", row.service)- for _, method := range row.forbidden {+ a.Contains(listing, "No endpoints found for service: "+row.service,+ "%s serves no method under any ceiling, so it is not a menu", row.service)+ for _, method := range row.refused {a.NotContains(listing, row.service+"/"+method,"search_api must not offer %s/%s, which the session can never call", row.service, method)}}- // The service list is the entry point into discovery. Every service here- // keeps at least its reads, so all of them stay listed — a service does- // drop out when every one of its methods is forbidden, which is what- // happened to AuthService and is pinned in the mcp package. The per-method- // hiding is the browse assertion above; this only checks the batch did not- // take a whole service off the menu.+ // WorkspaceService is the mixed case and the one that proves the hiding is+ // per method rather than per service: it keeps GetWorkspace and+ // ListWorkspaces, so it stays on the menu, and the token rotation is gone+ // from it.+ workspaceListing := searchAPIOnSession(ctx, t, session, map[string]any{"service": "WorkspaceService"})+ a.Contains(workspaceListing, "WorkspaceService/ListWorkspaces",+ "a service keeps the methods the ceiling serves")+ a.NotContains(workspaceListing, "WorkspaceService/RotateDirectorySyncToken",+ "search_api must not offer the token rotation, which the session can never call")++ // The service list is the entry point into discovery, and a service whose+ // every method is refused drops out of it entirely.services := searchAPIOnSession(ctx, t, session, map[string]any{})for _, service := range []string{"ServiceAccountService", "IdentityProviderService", "WorkloadIdentityService",- "UserService", "WorkspaceService", "SettingService",+ "UserService", "SettingService",} {- a.Contains(services, service, "%s keeps its reads, so it must stay listed", service)+ a.NotContains(services, service, "%s serves nothing, so it must not be listed", service)}+ a.Contains(services, "DatabaseService", "positive control: services the ceiling serves stay listed")+ a.Contains(services, "WorkspaceService", "a service keeping any served method stays listed")// Still resolvable by operation ID, and a call still reaches the gate.for _, operation := range []string{@@ -926,10 +963,15 @@ func TestMCPCredentialMintsLeaveDiscovery(t *testing.T) {"%s must stay resolvable so the denial can explain itself", operation)}- // The reads of the same services are unaffected — the batch classified- // credential issuance, not the services that happen to host it.- saListing := searchAPIOnSession(ctx, t, session, map[string]any{"service": "ServiceAccountService"})- a.Contains(saListing, "ServiceAccountService/GetServiceAccount",- "the reads must still be discoverable")- a.Contains(saListing, "ServiceAccountService/ListServiceAccounts")+ // The reads of those services are still not FORBIDDEN — they carry no+ // credential, and TestForbiddenClassLeavesReadsAlone pins that they never+ // become so. They are EXCLUDED, which is a scope decision a later+ // admin-capable ceiling can revisit, and until then they are refused and+ // unadvertised like everything else no mode serves.+ saRead := callAPIOnSession(ctx, t, session, "ServiceAccountService/ListServiceAccounts", map[string]any{+ "parent": workspaceName,+ })+ a.Equal(http.StatusForbidden, saRead.Status)+ a.Contains(saRead.Error, "administers the workspace",+ "the read is refused for what it is, not for minting a credential")}diff --git a/backend/tests/mcp_gate_test.go b/backend/tests/mcp_gate_test.gonew file mode 100644index 0000000000..be3149f68b--- /dev/null+++ b/backend/tests/mcp_gate_test.go@@ -0,0 +1,267 @@+package tests++import (+ "context"+ "encoding/base64"+ "fmt"+ "net/http"+ "testing"++ "connectrpc.com/connect"+ "github.com/google/uuid"+ "github.com/stretchr/testify/require"+ "google.golang.org/protobuf/types/known/fieldmaskpb"++ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"+)++// TestMCPGateServesAndRefusesByClass is the ceiling gate as an agent meets it:+// one live MCP session under the default workspace ceiling, calling one method+// of each class through call_api.+//+// The session is a workspace admin, so RBAC permits everything here. What+// refuses the two denied calls is the ceiling alone, which is the claim —+// effective = ceiling ∩ RBAC, and this test holds the ceiling term with the+// RBAC term saturated.+func TestMCPGateServesAndRefusesByClass(t *testing.T) {+ t.Parallel()+ a := require.New(t)+ ctx := context.Background()+ ctl := &controller{}++ ctx, err := ctl.StartServerWithExternalPg(ctx)+ a.NoError(err)+ defer ctl.Close(ctx)++ workspace, err := ctl.workspaceServiceClient.GetWorkspace(ctx, connect.NewRequest(&v1pb.GetWorkspaceRequest{+ Name: "workspaces/-",+ }))+ a.NoError(err)+ workspaceName := workspace.Msg.Name++ project, err := ctl.projectServiceClient.CreateProject(ctx, connect.NewRequest(&v1pb.CreateProjectRequest{+ ProjectId: "mcp-gate",+ Project: &v1pb.Project{Title: "MCP gate"},+ }))+ a.NoError(err)+ projectName := project.Msg.Name++ session := openMCPSession(ctx, t, ctl, ctl.authInterceptor.token)+ defer session.Close()++ // READ: served under every ceiling that admits a connection at all.+ a.Equal(http.StatusOK, callAPIStatus(ctx, t, session, "WorkspaceService/ListWorkspaces", nil))++ // WRITE: served because the workspace ceiling is unset, which resolves+ // READ_WRITE.+ sheet := callAPIOnSession(ctx, t, session, "SheetService/CreateSheet", map[string]any{+ "parent": projectName,+ "sheet": map[string]any{"content": base64.StdEncoding.EncodeToString([]byte("SELECT 1;"))},+ })+ a.Equal(http.StatusOK, sheet.Status, "a read-write session must reach a WRITE method: %s", sheet.Error)++ // EXCLUDED: refused whatever the ceiling, with the reason the annotation+ // records — this one is workspace administration, which no mode this phase+ // ships covers.+ excluded := callAPIOnSession(ctx, t, session, "UserService/ListUsers", map[string]any{})+ a.Equal(http.StatusForbidden, excluded.Status)+ a.Contains(excluded.Error, "administers the workspace")+ a.Contains(excluded.Error, "Bytebase console", "the denial must name where the human can do it instead")++ // FORBIDDEN: refused with a different recorded reason, so the two classes+ // do not collapse into one sentence an operator cannot tell apart.+ forbidden := callAPIOnSession(ctx, t, session, "AuthService/Logout", map[string]any{})+ a.Equal(http.StatusForbidden, forbidden.Status)+ a.Contains(forbidden.Error, "ends the human's own login session")++ // The EXCLUDED denial is audited, and ListUsers carries no audit+ // annotation: the record comes from the gate, not from the method.+ a.Len(deniedMCPRows(ctx, t, ctl, workspaceName, "/bytebase.v1.UserService/ListUsers"), 1,+ "a policy denial is recorded even where the method asks for no audit row")+}++// TestMCPGateRefusesGrantIssues is the one refusal a per-method class cannot+// express, over the live handler. CreateIssue is WRITE for the database-change+// issue an agent exists to compose; a ROLE_GRANT issue completes on creation+// when the workspace rule produces no approval template and writes the project+// IAM binding the request named, with no human in it.+func TestMCPGateRefusesGrantIssues(t *testing.T) {+ t.Parallel()+ a := require.New(t)+ ctx := context.Background()+ ctl := &controller{}++ ctx, err := ctl.StartServerWithExternalPg(ctx)+ a.NoError(err)+ defer ctl.Close(ctx)++ project, err := ctl.projectServiceClient.CreateProject(ctx, connect.NewRequest(&v1pb.CreateProjectRequest{+ ProjectId: "mcp-grant-issue",+ Project: &v1pb.Project{Title: "MCP grant issue"},+ }))+ a.NoError(err)+ projectName := project.Msg.Name++ session := openMCPSession(ctx, t, ctl, ctl.authInterceptor.token)+ defer session.Close()++ grant := callAPIOnSession(ctx, t, session, "IssueService/CreateIssue", map[string]any{+ "parent": projectName,+ "issue": map[string]any{+ "type": "ROLE_GRANT",+ "title": "grant me project owner",+ "roleGrant": map[string]any{+ "role": "roles/projectOwner",+ "user": "users/[email protected]",+ },+ },+ })+ a.Equal(http.StatusForbidden, grant.Status)+ a.Contains(grant.Error, "ROLE_GRANT", "the denial must name the issue type it refused")+ a.Contains(grant.Error, "no human step")++ // The bypass: UpdateIssue with allow_missing creates the issue when it does+ // not exist, by calling CreateIssue directly — a Go call, so the ceiling+ // gate never sees it. The gate deliberately does not refuse UpdateIssue,+ // because an AIP upsert sends the complete resource and the request cannot+ // say whether it will create anything; the guard sits at the creation+ // instead, and this is what proves it is there.+ upsert := callAPIOnSession(ctx, t, session, "IssueService/UpdateIssue", map[string]any{+ "issue": map[string]any{+ "name": projectName + "/issues/999999",+ "title": "grant me project owner",+ "type": "ROLE_GRANT",+ "roleGrant": map[string]any{+ "role": "roles/projectOwner",+ "user": "users/[email protected]",+ },+ },+ "updateMask": "title",+ "allowMissing": true,+ })+ a.Equal(http.StatusForbidden, upsert.Status,+ "allow_missing on a missing issue is a creation, and the guard must reach it: %s", upsert.Error)+ a.Contains(upsert.Error, "may not create a ROLE_GRANT issue")++ // The same upsert for the type an agent is allowed to create reaches the+ // handler, which then asks for the plan it has no way to do without. The+ // refusal is about the issue type, not about allow_missing.+ changeUpsert := callAPIOnSession(ctx, t, session, "IssueService/UpdateIssue", map[string]any{+ "issue": map[string]any{+ "name": projectName + "/issues/999998",+ "title": "an ordinary change",+ "type": "DATABASE_CHANGE",+ },+ "updateMask": "title",+ "allowMissing": true,+ })+ a.NotEqual(http.StatusForbidden, changeUpsert.Status,+ "a database-change upsert must reach the handler: %s", changeUpsert.Error)++ // The same method with the type it is classified for reaches its handler.+ // A missing plan is the handler's own complaint, which is the point: the+ // gate did not answer this one.+ change := callAPIOnSession(ctx, t, session, "IssueService/CreateIssue", map[string]any{+ "parent": projectName,+ "issue": map[string]any{"type": "DATABASE_CHANGE", "title": "an ordinary change"},+ })+ a.Equal(http.StatusBadRequest, change.Status,+ "a database-change issue must reach the handler, which then asks for its plan: %s", change.Error)+ a.NotContains(change.Error, "not available to MCP sessions")+}++// TestMCPCannotRunAnIssuelessRollout is the rule rollout_service.proto says the+// gate PR owes, and the reason it is a rule rather than a classification.+//+// Three approval RPCs are FORBIDDEN so an agent cannot move its own change+// through the human gate. That buys nothing if the agent can go round it: both+// approval checks on the execution path are guarded on a LINKED ISSUE existing,+// so a plan created without one reaches task creation with no approval whatever+// require_issue_approval says. CreatePlan, CreateRollout and BatchRunTasks are+// all WRITE and stay WRITE — issueless deployment is a supported contract, the+// shipped GitOps Service Agent role holds no issue permission at all — so the+// refusal is per session, not per method.+//+// The ceiling gate cannot take it: "the plan has no linked issue" is not a+// field of either request. The guard sits where the fact is loaded, and the+// control that matters most is the last one — a human doing the identical thing+// must be unaffected, because that is the risk of putting MCP policy in a+// handler at all.+func TestMCPCannotRunAnIssuelessRollout(t *testing.T) {+ t.Parallel()+ a := require.New(t)+ ctx := context.Background()+ ctl := &controller{}++ ctx, err := ctl.StartServerWithExternalPg(ctx)+ a.NoError(err)+ defer ctl.Close(ctx)++ pgContainer, err := provisionPgInstance(ctx, t)+ a.NoError(err)+ instanceResp, err := ctl.instanceServiceClient.CreateInstance(ctx, connect.NewRequest(&v1pb.CreateInstanceRequest{+ InstanceId: generateRandomString("inst"),+ Instance: &v1pb.Instance{+ Title: "MCP rollout instance",+ Engine: v1pb.Engine_POSTGRES,+ Environment: new("environments/prod"),+ Activation: true,+ DataSources: []*v1pb.DataSource{pgContainer.adminDataSource()},+ },+ }))+ a.NoError(err)+ dbName := generateRandomString("db")+ a.NoError(ctl.createDatabase(ctx, ctl.project, instanceResp.Msg, nil, dbName, ""))+ target := fmt.Sprintf("%s/databases/%s", instanceResp.Msg.Name, dbName)++ // The project requires issue approval, which is the whole point: the+ // customer turned the gate on.+ project := ctl.project+ project.RequireIssueApproval = true+ updated, err := ctl.projectServiceClient.UpdateProject(ctx, connect.NewRequest(&v1pb.UpdateProjectRequest{+ Project: project,+ UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"require_issue_approval"}},+ }))+ a.NoError(err)+ a.True(updated.Msg.RequireIssueApproval)++ // A plan with no issue, created the way an agent would.+ sheetResp, err := ctl.sheetServiceClient.CreateSheet(ctx, connect.NewRequest(&v1pb.CreateSheetRequest{+ Parent: ctl.project.Name,+ Sheet: &v1pb.Sheet{Content: []byte("CREATE TABLE mcp_rollout_guard(id INT);")},+ }))+ a.NoError(err)+ planResp, err := ctl.planServiceClient.CreatePlan(ctx, connect.NewRequest(&v1pb.CreatePlanRequest{+ Parent: ctl.project.Name,+ Plan: &v1pb.Plan{Specs: []*v1pb.Plan_Spec{{+ Id: uuid.NewString(),+ Config: &v1pb.Plan_Spec_ChangeDatabaseConfig{+ ChangeDatabaseConfig: &v1pb.Plan_ChangeDatabaseConfig{+ Targets: []string{target},+ Sheet: sheetResp.Msg.Name,+ },+ },+ }}},+ }))+ a.NoError(err)++ session := openMCPSession(ctx, t, ctl, ctl.authInterceptor.token)+ defer session.Close()++ rollout := callAPIOnSession(ctx, t, session, "RolloutService/CreateRollout", map[string]any{+ "parent": planResp.Msg.Name,+ })+ a.Equal(http.StatusForbidden, rollout.Status,+ "an MCP session must not start an issueless change on a project that requires approval: %s", rollout.Error)+ a.Contains(rollout.Error, "plan with no issue")+ a.Contains(rollout.Error, "Bytebase console", "the denial must name where the human can do it instead")++ // The control that makes the handler guard safe: the same call, same plan,+ // same setting, on the public chain. A human — and the GitOps agent, which+ // holds no issue permission at all — must be unaffected.+ consoleRollout, err := ctl.rolloutServiceClient.CreateRollout(ctx, connect.NewRequest(&v1pb.CreateRolloutRequest{+ Parent: planResp.Msg.Name,+ }))+ a.NoError(err, "the guard binds MCP sessions and nothing else")+ a.NotEmpty(consoleRollout.Msg.Name)+}diff --git a/backend/tests/mcp_migration_matrix_test.go b/backend/tests/mcp_migration_matrix_test.goindex 8c27838c86..94e0a2904b 100644--- a/backend/tests/mcp_migration_matrix_test.go+++ b/backend/tests/mcp_migration_matrix_test.go@@ -176,20 +176,28 @@ func TestMCPMigrationGrantStateMatrix(t *testing.T) {a.NoError(err)defer ctl.Close(ctx)- workspace, err := ctl.workspaceServiceClient.GetWorkspace(ctx, connect.NewRequest(&v1pb.GetWorkspaceRequest{- Name: "workspaces/-",+ // The probe is an audited mutation, so each session leaves exactly one+ // provenance-carrying row to sort out below, and it is a WRITE method+ // because the MCP ceiling serves READ and WRITE only. Every audited+ // serving-class method is project-scoped, hence the project.+ project, err := ctl.projectServiceClient.CreateProject(ctx, connect.NewRequest(&v1pb.CreateProjectRequest{+ ProjectId: "mcp-grant-matrix",+ Project: &v1pb.Project{Title: "MCP grant matrix"},}))a.NoError(err)+ createSheet := func(sql string) map[string]any {+ return map[string]any{+ "parent": project.Msg.Name,+ "sheet": map[string]any{"content": base64.StdEncoding.EncodeToString([]byte(sql))},+ }+ }// Row 3: the legacy admission — a plain web-session token driving MCP.- // The call is an audited mutation, so each session leaves exactly one- // provenance-carrying row to sort out below.plainSession := openMCPSession(ctx, t, ctl, ctl.authInterceptor.token)defer plainSession.Close()- a.Equal(http.StatusOK, callAPIStatus(ctx, t, plainSession, "GroupService/CreateGroup", map[string]any{- "group": map[string]any{"title": "driven by a pre-grant session"},- "groupEmail": "[email protected]",- }), "a plain web-session token must keep working through tools")+ a.Equal(http.StatusOK, callAPIStatus(ctx, t, plainSession, "SheetService/CreateSheet",+ createSheet("SELECT 'driven by a pre-grant session';")),+ "a plain web-session token must keep working through tools")// Row 4: a real consent that never names a scope.scopelessToken, scopelessRefresh, clientID := mintMCPOAuthTokenWithScope(t, ctl, ctl.authInterceptor.token, "")@@ -211,15 +219,14 @@ func TestMCPMigrationGrantStateMatrix(t *testing.T) {scopelessSession := openMCPSession(ctx, t, ctl, scopelessToken)defer scopelessSession.Close()- a.Equal(http.StatusOK, callAPIStatus(ctx, t, scopelessSession, "GroupService/CreateGroup", map[string]any{- "group": map[string]any{"title": "driven by a scope-less grant"},- "groupEmail": "[email protected]",- }), "a grant that recorded no scope must still work end to end")+ a.Equal(http.StatusOK, callAPIStatus(ctx, t, scopelessSession, "SheetService/CreateSheet",+ createSheet("SELECT 'driven by a scope-less grant';")),+ "a grant that recorded no scope must still work end to end")// What an operator investigating these sessions sees.rows, err := ctl.auditLogServiceClient.SearchAuditLogs(ctx, connect.NewRequest(&v1pb.SearchAuditLogsRequest{- Parent: workspace.Msg.Name,- Filter: `method == "/bytebase.v1.GroupService/CreateGroup"`,+ Parent: project.Msg.Name,+ Filter: `method == "/bytebase.v1.SheetService/CreateSheet"`,OrderBy: "create_time desc",}))a.NoError(err)@@ -297,10 +304,11 @@ func TestMCPMigrationCeilingLookupFailureFailsClosed(t *testing.T) {defer db.Close()// The stored ceiling is given a value the profile cannot be parsed with, so- // the read errors. An unrecognized enum NAME would not do it: the store's- // unmarshaler discards values it does not know, so such a ceiling reads- // back as unset — a different behavior, and one this test deliberately does- // not assert either way.+ // the read errors outright. That is a distinct arm from an unrecognized+ // enum NAME, which the store's unmarshaler discards: a name it does not+ // know is caught by the raw-key check in GetMCPCapabilityUncached and also+ // fails closed, and TestMCPCeilingStoredValueFailsClosed+ // (backend/api/mcp) owns that case. This one is the unmarshal error itself.restore := func() {result, err := db.ExecContext(ctx, `UPDATE setting SET value = value - 'mcpCapability'@@ -341,7 +349,10 @@ func TestMCPMigrationCeilingLookupFailureFailsClosed(t *testing.T) {session := openMCPSession(ctx, t, ctl, mcpToken)defer session.Close()- a.Equal(http.StatusOK, callAPIStatus(ctx, t, session, "ProjectService/ListProjects", nil))+ // The probe is a READ method deliberately: the MCP gate serves READ and+ // WRITE and refuses everything else, so an EXCLUDED probe would answer 403+ // for a reason that has nothing to do with the ceiling this test is about.+ a.Equal(http.StatusOK, callAPIStatus(ctx, t, session, "WorkspaceService/ListWorkspaces", nil))}// TestMCPMigrationTightenedCeilingBitesLiveSession is matrix row 7: tightening@@ -365,7 +376,7 @@ func TestMCPMigrationTightenedCeilingBitesLiveSession(t *testing.T) {mcpToken, _ := mintMCPOAuthToken(t, ctl, ctl.authInterceptor.token)session := openMCPSession(ctx, t, ctl, mcpToken)defer session.Close()- a.Equal(http.StatusOK, callAPIStatus(ctx, t, session, "ProjectService/ListProjects", nil),+ a.Equal(http.StatusOK, callAPIStatus(ctx, t, session, "WorkspaceService/ListWorkspaces", nil),"the session is live under the default ceiling")// An admin tightens the ceiling while the session stays open.@@ -378,7 +389,7 @@ func TestMCPMigrationTightenedCeilingBitesLiveSession(t *testing.T) {_, err = session.CallTool(ctx, &mcp.CallToolParams{Name: "call_api",- Arguments: map[string]any{"operationId": "ProjectService/ListProjects"},+ Arguments: map[string]any{"operationId": "WorkspaceService/ListWorkspaces"},})// The cause matters, not just the failure: a bare "some error" would go// green if the session broke for an unrelated reason while the ceiling@@ -391,5 +402,5 @@ func TestMCPMigrationTightenedCeilingBitesLiveSession(t *testing.T) {a.NoError(ctl.setMCPCapability(ctx, v1pb.WorkspaceProfileSetting_READ_WRITE))restored := openMCPSession(ctx, t, ctl, mcpToken)defer restored.Close()- a.Equal(http.StatusOK, callAPIStatus(ctx, t, restored, "ProjectService/ListProjects", nil))+ a.Equal(http.StatusOK, callAPIStatus(ctx, t, restored, "WorkspaceService/ListWorkspaces", nil))}diff --git a/backend/tests/mcp_token_boundary_test.go b/backend/tests/mcp_token_boundary_test.goindex 143999d4be..6496e48649 100644--- a/backend/tests/mcp_token_boundary_test.go+++ b/backend/tests/mcp_token_boundary_test.go@@ -181,7 +181,7 @@ func TestMCPTokenIsRejectedOnGeneralAPI(t *testing.T) {callTool := func() {result, err := session.CallTool(ctx, &mcp.CallToolParams{Name: "call_api",- Arguments: map[string]any{"operationId": "ProjectService/ListProjects"},+ Arguments: map[string]any{"operationId": "WorkspaceService/ListWorkspaces"},})a.NoError(err)raw, err := json.Marshal(result.StructuredContent)@@ -199,9 +199,9 @@ func TestMCPTokenIsRejectedOnGeneralAPI(t *testing.T) {// The very same bearer on the public v1 API is refused before any identity// resolution — the principal behind it is a workspace admin, so anything// but Unauthenticated here would mean the token still works as an API key.- asMCPToken := v1connect.NewProjectServiceClient(ctl.client, ctl.rootURL,+ asMCPToken := v1connect.NewWorkspaceServiceClient(ctl.client, ctl.rootURL,connect.WithInterceptors(&authInterceptor{token: mcpToken}))- _, err = asMCPToken.ListProjects(ctx, connect.NewRequest(&v1pb.ListProjectsRequest{}))+ _, err = asMCPToken.ListWorkspaces(ctx, connect.NewRequest(&v1pb.ListWorkspacesRequest{}))a.Error(err, "an MCP token must not be a general API bearer")a.Equal(connect.CodeUnauthenticated, connect.CodeOf(err))a.Contains(err.Error(), "only accepted at /mcp")diff --git a/backend/tests/mcp_tool_parity_test.go b/backend/tests/mcp_tool_parity_test.goindex 5040e050d4..4226b4190e 100644--- a/backend/tests/mcp_tool_parity_test.go+++ b/backend/tests/mcp_tool_parity_test.go@@ -42,12 +42,16 @@ func TestMCPToolCallParity(t *testing.T) {a.NoError(err)defer ctl.Close(ctx)- // Parity baseline: the principal's direct v1 API view.- direct, err := ctl.projectServiceClient.ListProjects(ctx, connect.NewRequest(&v1pb.ListProjectsRequest{}))+ // Parity baseline: the principal's direct v1 API view. The probe is+ // ListWorkspaces rather than ListProjects because the project reads are+ // EXCLUDED from the MCP ceiling (they return the incoming-webhook URL+ // verbatim, BOT-60); a probe the gate refuses would test the gate, not+ // parity. Any READ method whose result is scoped to the caller does.+ direct, err := ctl.workspaceServiceClient.ListWorkspaces(ctx, connect.NewRequest(&v1pb.ListWorkspacesRequest{}))a.NoError(err)var directNames []string- for _, p := range direct.Msg.Projects {- directNames = append(directNames, p.Name)+ for _, w := range direct.Msg.Workspaces {+ directNames = append(directNames, w.Name)}a.NotEmpty(directNames)@@ -65,7 +69,7 @@ func TestMCPToolCallParity(t *testing.T) {result, err := session.CallTool(ctx, &mcp.CallToolParams{Name: "call_api",- Arguments: map[string]any{"operationId": "ProjectService/ListProjects"},+ Arguments: map[string]any{"operationId": "WorkspaceService/ListWorkspaces"},})a.NoError(err)a.False(result.IsError, "call_api must succeed through the internal transport: %v", result.Content)@@ -75,20 +79,20 @@ func TestMCPToolCallParity(t *testing.T) {var out struct {Status int `json:"status"`Response struct {- Projects []struct {+ Workspaces []struct {Name string `json:"name"`- } `json:"projects"`+ } `json:"workspaces"`} `json:"response"`}a.NoError(json.Unmarshal(raw, &out))a.Equal(http.StatusOK, out.Status)var mcpNames []string- for _, p := range out.Response.Projects {- mcpNames = append(mcpNames, p.Name)+ for _, w := range out.Response.Workspaces {+ mcpNames = append(mcpNames, w.Name)}a.ElementsMatch(directNames, mcpNames,- "the MCP tool call must see exactly the projects the same principal sees directly")+ "the MCP tool call must see exactly what the same principal sees directly")}// TestMCPCannotMintPlainUserToken pins the boundary escape that riding thediff --git a/frontend/src/types/proto-es/v1/access_grant_service_pb.js b/frontend/src/types/proto-es/v1/access_grant_service_pb.jsindex a997c13c00..e1fc784596 100644--- a/frontend/src/types/proto-es/v1/access_grant_service_pb.js+++ b/frontend/src/types/proto-es/v1/access_grant_service_pb.js@@ -14,7 +14,7 @@ import { file_v1_annotation } from "./annotation_pb";* Describes the file v1/access_grant_service.proto.*/export const file_v1_access_grant_service = /*@__PURE__*/- fileDesc("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", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_duration, file_google_protobuf_timestamp, file_v1_annotation]);+ fileDesc("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", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_duration, file_google_protobuf_timestamp, file_v1_annotation]);/*** Describes the message bytebase.v1.AccessGrant.diff --git a/frontend/src/types/proto-es/v1/actuator_service_pb.js b/frontend/src/types/proto-es/v1/actuator_service_pb.jsindex f8d7388d5f..458f1cb270 100644--- a/frontend/src/types/proto-es/v1/actuator_service_pb.js+++ b/frontend/src/types/proto-es/v1/actuator_service_pb.js@@ -13,7 +13,7 @@ import { file_v1_annotation } from "./annotation_pb";* Describes the file v1/actuator_service.proto.*/export const file_v1_actuator_service = /*@__PURE__*/- fileDesc("Chl2MS9hY3R1YXRvcl9zZXJ2aWNlLnByb3RvEgtieXRlYmFzZS52MSIUChJTZXR1cFNhbXBsZVJlcXVlc3QiGAoWR2V0QWN0dWF0b3JJbmZvUmVxdWVzdCKZBAoMQWN0dWF0b3JJbmZvEhQKB3ZlcnNpb24YASABKAlCA+BBAxIXCgpnaXRfY29tbWl0GAIgASgJQgPgQQMSEQoEc2FhcxgEIAEoCEID4EEDEhkKDGV4dGVybmFsX3VybBgIIAEoCUID4EEDEjkKEGxhc3RfYWN0aXZlX3RpbWUYCyABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQgPgQQMSFgoJd29ya3NwYWNlGA0gASgJQgPgQQMSIAoTdW5saWNlbnNlZF9mZWF0dXJlcxgPIAMoCUID4EEDEiUKGGFjdGl2YXRlZF9pbnN0YW5jZV9jb3VudBgUIAEoBUID4EEDEiEKFHRvdGFsX2luc3RhbmNlX2NvdW50GBUgASgFQgPgQQMSGgoNZW5hYmxlX3NhbXBsZRgWIAEoCEID4EEDEiMKFmV4dGVybmFsX3VybF9mcm9tX2ZsYWcYFyABKAhCA+BBAxIaCg1yZXBsaWNhX2NvdW50GBggASgFQgPgQQMSHAoPZGVmYXVsdF9wcm9qZWN0GBogASgJQgPgQQMSHgoRdXNlcl9jb3VudF9pbl9pYW0YGyABKAVCA+BBAxIiChVhY3RpdmVfdmNzX3VzZXJfY291bnQYHCABKAVCA+BBA0oECAMQBEoECAUQCEoECAkQCkoECAoQC0oECAwQDUoECA4QD0oECBAQFEoECBkQGjKXAgoPQWN0dWF0b3JTZXJ2aWNlEnMKD0dldEFjdHVhdG9ySW5mbxIjLmJ5dGViYXNlLnYxLkdldEFjdHVhdG9ySW5mb1JlcXVlc3QaGS5ieXRlYmFzZS52MS5BY3R1YXRvckluZm8iINpBAKDqMAGC0+STAhMSES92MS9hY3R1YXRvci9pbmZvEo4BCgtTZXR1cFNhbXBsZRIfLmJ5dGViYXNlLnYxLlNldHVwU2FtcGxlUmVxdWVzdBoWLmdvb2dsZS5wcm90b2J1Zi5FbXB0eSJGiuowEmJiLnByb2plY3RzLmNyZWF0ZZDqMAGY6jABoOowBLDqMAGC0+STAhoiGC92MS9hY3R1YXRvcjpzZXR1cFNhbXBsZUKqAQoPY29tLmJ5dGViYXNlLnYxQhRBY3R1YXRvclNlcnZpY2VQcm90b1ABWjRnaXRodWIuY29tL2J5dGViYXNlL2J5dGViYXNlL2JhY2tlbmQvZ2VuZXJhdGVkLWdvL3YxogIDQlhYqgILQnl0ZWJhc2UuVjHKAgtCeXRlYmFzZVxWMeICF0J5dGViYXNlXFYxXEdQQk1ldGFkYXRh6gIMQnl0ZWJhc2U6OlYxYgZwcm90bzM", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_protobuf_empty, file_google_protobuf_timestamp, file_v1_annotation]);+ fileDesc("Chl2MS9hY3R1YXRvcl9zZXJ2aWNlLnByb3RvEgtieXRlYmFzZS52MSIUChJTZXR1cFNhbXBsZVJlcXVlc3QiGAoWR2V0QWN0dWF0b3JJbmZvUmVxdWVzdCKZBAoMQWN0dWF0b3JJbmZvEhQKB3ZlcnNpb24YASABKAlCA+BBAxIXCgpnaXRfY29tbWl0GAIgASgJQgPgQQMSEQoEc2FhcxgEIAEoCEID4EEDEhkKDGV4dGVybmFsX3VybBgIIAEoCUID4EEDEjkKEGxhc3RfYWN0aXZlX3RpbWUYCyABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQgPgQQMSFgoJd29ya3NwYWNlGA0gASgJQgPgQQMSIAoTdW5saWNlbnNlZF9mZWF0dXJlcxgPIAMoCUID4EEDEiUKGGFjdGl2YXRlZF9pbnN0YW5jZV9jb3VudBgUIAEoBUID4EEDEiEKFHRvdGFsX2luc3RhbmNlX2NvdW50GBUgASgFQgPgQQMSGgoNZW5hYmxlX3NhbXBsZRgWIAEoCEID4EEDEiMKFmV4dGVybmFsX3VybF9mcm9tX2ZsYWcYFyABKAhCA+BBAxIaCg1yZXBsaWNhX2NvdW50GBggASgFQgPgQQMSHAoPZGVmYXVsdF9wcm9qZWN0GBogASgJQgPgQQMSHgoRdXNlcl9jb3VudF9pbl9pYW0YGyABKAVCA+BBAxIiChVhY3RpdmVfdmNzX3VzZXJfY291bnQYHCABKAVCA+BBA0oECAMQBEoECAUQCEoECAkQCkoECAoQC0oECAwQDUoECA4QD0oECBAQFEoECBkQGjKXAgoPQWN0dWF0b3JTZXJ2aWNlEnMKD0dldEFjdHVhdG9ySW5mbxIjLmJ5dGViYXNlLnYxLkdldEFjdHVhdG9ySW5mb1JlcXVlc3QaGS5ieXRlYmFzZS52MS5BY3R1YXRvckluZm8iINpBAKDqMAGC0+STAhMSES92MS9hY3R1YXRvci9pbmZvEo4BCgtTZXR1cFNhbXBsZRIfLmJ5dGViYXNlLnYxLlNldHVwU2FtcGxlUmVxdWVzdBoWLmdvb2dsZS5wcm90b2J1Zi5FbXB0eSJGiuowEmJiLnByb2plY3RzLmNyZWF0ZZDqMAGY6jABoOowBKjqMAmC0+STAhoiGC92MS9hY3R1YXRvcjpzZXR1cFNhbXBsZUKqAQoPY29tLmJ5dGViYXNlLnYxQhRBY3R1YXRvclNlcnZpY2VQcm90b1ABWjRnaXRodWIuY29tL2J5dGViYXNlL2J5dGViYXNlL2JhY2tlbmQvZ2VuZXJhdGVkLWdvL3YxogIDQlhYqgILQnl0ZWJhc2UuVjHKAgtCeXRlYmFzZVxWMeICF0J5dGViYXNlXFYxXEdQQk1ldGFkYXRh6gIMQnl0ZWJhc2U6OlYxYgZwcm90bzM", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_protobuf_empty, file_google_protobuf_timestamp, file_v1_annotation]);/*** Describes the message bytebase.v1.SetupSampleRequest.diff --git a/frontend/src/types/proto-es/v1/ai_service_pb.js b/frontend/src/types/proto-es/v1/ai_service_pb.jsindex 4e9d73b573..f93b82d084 100644--- a/frontend/src/types/proto-es/v1/ai_service_pb.js+++ b/frontend/src/types/proto-es/v1/ai_service_pb.js@@ -10,7 +10,7 @@ import { file_v1_annotation } from "./annotation_pb";* Describes the file v1/ai_service.proto.*/export const file_v1_ai_service = /*@__PURE__*/- fileDesc("ChN2MS9haV9zZXJ2aWNlLnByb3RvEgtieXRlYmFzZS52MSK8AQoNQUlDaGF0TWVzc2FnZRIsCgRyb2xlGAEgASgOMh4uYnl0ZWJhc2UudjEuQUlDaGF0TWVzc2FnZVJvbGUSFAoHY29udGVudBgCIAEoCUgAiAEBEi8KCnRvb2xfY2FsbHMYAyADKAsyGy5ieXRlYmFzZS52MS5BSUNoYXRUb29sQ2FsbBIZCgx0b29sX2NhbGxfaWQYBCABKAlIAYgBAUIKCghfY29udGVudEIPCg1fdG9vbF9jYWxsX2lkIlQKFEFJQ2hhdFRvb2xEZWZpbml0aW9uEgwKBG5hbWUYASABKAkSEwoLZGVzY3JpcHRpb24YAiABKAkSGQoRcGFyYW1ldGVyc19zY2hlbWEYAyABKAkiYQoOQUlDaGF0VG9vbENhbGwSCgoCaWQYASABKAkSDAoEbmFtZRgCIAEoCRIRCglhcmd1bWVudHMYAyABKAkSFQoIbWV0YWRhdGEYBCABKAlIAIgBAUILCglfbWV0YWRhdGEiegoNQUlDaGF0UmVxdWVzdBIsCghtZXNzYWdlcxgBIAMoCzIaLmJ5dGViYXNlLnYxLkFJQ2hhdE1lc3NhZ2USOwoQdG9vbF9kZWZpbml0aW9ucxgCIAMoCzIhLmJ5dGViYXNlLnYxLkFJQ2hhdFRvb2xEZWZpbml0aW9uIiMKC0FJQ2hhdFVzYWdlEhQKDHRvdGFsX3Rva2VucxgBIAEoBSKbAQoOQUlDaGF0UmVzcG9uc2USFAoHY29udGVudBgBIAEoCUgAiAEBEi8KCnRvb2xfY2FsbHMYAiADKAsyGy5ieXRlYmFzZS52MS5BSUNoYXRUb29sQ2FsbBIsCgV1c2FnZRgDIAEoCzIYLmJ5dGViYXNlLnYxLkFJQ2hhdFVzYWdlSAGIAQFCCgoIX2NvbnRlbnRCCAoGX3VzYWdlKrwBChFBSUNoYXRNZXNzYWdlUm9sZRIkCiBBSV9DSEFUX01FU1NBR0VfUk9MRV9VTlNQRUNJRklFRBAAEh8KG0FJX0NIQVRfTUVTU0FHRV9ST0xFX1NZU1RFTRABEh0KGUFJX0NIQVRfTUVTU0FHRV9ST0xFX1VTRVIQAhIiCh5BSV9DSEFUX01FU1NBR0VfUk9MRV9BU1NJU1RBTlQQAxIdChlBSV9DSEFUX01FU1NBR0VfUk9MRV9UT09MEAQycAoJQUlTZXJ2aWNlEmMKBENoYXQSGi5ieXRlYmFzZS52MS5BSUNoYXRSZXF1ZXN0GhsuYnl0ZWJhc2UudjEuQUlDaGF0UmVzcG9uc2UiIpDqMAKg6jAEsOowBILT5JMCEDoBKiILL3YxL2FpL2NoYXRCpAEKD2NvbS5ieXRlYmFzZS52MUIOQWlTZXJ2aWNlUHJvdG9QAVo0Z2l0aHViLmNvbS9ieXRlYmFzZS9ieXRlYmFzZS9iYWNrZW5kL2dlbmVyYXRlZC1nby92MaICA0JYWKoCC0J5dGViYXNlLlYxygILQnl0ZWJhc2VcVjHiAhdCeXRlYmFzZVxWMVxHUEJNZXRhZGF0YeoCDEJ5dGViYXNlOjpWMWIGcHJvdG8z", [file_google_api_annotations, file_v1_annotation]);+ fileDesc("ChN2MS9haV9zZXJ2aWNlLnByb3RvEgtieXRlYmFzZS52MSK8AQoNQUlDaGF0TWVzc2FnZRIsCgRyb2xlGAEgASgOMh4uYnl0ZWJhc2UudjEuQUlDaGF0TWVzc2FnZVJvbGUSFAoHY29udGVudBgCIAEoCUgAiAEBEi8KCnRvb2xfY2FsbHMYAyADKAsyGy5ieXRlYmFzZS52MS5BSUNoYXRUb29sQ2FsbBIZCgx0b29sX2NhbGxfaWQYBCABKAlIAYgBAUIKCghfY29udGVudEIPCg1fdG9vbF9jYWxsX2lkIlQKFEFJQ2hhdFRvb2xEZWZpbml0aW9uEgwKBG5hbWUYASABKAkSEwoLZGVzY3JpcHRpb24YAiABKAkSGQoRcGFyYW1ldGVyc19zY2hlbWEYAyABKAkiYQoOQUlDaGF0VG9vbENhbGwSCgoCaWQYASABKAkSDAoEbmFtZRgCIAEoCRIRCglhcmd1bWVudHMYAyABKAkSFQoIbWV0YWRhdGEYBCABKAlIAIgBAUILCglfbWV0YWRhdGEiegoNQUlDaGF0UmVxdWVzdBIsCghtZXNzYWdlcxgBIAMoCzIaLmJ5dGViYXNlLnYxLkFJQ2hhdE1lc3NhZ2USOwoQdG9vbF9kZWZpbml0aW9ucxgCIAMoCzIhLmJ5dGViYXNlLnYxLkFJQ2hhdFRvb2xEZWZpbml0aW9uIiMKC0FJQ2hhdFVzYWdlEhQKDHRvdGFsX3Rva2VucxgBIAEoBSKbAQoOQUlDaGF0UmVzcG9uc2USFAoHY29udGVudBgBIAEoCUgAiAEBEi8KCnRvb2xfY2FsbHMYAiADKAsyGy5ieXRlYmFzZS52MS5BSUNoYXRUb29sQ2FsbBIsCgV1c2FnZRgDIAEoCzIYLmJ5dGViYXNlLnYxLkFJQ2hhdFVzYWdlSAGIAQFCCgoIX2NvbnRlbnRCCAoGX3VzYWdlKrwBChFBSUNoYXRNZXNzYWdlUm9sZRIkCiBBSV9DSEFUX01FU1NBR0VfUk9MRV9VTlNQRUNJRklFRBAAEh8KG0FJX0NIQVRfTUVTU0FHRV9ST0xFX1NZU1RFTRABEh0KGUFJX0NIQVRfTUVTU0FHRV9ST0xFX1VTRVIQAhIiCh5BSV9DSEFUX01FU1NBR0VfUk9MRV9BU1NJU1RBTlQQAxIdChlBSV9DSEFUX01FU1NBR0VfUk9MRV9UT09MEAQycAoJQUlTZXJ2aWNlEmMKBENoYXQSGi5ieXRlYmFzZS52MS5BSUNoYXRSZXF1ZXN0GhsuYnl0ZWJhc2UudjEuQUlDaGF0UmVzcG9uc2UiIpDqMAKg6jAEqOowDILT5JMCEDoBKiILL3YxL2FpL2NoYXRCpAEKD2NvbS5ieXRlYmFzZS52MUIOQWlTZXJ2aWNlUHJvdG9QAVo0Z2l0aHViLmNvbS9ieXRlYmFzZS9ieXRlYmFzZS9iYWNrZW5kL2dlbmVyYXRlZC1nby92MaICA0JYWKoCC0J5dGViYXNlLlYxygILQnl0ZWJhc2VcVjHiAhdCeXRlYmFzZVxWMVxHUEJNZXRhZGF0YeoCDEJ5dGViYXNlOjpWMWIGcHJvdG8z", [file_google_api_annotations, file_v1_annotation]);/*** Describes the message bytebase.v1.AIChatMessage.diff --git a/frontend/src/types/proto-es/v1/annotation_pb.d.ts b/frontend/src/types/proto-es/v1/annotation_pb.d.tsindex 87c6d02c3e..ad729f6eee 100644--- a/frontend/src/types/proto-es/v1/annotation_pb.d.ts+++ b/frontend/src/types/proto-es/v1/annotation_pb.d.ts@@ -48,20 +48,20 @@ export declare const AuthMethodSchema: GenEnum<AuthMethod>;* authorization of an MCP session is this classification intersected with the* caller's own RBAC: it can only ever narrow what the human could do, never* widen it.- * Only FORBIDDEN is enforced today. READ, WRITE and EXCLUDED are recorded- * classifications and nothing reads them at request time yet — the gate that- * selects between them is a later change. A method annotated READ or WRITE is- * therefore served exactly as it is today; the annotation states where it- * belongs, not where the boundary currently sits. FORBIDDEN is the exception- * and is enforced the moment it is annotated.+ * Every value is enforced, at the gate on the internal MCP chain. READ and+ * WRITE are the serving classes the workspace's MCP capability ceiling selects+ * between, EXCLUDED and FORBIDDEN are served by no ceiling, and an unclassified+ * method is refused rather than served. Annotating a method is therefore a+ * change to what an MCP session can reach, taking effect on the next request.** @generated from enum bytebase.v1.MCPMethodClass*/export enum MCPMethodClass {/**- * Not yet classified. Reaches its handler, subject to RBAC as usual. CI- * rejects this value on any v1 RPC, so it survives only inside a build that- * has not been linted: a new RPC is classified before it can ship.+ * Not yet classified, and refused. CI rejects this value on any v1 RPC, so+ * it survives only inside a build that has not been linted: a new RPC is+ * classified before it can ship, and one that somehow reaches an MCP session+ * unclassified is denied rather than guessed at.** @generated from enum value: MCP_METHOD_CLASS_UNSPECIFIED = 0;*/@@ -95,9 +95,10 @@ export enum MCPMethodClass {FORBIDDEN = 3,/**- * Served by no MCP mode this phase ships, and not a durable never. These are- * workspace administration, plus the handful of methods that do something- * materially worse than the plain read permission they share suggests.+ * Served by no MCP capability ceiling this phase ships, and not a durable+ * never. These are workspace administration, plus the handful of methods+ * that do something materially worse than the plain read permission they+ * share suggests.** The line against FORBIDDEN is reversibility. An admin-capable ceiling, if* one is ever built, could legitimately serve an EXCLUDED method — that is a@@ -117,22 +118,35 @@ export enum MCPMethodClass {export declare const MCPMethodClassSchema: GenEnum<MCPMethodClass>;/**- * Why an RPC is FORBIDDEN to MCP sessions. The mechanism, not the wording:- * each value names what its methods actually do, and the serving side turns- * that into a sentence. A denial whose stated reason has drifted from the- * mechanism is worse than a bare refusal, because it is the thing the next- * reader trusts — so a method changing what it does changes its reason here.+ * Why an MCP session may not call an RPC. The mechanism, not the wording: each+ * value names what its methods actually do, and the serving side turns that+ * into a sentence. A denial whose stated reason has drifted from the mechanism+ * is worse than a bare refusal, because it is the thing the next reader trusts+ * — so a method changing what it does changes its reason here.*- * @generated from enum bytebase.v1.MCPForbiddenReason+ * One enum covers both refused classes, and every value belongs to exactly one+ * of them: values 1-8 name a mechanism that breaks the MCP boundary, which is+ * what FORBIDDEN means, and values 9-13 name a scope decision this phase took,+ * which is what EXCLUDED means. The distinction is real and lives on the class+ * annotation — a FORBIDDEN mechanism is a durable never, an EXCLUDED scope+ * decision is what a future admin-capable ceiling would argue with, one+ * population at a time. Splitting it across two enums as well only made the+ * nonsense states representable: a method could carry both, or carry the kind+ * that contradicts its class. Neither is expressible now, and the one check+ * left — the reason belongs to the class it is used on — is a table the gate+ * already keeps for the wording.+ *+ * @generated from enum bytebase.v1.MCPDenialReason*/-export enum MCPForbiddenReason {+export enum MCPDenialReason {/*** No reason recorded. The method is still denied — mcp_method_class is what- * enforces — and the denial falls back to generic wording.+ * enforces — and the denial falls back to generic wording. CI rejects this+ * on a method classified FORBIDDEN or EXCLUDED.*- * @generated from enum value: MCP_FORBIDDEN_REASON_UNSPECIFIED = 0;+ * @generated from enum value: MCP_DENIAL_REASON_UNSPECIFIED = 0;*/- MCP_FORBIDDEN_REASON_UNSPECIFIED = 0,+ MCP_DENIAL_REASON_UNSPECIFIED = 0,/*** Puts a token for the caller's own principal in the response body.@@ -202,29 +216,6 @@ export enum MCPForbiddenReason {* @generated from enum value: DRIVES_THE_APPROVAL_DECISION = 8;*/DRIVES_THE_APPROVAL_DECISION = 8,-}--/**- * Describes the enum bytebase.v1.MCPForbiddenReason.- */-export declare const MCPForbiddenReasonSchema: GenEnum<MCPForbiddenReason>;--/**- * Why an RPC is served by no MCP mode. Unlike MCPForbiddenReason, which names- * a mechanism that breaks the MCP boundary, these name a scope decision: the- * method is out because this phase ships two modes and neither is the right- * home for it. Each value is what a future admin-capable ceiling would have to- * argue with, one population at a time.- *- * @generated from enum bytebase.v1.MCPExclusionReason- */-export enum MCPExclusionReason {- /**- * No reason recorded. CI rejects this on a method classified EXCLUDED.- *- * @generated from enum value: MCP_EXCLUSION_REASON_UNSPECIFIED = 0;- */- MCP_EXCLUSION_REASON_UNSPECIFIED = 0,/*** Administers the workspace rather than doing database work: identity,@@ -233,9 +224,9 @@ export enum MCPExclusionReason {* trail. Reading is administration too where the read returns the privilege* topology or a stored secret rather than the state of a database.*- * @generated from enum value: ADMINISTERS_THE_WORKSPACE = 1;+ * @generated from enum value: ADMINISTERS_THE_WORKSPACE = 9;*/- ADMINISTERS_THE_WORKSPACE = 1,+ ADMINISTERS_THE_WORKSPACE = 9,/*** Returns SQL that other people wrote. The permission gating it reads as an@@ -243,9 +234,9 @@ export enum MCPExclusionReason {* permission: these methods span the workspace or ignore the per-object* sharing that keeps a saved query private.*- * @generated from enum value: READS_OTHER_USERS_SQL = 2;+ * @generated from enum value: READS_OTHER_USERS_SQL = 10;*/- READS_OTHER_USERS_SQL = 2,+ READS_OTHER_USERS_SQL = 10,/*** Opens an admin-credentialed connection to the customer's database and@@ -253,17 +244,17 @@ export enum MCPExclusionReason {* unmasked SQL. It shares a plain read permission with sibling methods that* only read Bytebase's own store.*- * @generated from enum value: OPENS_AN_ADMIN_CONNECTION = 3;+ * @generated from enum value: OPENS_AN_ADMIN_CONNECTION = 11;*/- OPENS_AN_ADMIN_CONNECTION = 3,+ OPENS_AN_ADMIN_CONNECTION = 11,/*** Spends a stored workspace credential on an outbound call to a third* party, which puts whatever the caller passes outside the product.*- * @generated from enum value: SENDS_DATA_TO_A_THIRD_PARTY = 4;+ * @generated from enum value: SENDS_DATA_TO_A_THIRD_PARTY = 12;*/- SENDS_DATA_TO_A_THIRD_PARTY = 4,+ SENDS_DATA_TO_A_THIRD_PARTY = 12,/*** Returns a stored secret in its response body today. These are ordinary@@ -274,15 +265,15 @@ export enum MCPExclusionReason {* method to READ, as a reviewed widening, rather than leaving a quiet* exposure the moment the ceiling starts serving.*- * @generated from enum value: RETURNS_A_STORED_SECRET = 5;+ * @generated from enum value: RETURNS_A_STORED_SECRET = 13;*/- RETURNS_A_STORED_SECRET = 5,+ RETURNS_A_STORED_SECRET = 13,}/**- * Describes the enum bytebase.v1.MCPExclusionReason.+ * Describes the enum bytebase.v1.MCPDenialReason.*/-export declare const MCPExclusionReasonSchema: GenEnum<MCPExclusionReason>;+export declare const MCPDenialReasonSchema: GenEnum<MCPDenialReason>;/*** Whether the method allows access without authentication credentials.@@ -320,22 +311,19 @@ export declare const audit: GenExtension<MethodOptions, boolean>;export declare const mcp_method_class: GenExtension<MethodOptions, MCPMethodClass>;/**- * Why the method is forbidden to MCP sessions. Meaningful only alongside- * mcp_method_class = FORBIDDEN; the denial names it so the agent, and the- * operator reading the audit row, learn why rather than just that it was- * refused.+ * Why an MCP session may not call the method. Meaningful only alongside+ * mcp_method_class = FORBIDDEN or EXCLUDED, and required on both: the denial+ * names it so the agent, and the operator reading the audit row, learn why+ * rather than just that it was refused, and an exclusion whose reason nobody+ * wrote down is one nobody can revisit.*- * @generated from extension: bytebase.v1.MCPForbiddenReason mcp_forbidden_reason = 100005;- */-export declare const mcp_forbidden_reason: GenExtension<MethodOptions, MCPForbiddenReason>;--/**- * Why the method is served by no MCP mode. Meaningful only alongside- * mcp_method_class = EXCLUDED, and required there: an exclusion whose reason- * nobody wrote down is one nobody can revisit, and these are the rows a- * later admin-capable ceiling has to re-decide one at a time.+ * 100006 was mcp_exclusion_reason, folded into mcp_denial_reason above. Do+ * not reuse the number: an extend block cannot carry a `reserved` statement,+ * so this comment is the only marker, and a binary built before the merge+ * reads 100006 as the old enum — giving that number a new meaning would let+ * it read a confident wrong answer instead of nothing.*- * @generated from extension: bytebase.v1.MCPExclusionReason mcp_exclusion_reason = 100006;+ * @generated from extension: bytebase.v1.MCPDenialReason mcp_denial_reason = 100005;*/-export declare const mcp_exclusion_reason: GenExtension<MethodOptions, MCPExclusionReason>;+export declare const mcp_denial_reason: GenExtension<MethodOptions, MCPDenialReason>;diff --git a/frontend/src/types/proto-es/v1/annotation_pb.js b/frontend/src/types/proto-es/v1/annotation_pb.jsindex a78a95251f..6737e8e61d 100644--- a/frontend/src/types/proto-es/v1/annotation_pb.js+++ b/frontend/src/types/proto-es/v1/annotation_pb.js@@ -9,7 +9,7 @@ import { file_google_protobuf_descriptor } from "@bufbuild/protobuf/wkt";* Describes the file v1/annotation.proto.*/export const file_v1_annotation = /*@__PURE__*/- fileDesc("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", [file_google_protobuf_descriptor]);+ fileDesc("ChN2MS9hbm5vdGF0aW9uLnByb3RvEgtieXRlYmFzZS52MSo+CgpBdXRoTWV0aG9kEhsKF0FVVEhfTUVUSE9EX1VOU1BFQ0lGSUVEEAASBwoDSUFNEAESCgoGQ1VTVE9NEAIqZAoOTUNQTWV0aG9kQ2xhc3MSIAocTUNQX01FVEhPRF9DTEFTU19VTlNQRUNJRklFRBAAEggKBFJFQUQQARIJCgVXUklURRACEg0KCUZPUkJJRERFThADEgwKCEVYQ0xVREVEEAQqmQMKD01DUERlbmlhbFJlYXNvbhIhCh1NQ1BfREVOSUFMX1JFQVNPTl9VTlNQRUNJRklFRBAAEhQKEE1JTlRTX0NSRURFTlRJQUwQARIVChFSRVNFVFNfQ1JFREVOVElBTBACEhYKElRBS0VTX09WRVJfQUNDT1VOVBADEhAKDEVORFNfU0VTU0lPThAEEhMKD0VORFNfTUVNQkVSU0hJUBAFEh8KG01JTlRTX0NSRURFTlRJQUxfRk9SX09USEVSUxAGEh0KGVJFV1JJVEVTX1NFU1NJT05fQk9VTkRBUlkQBxIgChxEUklWRVNfVEhFX0FQUFJPVkFMX0RFQ0lTSU9OEAgSHQoZQURNSU5JU1RFUlNfVEhFX1dPUktTUEFDRRAJEhkKFVJFQURTX09USEVSX1VTRVJTX1NRTBAKEh0KGU9QRU5TX0FOX0FETUlOX0NPTk5FQ1RJT04QCxIfChtTRU5EU19EQVRBX1RPX0FfVEhJUkRfUEFSVFkQDBIbChdSRVRVUk5TX0FfU1RPUkVEX1NFQ1JFVBANOloKGGFsbG93X3dpdGhvdXRfY3JlZGVudGlhbBIeLmdvb2dsZS5wcm90b2J1Zi5NZXRob2RPcHRpb25zGKCNBiABKAhSFmFsbG93V2l0aG91dENyZWRlbnRpYWw6QAoKcGVybWlzc2lvbhIeLmdvb2dsZS5wcm90b2J1Zi5NZXRob2RPcHRpb25zGKGNBiABKAlSCnBlcm1pc3Npb246WgoLYXV0aF9tZXRob2QSHi5nb29nbGUucHJvdG9idWYuTWV0aG9kT3B0aW9ucxiijQYgASgOMhcuYnl0ZWJhc2UudjEuQXV0aE1ldGhvZFIKYXV0aE1ldGhvZDo2CgVhdWRpdBIeLmdvb2dsZS5wcm90b2J1Zi5NZXRob2RPcHRpb25zGKONBiABKAhSBWF1ZGl0OmcKEG1jcF9tZXRob2RfY2xhc3MSHi5nb29nbGUucHJvdG9idWYuTWV0aG9kT3B0aW9ucxikjQYgASgOMhsuYnl0ZWJhc2UudjEuTUNQTWV0aG9kQ2xhc3NSDm1jcE1ldGhvZENsYXNzOmoKEW1jcF9kZW5pYWxfcmVhc29uEh4uZ29vZ2xlLnByb3RvYnVmLk1ldGhvZE9wdGlvbnMYpY0GIAEoDjIcLmJ5dGViYXNlLnYxLk1DUERlbmlhbFJlYXNvblIPbWNwRGVuaWFsUmVhc29uQqUBCg9jb20uYnl0ZWJhc2UudjFCD0Fubm90YXRpb25Qcm90b1ABWjRnaXRodWIuY29tL2J5dGViYXNlL2J5dGViYXNlL2JhY2tlbmQvZ2VuZXJhdGVkLWdvL3YxogIDQlhYqgILQnl0ZWJhc2UuVjHKAgtCeXRlYmFzZVxWMeICF0J5dGViYXNlXFYxXEdQQk1ldGFkYXRh6gIMQnl0ZWJhc2U6OlYxYgZwcm90bzM", [file_google_protobuf_descriptor]);/*** Describes the enum bytebase.v1.AuthMethod.@@ -36,12 +36,11 @@ export const MCPMethodClassSchema = /*@__PURE__*/* authorization of an MCP session is this classification intersected with the* caller's own RBAC: it can only ever narrow what the human could do, never* widen it.- * Only FORBIDDEN is enforced today. READ, WRITE and EXCLUDED are recorded- * classifications and nothing reads them at request time yet — the gate that- * selects between them is a later change. A method annotated READ or WRITE is- * therefore served exactly as it is today; the annotation states where it- * belongs, not where the boundary currently sits. FORBIDDEN is the exception- * and is enforced the moment it is annotated.+ * Every value is enforced, at the gate on the internal MCP chain. READ and+ * WRITE are the serving classes the workspace's MCP capability ceiling selects+ * between, EXCLUDED and FORBIDDEN are served by no ceiling, and an unclassified+ * method is refused rather than served. Annotating a method is therefore a+ * change to what an MCP session can reach, taking effect on the next request.** @generated from enum bytebase.v1.MCPMethodClass*/@@ -49,40 +48,34 @@ export const MCPMethodClass = /*@__PURE__*/tsEnum(MCPMethodClassSchema);/**- * Describes the enum bytebase.v1.MCPForbiddenReason.+ * Describes the enum bytebase.v1.MCPDenialReason.*/-export const MCPForbiddenReasonSchema = /*@__PURE__*/+export const MCPDenialReasonSchema = /*@__PURE__*/enumDesc(file_v1_annotation, 2);/**- * Why an RPC is FORBIDDEN to MCP sessions. The mechanism, not the wording:- * each value names what its methods actually do, and the serving side turns- * that into a sentence. A denial whose stated reason has drifted from the- * mechanism is worse than a bare refusal, because it is the thing the next- * reader trusts — so a method changing what it does changes its reason here.+ * Why an MCP session may not call an RPC. The mechanism, not the wording: each+ * value names what its methods actually do, and the serving side turns that+ * into a sentence. A denial whose stated reason has drifted from the mechanism+ * is worse than a bare refusal, because it is the thing the next reader trusts+ * — so a method changing what it does changes its reason here.*- * @generated from enum bytebase.v1.MCPForbiddenReason- */-export const MCPForbiddenReason = /*@__PURE__*/- tsEnum(MCPForbiddenReasonSchema);--/**- * Describes the enum bytebase.v1.MCPExclusionReason.- */-export const MCPExclusionReasonSchema = /*@__PURE__*/- enumDesc(file_v1_annotation, 3);--/**- * Why an RPC is served by no MCP mode. Unlike MCPForbiddenReason, which names- * a mechanism that breaks the MCP boundary, these name a scope decision: the- * method is out because this phase ships two modes and neither is the right- * home for it. Each value is what a future admin-capable ceiling would have to- * argue with, one population at a time.+ * One enum covers both refused classes, and every value belongs to exactly one+ * of them: values 1-8 name a mechanism that breaks the MCP boundary, which is+ * what FORBIDDEN means, and values 9-13 name a scope decision this phase took,+ * which is what EXCLUDED means. The distinction is real and lives on the class+ * annotation — a FORBIDDEN mechanism is a durable never, an EXCLUDED scope+ * decision is what a future admin-capable ceiling would argue with, one+ * population at a time. Splitting it across two enums as well only made the+ * nonsense states representable: a method could carry both, or carry the kind+ * that contradicts its class. Neither is expressible now, and the one check+ * left — the reason belongs to the class it is used on — is a table the gate+ * already keeps for the wording.*- * @generated from enum bytebase.v1.MCPExclusionReason+ * @generated from enum bytebase.v1.MCPDenialReason*/-export const MCPExclusionReason = /*@__PURE__*/- tsEnum(MCPExclusionReasonSchema);+export const MCPDenialReason = /*@__PURE__*/+ tsEnum(MCPDenialReasonSchema);/*** Whether the method allows access without authentication credentials.@@ -125,24 +118,20 @@ export const mcp_method_class = /*@__PURE__*/extDesc(file_v1_annotation, 4);/**- * Why the method is forbidden to MCP sessions. Meaningful only alongside- * mcp_method_class = FORBIDDEN; the denial names it so the agent, and the- * operator reading the audit row, learn why rather than just that it was- * refused.+ * Why an MCP session may not call the method. Meaningful only alongside+ * mcp_method_class = FORBIDDEN or EXCLUDED, and required on both: the denial+ * names it so the agent, and the operator reading the audit row, learn why+ * rather than just that it was refused, and an exclusion whose reason nobody+ * wrote down is one nobody can revisit.*- * @generated from extension: bytebase.v1.MCPForbiddenReason mcp_forbidden_reason = 100005;- */-export const mcp_forbidden_reason = /*@__PURE__*/- extDesc(file_v1_annotation, 5);--/**- * Why the method is served by no MCP mode. Meaningful only alongside- * mcp_method_class = EXCLUDED, and required there: an exclusion whose reason- * nobody wrote down is one nobody can revisit, and these are the rows a- * later admin-capable ceiling has to re-decide one at a time.+ * 100006 was mcp_exclusion_reason, folded into mcp_denial_reason above. Do+ * not reuse the number: an extend block cannot carry a `reserved` statement,+ * so this comment is the only marker, and a binary built before the merge+ * reads 100006 as the old enum — giving that number a new meaning would let+ * it read a confident wrong answer instead of nothing.*- * @generated from extension: bytebase.v1.MCPExclusionReason mcp_exclusion_reason = 100006;+ * @generated from extension: bytebase.v1.MCPDenialReason mcp_denial_reason = 100005;*/-export const mcp_exclusion_reason = /*@__PURE__*/- extDesc(file_v1_annotation, 6);+export const mcp_denial_reason = /*@__PURE__*/+ extDesc(file_v1_annotation, 5);diff --git a/frontend/src/types/proto-es/v1/audit_log_service_pb.js b/frontend/src/types/proto-es/v1/audit_log_service_pb.jsindex 8df3c740b2..1a996331fa 100644--- a/frontend/src/types/proto-es/v1/audit_log_service_pb.js+++ b/frontend/src/types/proto-es/v1/audit_log_service_pb.js@@ -16,7 +16,7 @@ import { file_v1_iam_policy } from "./iam_policy_pb";* Describes the file v1/audit_log_service.proto.*/export const file_v1_audit_log_service = /*@__PURE__*/- fileDesc("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", [file_google_api_annotations, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_any, file_google_protobuf_duration, file_google_protobuf_timestamp, file_google_rpc_status, file_v1_annotation, file_v1_common, file_v1_iam_policy]);+ fileDesc("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", [file_google_api_annotations, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_any, file_google_protobuf_duration, file_google_protobuf_timestamp, file_google_rpc_status, file_v1_annotation, file_v1_common, file_v1_iam_policy]);/*** Describes the message bytebase.v1.SearchAuditLogsRequest.diff --git a/frontend/src/types/proto-es/v1/database_catalog_service_pb.js b/frontend/src/types/proto-es/v1/database_catalog_service_pb.jsindex 7e84b74908..ff656c7091 100644--- a/frontend/src/types/proto-es/v1/database_catalog_service_pb.js+++ b/frontend/src/types/proto-es/v1/database_catalog_service_pb.js@@ -13,7 +13,7 @@ import { file_v1_annotation } from "./annotation_pb";* Describes the file v1/database_catalog_service.proto.*/export const file_v1_database_catalog_service = /*@__PURE__*/- fileDesc("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", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_v1_annotation]);+ fileDesc("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", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_v1_annotation]);/*** Describes the message bytebase.v1.GetDatabaseCatalogRequest.diff --git a/frontend/src/types/proto-es/v1/group_service_pb.js b/frontend/src/types/proto-es/v1/group_service_pb.jsindex 7f4ac4c98c..50fa4e30d4 100644--- a/frontend/src/types/proto-es/v1/group_service_pb.js+++ b/frontend/src/types/proto-es/v1/group_service_pb.js@@ -15,7 +15,7 @@ import { file_v1_annotation } from "./annotation_pb";* Describes the file v1/group_service.proto.*/export const file_v1_group_service = /*@__PURE__*/- fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_v1_annotation]);+ fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_v1_annotation]);/*** Describes the message bytebase.v1.GetGroupRequest.diff --git a/frontend/src/types/proto-es/v1/idp_service_pb.js b/frontend/src/types/proto-es/v1/idp_service_pb.jsindex faaf872f11..1b3850e0c6 100644--- a/frontend/src/types/proto-es/v1/idp_service_pb.js+++ b/frontend/src/types/proto-es/v1/idp_service_pb.js@@ -15,7 +15,7 @@ import { file_v1_annotation } from "./annotation_pb";* Describes the file v1/idp_service.proto.*/export const file_v1_idp_service = /*@__PURE__*/- fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_v1_annotation]);+ fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_v1_annotation]);/*** Describes the message bytebase.v1.GetIdentityProviderRequest.diff --git a/frontend/src/types/proto-es/v1/instance_role_service_pb.js b/frontend/src/types/proto-es/v1/instance_role_service_pb.jsindex b8dc0a6fc7..40be31b418 100644--- a/frontend/src/types/proto-es/v1/instance_role_service_pb.js+++ b/frontend/src/types/proto-es/v1/instance_role_service_pb.js@@ -13,7 +13,7 @@ import { file_v1_annotation } from "./annotation_pb";* Describes the file v1/instance_role_service.proto.*/export const file_v1_instance_role_service = /*@__PURE__*/- fileDesc("Ch52MS9pbnN0YW5jZV9yb2xlX3NlcnZpY2UucHJvdG8SC2J5dGViYXNlLnYxIoEBChhMaXN0SW5zdGFuY2VSb2xlc1JlcXVlc3QSLQoGcGFyZW50GAEgASgJQh3gQQL6QRcKFWJ5dGViYXNlLmNvbS9JbnN0YW5jZRIRCglwYWdlX3NpemUYAiABKAUSEgoKcGFnZV90b2tlbhgDIAEoCRIPCgdyZWZyZXNoGAQgASgIIl4KGUxpc3RJbnN0YW5jZVJvbGVzUmVzcG9uc2USKAoFcm9sZXMYASADKAsyGS5ieXRlYmFzZS52MS5JbnN0YW5jZVJvbGUSFwoPbmV4dF9wYWdlX3Rva2VuGAIgASgJItUCCgxJbnN0YW5jZVJvbGUSDAoEbmFtZRgBIAEoCRIRCglyb2xlX25hbWUYAiABKAkSGgoIcGFzc3dvcmQYAyABKAlCA+BBBEgAiAEBEh0KEGNvbm5lY3Rpb25fbGltaXQYBCABKAVIAYgBARIYCgt2YWxpZF91bnRpbBgFIAEoCUgCiAEBEhYKCWF0dHJpYnV0ZRgGIAEoCUgDiAEBOnfqQXQKGWJ5dGViYXNlLmNvbS9JbnN0YW5jZVJvbGUSIWluc3RhbmNlcy97aW5zdGFuY2V9L3JvbGVzL3tyb2xlfRI0cHJvamVjdHMve3Byb2plY3R9L2luc3RhbmNlcy97aW5zdGFuY2V9L3JvbGVzL3tyb2xlfUILCglfcGFzc3dvcmRCEwoRX2Nvbm5lY3Rpb25fbGltaXRCDgoMX3ZhbGlkX3VudGlsQgwKCl9hdHRyaWJ1dGUy/gEKE0luc3RhbmNlUm9sZVNlcnZpY2US5gEKEUxpc3RJbnN0YW5jZVJvbGVzEiUuYnl0ZWJhc2UudjEuTGlzdEluc3RhbmNlUm9sZXNSZXF1ZXN0GiYuYnl0ZWJhc2UudjEuTGlzdEluc3RhbmNlUm9sZXNSZXNwb25zZSKBAdpBBnBhcmVudIrqMBViYi5pbnN0YW5jZVJvbGVzLmxpc3SQ6jABoOowBLDqMAWC0+STAk1aKxIpL3YxL3twYXJlbnQ9cHJvamVjdHMvKi9pbnN0YW5jZXMvKn0vcm9sZXMSHi92MS97cGFyZW50PWluc3RhbmNlcy8qfS9yb2xlc0KuAQoPY29tLmJ5dGViYXNlLnYxQhhJbnN0YW5jZVJvbGVTZXJ2aWNlUHJvdG9QAVo0Z2l0aHViLmNvbS9ieXRlYmFzZS9ieXRlYmFzZS9iYWNrZW5kL2dlbmVyYXRlZC1nby92MaICA0JYWKoCC0J5dGViYXNlLlYxygILQnl0ZWJhc2VcVjHiAhdCeXRlYmFzZVxWMVxHUEJNZXRhZGF0YeoCDEJ5dGViYXNlOjpWMWIGcHJvdG8z", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_v1_annotation]);+ fileDesc("Ch52MS9pbnN0YW5jZV9yb2xlX3NlcnZpY2UucHJvdG8SC2J5dGViYXNlLnYxIoEBChhMaXN0SW5zdGFuY2VSb2xlc1JlcXVlc3QSLQoGcGFyZW50GAEgASgJQh3gQQL6QRcKFWJ5dGViYXNlLmNvbS9JbnN0YW5jZRIRCglwYWdlX3NpemUYAiABKAUSEgoKcGFnZV90b2tlbhgDIAEoCRIPCgdyZWZyZXNoGAQgASgIIl4KGUxpc3RJbnN0YW5jZVJvbGVzUmVzcG9uc2USKAoFcm9sZXMYASADKAsyGS5ieXRlYmFzZS52MS5JbnN0YW5jZVJvbGUSFwoPbmV4dF9wYWdlX3Rva2VuGAIgASgJItUCCgxJbnN0YW5jZVJvbGUSDAoEbmFtZRgBIAEoCRIRCglyb2xlX25hbWUYAiABKAkSGgoIcGFzc3dvcmQYAyABKAlCA+BBBEgAiAEBEh0KEGNvbm5lY3Rpb25fbGltaXQYBCABKAVIAYgBARIYCgt2YWxpZF91bnRpbBgFIAEoCUgCiAEBEhYKCWF0dHJpYnV0ZRgGIAEoCUgDiAEBOnfqQXQKGWJ5dGViYXNlLmNvbS9JbnN0YW5jZVJvbGUSIWluc3RhbmNlcy97aW5zdGFuY2V9L3JvbGVzL3tyb2xlfRI0cHJvamVjdHMve3Byb2plY3R9L2luc3RhbmNlcy97aW5zdGFuY2V9L3JvbGVzL3tyb2xlfUILCglfcGFzc3dvcmRCEwoRX2Nvbm5lY3Rpb25fbGltaXRCDgoMX3ZhbGlkX3VudGlsQgwKCl9hdHRyaWJ1dGUy/gEKE0luc3RhbmNlUm9sZVNlcnZpY2US5gEKEUxpc3RJbnN0YW5jZVJvbGVzEiUuYnl0ZWJhc2UudjEuTGlzdEluc3RhbmNlUm9sZXNSZXF1ZXN0GiYuYnl0ZWJhc2UudjEuTGlzdEluc3RhbmNlUm9sZXNSZXNwb25zZSKBAdpBBnBhcmVudIrqMBViYi5pbnN0YW5jZVJvbGVzLmxpc3SQ6jABoOowBKjqMA2C0+STAk1aKxIpL3YxL3twYXJlbnQ9cHJvamVjdHMvKi9pbnN0YW5jZXMvKn0vcm9sZXMSHi92MS97cGFyZW50PWluc3RhbmNlcy8qfS9yb2xlc0KuAQoPY29tLmJ5dGViYXNlLnYxQhhJbnN0YW5jZVJvbGVTZXJ2aWNlUHJvdG9QAVo0Z2l0aHViLmNvbS9ieXRlYmFzZS9ieXRlYmFzZS9iYWNrZW5kL2dlbmVyYXRlZC1nby92MaICA0JYWKoCC0J5dGViYXNlLlYxygILQnl0ZWJhc2VcVjHiAhdCeXRlYmFzZVxWMVxHUEJNZXRhZGF0YeoCDEJ5dGViYXNlOjpWMWIGcHJvdG8z", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_v1_annotation]);/*** Describes the message bytebase.v1.ListInstanceRolesRequest.diff --git a/frontend/src/types/proto-es/v1/instance_service_pb.js b/frontend/src/types/proto-es/v1/instance_service_pb.jsindex aa81dd1a0f..9024e0066b 100644--- a/frontend/src/types/proto-es/v1/instance_service_pb.js+++ b/frontend/src/types/proto-es/v1/instance_service_pb.js@@ -17,7 +17,7 @@ import { file_v1_instance_role_service } from "./instance_role_service_pb";* Describes the file v1/instance_service.proto.*/export const file_v1_instance_service = /*@__PURE__*/- fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_duration, file_google_protobuf_empty, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common, file_v1_instance_role_service]);+ fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_duration, file_google_protobuf_empty, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common, file_v1_instance_role_service]);/*** Describes the message bytebase.v1.GetInstanceRequest.diff --git a/frontend/src/types/proto-es/v1/org_policy_service_pb.js b/frontend/src/types/proto-es/v1/org_policy_service_pb.jsindex 4f17694b27..d24defa7c9 100644--- a/frontend/src/types/proto-es/v1/org_policy_service_pb.js+++ b/frontend/src/types/proto-es/v1/org_policy_service_pb.js@@ -15,7 +15,7 @@ import { file_v1_annotation } from "./annotation_pb";* Describes the file v1/org_policy_service.proto.*/export const file_v1_org_policy_service = /*@__PURE__*/- fileDesc("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", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_google_type_expr, file_v1_annotation]);+ fileDesc("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", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_google_type_expr, file_v1_annotation]);/*** Describes the message bytebase.v1.CreatePolicyRequest.diff --git a/frontend/src/types/proto-es/v1/project_service_pb.js b/frontend/src/types/proto-es/v1/project_service_pb.jsindex 774121a642..824e2893ef 100644--- a/frontend/src/types/proto-es/v1/project_service_pb.js+++ b/frontend/src/types/proto-es/v1/project_service_pb.js@@ -18,7 +18,7 @@ import { file_v1_iam_policy } from "./iam_policy_pb";* Describes the file v1/project_service.proto.*/export const file_v1_project_service = /*@__PURE__*/- fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_google_type_color, file_v1_annotation, file_v1_common, file_v1_iam_policy]);+ fileDesc("Chh2MS9wcm9qZWN0X3NlcnZpY2UucHJvdG8SC2J5dGViYXNlLnYxIj8KEUdldFByb2plY3RSZXF1ZXN0EioKBG5hbWUYASABKAlCHOBBAvpBFgoUYnl0ZWJhc2UuY29tL1Byb2plY3QiRgoXQmF0Y2hHZXRQcm9qZWN0c1JlcXVlc3QSKwoFbmFtZXMYASADKAlCHOBBAvpBFgoUYnl0ZWJhc2UuY29tL1Byb2plY3QiQgoYQmF0Y2hHZXRQcm9qZWN0c1Jlc3BvbnNlEiYKCHByb2plY3RzGAEgAygLMhQuYnl0ZWJhc2UudjEuUHJvamVjdCJ0ChNMaXN0UHJvamVjdHNSZXF1ZXN0EhEKCXBhZ2Vfc2l6ZRgBIAEoBRISCgpwYWdlX3Rva2VuGAIgASgJEhQKDHNob3dfZGVsZXRlZBgDIAEoCBIOCgZmaWx0ZXIYBCABKAkSEAoIb3JkZXJfYnkYBSABKAkiVwoUTGlzdFByb2plY3RzUmVzcG9uc2USJgoIcHJvamVjdHMYASADKAsyFC5ieXRlYmFzZS52MS5Qcm9qZWN0EhcKD25leHRfcGFnZV90b2tlbhgCIAEoCSJ2ChVTZWFyY2hQcm9qZWN0c1JlcXVlc3QSFAoMc2hvd19kZWxldGVkGAEgASgIEg4KBmZpbHRlchgCIAEoCRIRCglwYWdlX3NpemUYAyABKAUSEgoKcGFnZV90b2tlbhgEIAEoCRIQCghvcmRlcl9ieRgFIAEoCSJZChZTZWFyY2hQcm9qZWN0c1Jlc3BvbnNlEiYKCHByb2plY3RzGAEgAygLMhQuYnl0ZWJhc2UudjEuUHJvamVjdBIXCg9uZXh0X3BhZ2VfdG9rZW4YAiABKAkiVgoUQ3JlYXRlUHJvamVjdFJlcXVlc3QSKgoHcHJvamVjdBgBIAEoCzIULmJ5dGViYXNlLnYxLlByb2plY3RCA+BBAhISCgpwcm9qZWN0X2lkGAIgASgJIooBChRVcGRhdGVQcm9qZWN0UmVxdWVzdBIqCgdwcm9qZWN0GAEgASgLMhQuYnl0ZWJhc2UudjEuUHJvamVjdEID4EECEi8KC3VwZGF0ZV9tYXNrGAIgASgLMhouZ29vZ2xlLnByb3RvYnVmLkZpZWxkTWFzaxIVCg1hbGxvd19taXNzaW5nGAMgASgIIlEKFERlbGV0ZVByb2plY3RSZXF1ZXN0EioKBG5hbWUYASABKAlCHOBBAvpBFgoUYnl0ZWJhc2UuY29tL1Byb2plY3QSDQoFcHVyZ2UYAiABKAgiRAoWVW5kZWxldGVQcm9qZWN0UmVxdWVzdBIqCgRuYW1lGAEgASgJQhzgQQL6QRYKFGJ5dGViYXNlLmNvbS9Qcm9qZWN0IlgKGkJhdGNoRGVsZXRlUHJvamVjdHNSZXF1ZXN0EisKBW5hbWVzGAEgAygJQhzgQQL6QRYKFGJ5dGViYXNlLmNvbS9Qcm9qZWN0Eg0KBXB1cmdlGAIgASgIIkgKBUxhYmVsEg0KBXZhbHVlGAEgASgJEiEKBWNvbG9yGAIgASgLMhIuZ29vZ2xlLnR5cGUuQ29sb3ISDQoFZ3JvdXAYAyABKAkivwYKB1Byb2plY3QSDAoEbmFtZRgBIAEoCRIhCgVzdGF0ZRgCIAEoDjISLmJ5dGViYXNlLnYxLlN0YXRlEhcKBXRpdGxlGAMgASgJQgi6SAVyAxjIARImCgh3ZWJob29rcxgEIAMoCzIULmJ5dGViYXNlLnYxLldlYmhvb2sSJQodZGF0YV9jbGFzc2lmaWNhdGlvbl9jb25maWdfaWQYBSABKAkSKAoMaXNzdWVfbGFiZWxzGAYgAygLMhIuYnl0ZWJhc2UudjEuTGFiZWwSGgoSZm9yY2VfaXNzdWVfbGFiZWxzGAcgASgIEhsKE2VuZm9yY2VfaXNzdWVfdGl0bGUYCiABKAgSJQodcG9zdGdyZXNfZGF0YWJhc2VfdGVuYW50X21vZGUYDSABKAgSGwoTYWxsb3dfc2VsZl9hcHByb3ZhbBgOIAEoCBJJChZleGVjdXRpb25fcmV0cnlfcG9saWN5GA8gASgLMikuYnl0ZWJhc2UudjEuUHJvamVjdC5FeGVjdXRpb25SZXRyeVBvbGljeRIYChBjaV9zYW1wbGluZ19zaXplGBAgASgFEiIKGnBhcmFsbGVsX3Rhc2tzX3Blcl9yb2xsb3V0GBEgASgFEjAKBmxhYmVscxgSIAMoCzIgLmJ5dGViYXNlLnYxLlByb2plY3QuTGFiZWxzRW50cnkSGgoSZW5mb3JjZV9zcWxfcmV2aWV3GBMgASgIEh4KFnJlcXVpcmVfaXNzdWVfYXBwcm92YWwYFCABKAgSIwobcmVxdWlyZV9wbGFuX2NoZWNrX25vX2Vycm9yGBUgASgIEhoKEmFsbG93X3JlcXVlc3Rfcm9sZRgWIAEoCBIhChlhbGxvd19qdXN0X2luX3RpbWVfYWNjZXNzGBcgASgIGi8KFEV4ZWN1dGlvblJldHJ5UG9saWN5EhcKD21heGltdW1fcmV0cmllcxgBIAEoBRotCgtMYWJlbHNFbnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAk6AjgBOi3qQSoKFGJ5dGViYXNlLmNvbS9Qcm9qZWN0EhJwcm9qZWN0cy97cHJvamVjdH1KBAgIEApKBAgLEA0ibgoRQWRkV2ViaG9va1JlcXVlc3QSLQoHcHJvamVjdBgBIAEoCUIc4EEC+kEWChRieXRlYmFzZS5jb20vUHJvamVjdBIqCgd3ZWJob29rGAIgASgLMhQuYnl0ZWJhc2UudjEuV2ViaG9va0ID4EECIooBChRVcGRhdGVXZWJob29rUmVxdWVzdBIqCgd3ZWJob29rGAEgASgLMhQuYnl0ZWJhc2UudjEuV2ViaG9va0ID4EECEi8KC3VwZGF0ZV9tYXNrGAIgASgLMhouZ29vZ2xlLnByb3RvYnVmLkZpZWxkTWFzaxIVCg1hbGxvd19taXNzaW5nGAMgASgIIkIKFFJlbW92ZVdlYmhvb2tSZXF1ZXN0EioKB3dlYmhvb2sYASABKAsyFC5ieXRlYmFzZS52MS5XZWJob29rQgPgQQIibwoSVGVzdFdlYmhvb2tSZXF1ZXN0Ei0KB3Byb2plY3QYASABKAlCHOBBAvpBFgoUYnl0ZWJhc2UuY29tL1Byb2plY3QSKgoHd2ViaG9vaxgCIAEoCzIULmJ5dGViYXNlLnYxLldlYmhvb2tCA+BBAiIkChNUZXN0V2ViaG9va1Jlc3BvbnNlEg0KBWVycm9yGAEgASgJIoECCgdXZWJob29rEgwKBG5hbWUYASABKAkSKwoEdHlwZRgCIAEoDjIYLmJ5dGViYXNlLnYxLldlYmhvb2tUeXBlQgPgQQISEgoFdGl0bGUYAyABKAlCA+BBAhIQCgN1cmwYBCABKAlCA+BBAhIWCg5kaXJlY3RfbWVzc2FnZRgGIAEoCBI7ChJub3RpZmljYXRpb25fdHlwZXMYBSADKA4yGi5ieXRlYmFzZS52MS5BY3Rpdml0eS5UeXBlQgPgQQY6QOpBPQoUYnl0ZWJhc2UuY29tL1dlYmhvb2sSJXByb2plY3RzL3twcm9qZWN0fS93ZWJob29rcy97d2ViaG9va30itgEKCEFjdGl2aXR5IqkBCgRUeXBlEhQKEFRZUEVfVU5TUEVDSUZJRUQQABIRCg1JU1NVRV9DUkVBVEVEEAoSHAoYSVNTVUVfQVBQUk9WQUxfUkVRVUVTVEVEEAsSEwoPSVNTVUVfU0VOVF9CQUNLEAwSEwoPUElQRUxJTkVfRkFJTEVEEA0SFgoSUElQRUxJTkVfQ09NUExFVEVEEA4SEgoOSVNTVUVfQVBQUk9WRUQQDyIECAEQCTKQEwoOUHJvamVjdFNlcnZpY2UShwEKCkdldFByb2plY3QSHi5ieXRlYmFzZS52MS5HZXRQcm9qZWN0UmVxdWVzdBoULmJ5dGViYXNlLnYxLlByb2plY3QiQ9pBBG5hbWWK6jAPYmIucHJvamVjdHMuZ2V0kOowAaDqMASo6jANgtPkkwIXEhUvdjEve25hbWU9cHJvamVjdHMvKn0SnQEKEEJhdGNoR2V0UHJvamVjdHMSJC5ieXRlYmFzZS52MS5CYXRjaEdldFByb2plY3RzUmVxdWVzdBolLmJ5dGViYXNlLnYxLkJhdGNoR2V0UHJvamVjdHNSZXNwb25zZSI8iuowD2JiLnByb2plY3RzLmdldJDqMAGg6jAEqOowDYLT5JMCFxIVL3YxL3Byb2plY3RzOmJhdGNoR2V0EowBCgxMaXN0UHJvamVjdHMSIC5ieXRlYmFzZS52MS5MaXN0UHJvamVjdHNSZXF1ZXN0GiEuYnl0ZWJhc2UudjEuTGlzdFByb2plY3RzUmVzcG9uc2UiN9pBAIrqMBBiYi5wcm9qZWN0cy5saXN0kOowAaDqMASo6jANgtPkkwIOEgwvdjEvcHJvamVjdHMSiAEKDlNlYXJjaFByb2plY3RzEiIuYnl0ZWJhc2UudjEuU2VhcmNoUHJvamVjdHNSZXF1ZXN0GiMuYnl0ZWJhc2UudjEuU2VhcmNoUHJvamVjdHNSZXNwb25zZSIt2kEAkOowAqDqMASo6jANgtPkkwIYOgEqIhMvdjEvcHJvamVjdHM6c2VhcmNoEpABCg1DcmVhdGVQcm9qZWN0EiEuYnl0ZWJhc2UudjEuQ3JlYXRlUHJvamVjdFJlcXVlc3QaFC5ieXRlYmFzZS52MS5Qcm9qZWN0IkbaQQCK6jASYmIucHJvamVjdHMuY3JlYXRlkOowAZjqMAGg6jAEqOowCYLT5JMCFzoHcHJvamVjdCIML3YxL3Byb2plY3RzErQBCg1VcGRhdGVQcm9qZWN0EiEuYnl0ZWJhc2UudjEuVXBkYXRlUHJvamVjdFJlcXVlc3QaFC5ieXRlYmFzZS52MS5Qcm9qZWN0ImraQRNwcm9qZWN0LHVwZGF0ZV9tYXNriuowEmJiLnByb2plY3RzLnVwZGF0ZZDqMAGY6jABoOowBKjqMAmC0+STAig6B3Byb2plY3QyHS92MS97cHJvamVjdC5uYW1lPXByb2plY3RzLyp9EpYBCg1EZWxldGVQcm9qZWN0EiEuYnl0ZWJhc2UudjEuRGVsZXRlUHJvamVjdFJlcXVlc3QaFi5nb29nbGUucHJvdG9idWYuRW1wdHkiStpBBG5hbWWK6jASYmIucHJvamVjdHMuZGVsZXRlkOowAZjqMAGg6jAEqOowCYLT5JMCFyoVL3YxL3tuYW1lPXByb2plY3RzLyp9Ep8BCg9VbmRlbGV0ZVByb2plY3QSIy5ieXRlYmFzZS52MS5VbmRlbGV0ZVByb2plY3RSZXF1ZXN0GhQuYnl0ZWJhc2UudjEuUHJvamVjdCJRiuowFGJiLnByb2plY3RzLnVuZGVsZXRlkOowAZjqMAGg6jAEqOowCYLT5JMCIzoBKiIeL3YxL3tuYW1lPXByb2plY3RzLyp9OnVuZGVsZXRlEqEBChNCYXRjaERlbGV0ZVByb2plY3RzEicuYnl0ZWJhc2UudjEuQmF0Y2hEZWxldGVQcm9qZWN0c1JlcXVlc3QaFi5nb29nbGUucHJvdG9idWYuRW1wdHkiSYrqMBJiYi5wcm9qZWN0cy5kZWxldGWQ6jABmOowAaDqMASo6jAJgtPkkwIdOgEqIhgvdjEvcHJvamVjdHM6YmF0Y2hEZWxldGUSoAEKDEdldElhbVBvbGljeRIgLmJ5dGViYXNlLnYxLkdldElhbVBvbGljeVJlcXVlc3QaFi5ieXRlYmFzZS52MS5JYW1Qb2xpY3kiVorqMBhiYi5wcm9qZWN0cy5nZXRJYW1Qb2xpY3mQ6jABoOowBKjqMAmC0+STAigSJi92MS97cmVzb3VyY2U9cHJvamVjdHMvKn06Z2V0SWFtUG9saWN5EqcBCgxTZXRJYW1Qb2xpY3kSIC5ieXRlYmFzZS52MS5TZXRJYW1Qb2xpY3lSZXF1ZXN0GhYuYnl0ZWJhc2UudjEuSWFtUG9saWN5Il2K6jAYYmIucHJvamVjdHMuc2V0SWFtUG9saWN5kOowAZjqMAGg6jAEqOowCYLT5JMCKzoBKiImL3YxL3tyZXNvdXJjZT1wcm9qZWN0cy8qfTpzZXRJYW1Qb2xpY3kSmAEKCkFkZFdlYmhvb2sSHi5ieXRlYmFzZS52MS5BZGRXZWJob29rUmVxdWVzdBoULmJ5dGViYXNlLnYxLlByb2plY3QiVIrqMBJiYi5wcm9qZWN0cy51cGRhdGWQ6jABmOowAaDqMASo6jAJgtPkkwIoOgEqIiMvdjEve3Byb2plY3Q9cHJvamVjdHMvKn06YWRkV2ViaG9vaxLOAQoNVXBkYXRlV2ViaG9vaxIhLmJ5dGViYXNlLnYxLlVwZGF0ZVdlYmhvb2tSZXF1ZXN0GhQuYnl0ZWJhc2UudjEuUHJvamVjdCKDAdpBE3dlYmhvb2ssdXBkYXRlX21hc2uK6jASYmIucHJvamVjdHMudXBkYXRlkOowAZjqMAGg6jAEqOowCYLT5JMCQToHd2ViaG9vazI2L3YxL3t3ZWJob29rLm5hbWU9cHJvamVjdHMvKi93ZWJob29rcy8qfTp1cGRhdGVXZWJob29rErEBCg1SZW1vdmVXZWJob29rEiEuYnl0ZWJhc2UudjEuUmVtb3ZlV2ViaG9va1JlcXVlc3QaFC5ieXRlYmFzZS52MS5Qcm9qZWN0ImeK6jASYmIucHJvamVjdHMudXBkYXRlkOowAZjqMAGg6jAEqOowCYLT5JMCOzoBKiI2L3YxL3t3ZWJob29rLm5hbWU9cHJvamVjdHMvKi93ZWJob29rcy8qfTpyZW1vdmVXZWJob29rEqMBCgtUZXN0V2ViaG9vaxIfLmJ5dGViYXNlLnYxLlRlc3RXZWJob29rUmVxdWVzdBogLmJ5dGViYXNlLnYxLlRlc3RXZWJob29rUmVzcG9uc2UiUYrqMBJiYi5wcm9qZWN0cy51cGRhdGWQ6jABoOowBKjqMAyC0+STAik6ASoiJC92MS97cHJvamVjdD1wcm9qZWN0cy8qfTp0ZXN0V2ViaG9va0KpAQoPY29tLmJ5dGViYXNlLnYxQhNQcm9qZWN0U2VydmljZVByb3RvUAFaNGdpdGh1Yi5jb20vYnl0ZWJhc2UvYnl0ZWJhc2UvYmFja2VuZC9nZW5lcmF0ZWQtZ28vdjGiAgNCWFiqAgtCeXRlYmFzZS5WMcoCC0J5dGViYXNlXFYx4gIXQnl0ZWJhc2VcVjFcR1BCTWV0YWRhdGHqAgxCeXRlYmFzZTo6VjFiBnByb3RvMw", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_google_type_color, file_v1_annotation, file_v1_common, file_v1_iam_policy]);/*** Describes the message bytebase.v1.GetProjectRequest.diff --git a/frontend/src/types/proto-es/v1/query_history_service_pb.js b/frontend/src/types/proto-es/v1/query_history_service_pb.jsindex 2597ebd412..97463be588 100644--- a/frontend/src/types/proto-es/v1/query_history_service_pb.js+++ b/frontend/src/types/proto-es/v1/query_history_service_pb.js@@ -14,7 +14,7 @@ import { file_v1_annotation } from "./annotation_pb";* Describes the file v1/query_history_service.proto.*/export const file_v1_query_history_service = /*@__PURE__*/- fileDesc("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", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_duration, file_google_protobuf_timestamp, file_v1_annotation]);+ fileDesc("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", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_duration, file_google_protobuf_timestamp, file_v1_annotation]);/*** Describes the message bytebase.v1.SearchQueryHistoriesRequest.diff --git a/frontend/src/types/proto-es/v1/review_config_service_pb.js b/frontend/src/types/proto-es/v1/review_config_service_pb.jsindex 4c8b33f23e..0a1bf3f114 100644--- a/frontend/src/types/proto-es/v1/review_config_service_pb.js+++ b/frontend/src/types/proto-es/v1/review_config_service_pb.js@@ -16,7 +16,7 @@ import { file_v1_common } from "./common_pb";* Describes the file v1/review_config_service.proto.*/export const file_v1_review_config_service = /*@__PURE__*/- fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_v1_annotation, file_v1_common]);+ fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_v1_annotation, file_v1_common]);/*** Describes the message bytebase.v1.ListReviewConfigsRequest.diff --git a/frontend/src/types/proto-es/v1/role_service_pb.js b/frontend/src/types/proto-es/v1/role_service_pb.jsindex 8bd072cae2..fa27da76c9 100644--- a/frontend/src/types/proto-es/v1/role_service_pb.js+++ b/frontend/src/types/proto-es/v1/role_service_pb.js@@ -15,7 +15,7 @@ import { file_v1_annotation } from "./annotation_pb";* Describes the file v1/role_service.proto.*/export const file_v1_role_service = /*@__PURE__*/- fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_v1_annotation]);+ fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_v1_annotation]);/*** Describes the message bytebase.v1.ListRolesRequest.diff --git a/frontend/src/types/proto-es/v1/rollout_service_pb.js b/frontend/src/types/proto-es/v1/rollout_service_pb.jsindex c17a672d66..559737736e 100644--- a/frontend/src/types/proto-es/v1/rollout_service_pb.js+++ b/frontend/src/types/proto-es/v1/rollout_service_pb.js@@ -16,7 +16,7 @@ import { file_v1_common } from "./common_pb";* Describes the file v1/rollout_service.proto.*/export const file_v1_rollout_service = /*@__PURE__*/- fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common]);+ fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common]);/*** Describes the message bytebase.v1.BatchRunTasksRequest.diff --git a/frontend/src/types/proto-es/v1/saved_query_service_pb.js b/frontend/src/types/proto-es/v1/saved_query_service_pb.jsindex 7f5184cfc7..e1e30e7ed2 100644--- a/frontend/src/types/proto-es/v1/saved_query_service_pb.js+++ b/frontend/src/types/proto-es/v1/saved_query_service_pb.js@@ -15,7 +15,7 @@ import { file_v1_annotation } from "./annotation_pb";* Describes the file v1/saved_query_service.proto.*/export const file_v1_saved_query_service = /*@__PURE__*/- fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_v1_annotation]);+ fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_v1_annotation]);/*** Describes the message bytebase.v1.CreateSavedQueryRequest.diff --git a/frontend/src/types/proto-es/v1/service_account_service_pb.js b/frontend/src/types/proto-es/v1/service_account_service_pb.jsindex b3e3631bde..2d1ca15adf 100644--- a/frontend/src/types/proto-es/v1/service_account_service_pb.js+++ b/frontend/src/types/proto-es/v1/service_account_service_pb.js@@ -16,7 +16,7 @@ import { file_v1_common } from "./common_pb";* Describes the file v1/service_account_service.proto.*/export const file_v1_service_account_service = /*@__PURE__*/- fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common]);+ fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common]);/*** Describes the message bytebase.v1.ServiceAccount.diff --git a/frontend/src/types/proto-es/v1/setting_service_pb.js b/frontend/src/types/proto-es/v1/setting_service_pb.jsindex 56fb0141f1..9a2d052893 100644--- a/frontend/src/types/proto-es/v1/setting_service_pb.js+++ b/frontend/src/types/proto-es/v1/setting_service_pb.js@@ -18,7 +18,7 @@ import { file_v1_issue_service } from "./issue_service_pb";* Describes the file v1/setting_service.proto.*/export const file_v1_setting_service = /*@__PURE__*/- fileDesc("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", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_duration, file_google_protobuf_field_mask, file_google_type_color, file_google_type_expr, file_v1_annotation, file_v1_common, file_v1_issue_service]);+ fileDesc("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", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_duration, file_google_protobuf_field_mask, file_google_type_color, file_google_type_expr, file_v1_annotation, file_v1_common, file_v1_issue_service]);/*** Describes the message bytebase.v1.ListSettingsRequest.diff --git a/frontend/src/types/proto-es/v1/sql_service_pb.js b/frontend/src/types/proto-es/v1/sql_service_pb.jsindex 07f34acf5b..90712483b8 100644--- a/frontend/src/types/proto-es/v1/sql_service_pb.js+++ b/frontend/src/types/proto-es/v1/sql_service_pb.js@@ -15,7 +15,7 @@ import { file_v1_query_history_service } from "./query_history_service_pb";* Describes the file v1/sql_service.proto.*/export const file_v1_sql_service = /*@__PURE__*/- fileDesc("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", [file_google_api_annotations, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_duration, file_google_protobuf_struct, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common, file_v1_query_history_service]);+ fileDesc("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", [file_google_api_annotations, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_duration, file_google_protobuf_struct, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common, file_v1_query_history_service]);/*** Describes the message bytebase.v1.AdminExecuteRequest.diff --git a/frontend/src/types/proto-es/v1/subscription_service_pb.js b/frontend/src/types/proto-es/v1/subscription_service_pb.jsindex d962f8ac0a..dd2bc47dd3 100644--- a/frontend/src/types/proto-es/v1/subscription_service_pb.js+++ b/frontend/src/types/proto-es/v1/subscription_service_pb.js@@ -13,7 +13,7 @@ import { file_v1_annotation } from "./annotation_pb";* Describes the file v1/subscription_service.proto.*/export const file_v1_subscription_service = /*@__PURE__*/- fileDesc("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", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_protobuf_timestamp, file_v1_annotation]);+ fileDesc("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", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_protobuf_timestamp, file_v1_annotation]);/*** Describes the message bytebase.v1.GetSubscriptionRequest.diff --git a/frontend/src/types/proto-es/v1/user_service_pb.js b/frontend/src/types/proto-es/v1/user_service_pb.jsindex 41d39e941d..64b7e68eab 100644--- a/frontend/src/types/proto-es/v1/user_service_pb.js+++ b/frontend/src/types/proto-es/v1/user_service_pb.js@@ -16,7 +16,7 @@ import { file_v1_common } from "./common_pb";* Describes the file v1/user_service.proto.*/export const file_v1_user_service = /*@__PURE__*/- fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common]);+ fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common]);/*** Describes the message bytebase.v1.GetUserRequest.diff --git a/frontend/src/types/proto-es/v1/workload_identity_service_pb.js b/frontend/src/types/proto-es/v1/workload_identity_service_pb.jsindex ed65f20447..4f015a8f95 100644--- a/frontend/src/types/proto-es/v1/workload_identity_service_pb.js+++ b/frontend/src/types/proto-es/v1/workload_identity_service_pb.js@@ -16,7 +16,7 @@ import { file_v1_common } from "./common_pb";* Describes the file v1/workload_identity_service.proto.*/export const file_v1_workload_identity_service = /*@__PURE__*/- fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common]);+ fileDesc("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", [file_buf_validate_validate, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common]);/*** Describes the message bytebase.v1.WorkloadIdentity.diff --git a/frontend/src/types/proto-es/v1/workspace_service_pb.js b/frontend/src/types/proto-es/v1/workspace_service_pb.jsindex 653bb5353e..474cccfb37 100644--- a/frontend/src/types/proto-es/v1/workspace_service_pb.js+++ b/frontend/src/types/proto-es/v1/workspace_service_pb.js@@ -16,7 +16,7 @@ import { file_v1_iam_policy } from "./iam_policy_pb";* Describes the file v1/workspace_service.proto.*/export const file_v1_workspace_service = /*@__PURE__*/- fileDesc("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", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_field_mask, file_v1_annotation, file_v1_auth_service, file_v1_iam_policy]);+ fileDesc("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", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_field_mask, file_v1_annotation, file_v1_auth_service, file_v1_iam_policy]);/*** Describes the message bytebase.v1.RotateDirectorySyncTokenRequest.diff --git a/proto/gen/grpc-doc/openapi.yaml b/proto/gen/grpc-doc/openapi.yamlindex de5c5abfe3..c82e61e97a 100644--- a/proto/gen/grpc-doc/openapi.yaml+++ b/proto/gen/grpc-doc/openapi.yaml@@ -25971,27 +25971,11 @@ components:Protocol) server's delegated credential. The values are copied verbatim fromthe verified credential's grant state; empty fields record that the grantstored nothing (legacy sessions), never a resolved or synthesized value.- bytebase.v1.MCPExclusionReason:+ bytebase.v1.MCPDenialReason:type: string- title: MCPExclusionReason+ title: MCPDenialReasonenum:- - MCP_EXCLUSION_REASON_UNSPECIFIED- - ADMINISTERS_THE_WORKSPACE- - READS_OTHER_USERS_SQL- - OPENS_AN_ADMIN_CONNECTION- - SENDS_DATA_TO_A_THIRD_PARTY- - RETURNS_A_STORED_SECRET- description: |-- Why an RPC is served by no MCP mode. Unlike MCPForbiddenReason, which names- a mechanism that breaks the MCP boundary, these name a scope decision: the- method is out because this phase ships two modes and neither is the right- home for it. Each value is what a future admin-capable ceiling would have to- argue with, one population at a time.- bytebase.v1.MCPForbiddenReason:- type: string- title: MCPForbiddenReason- enum:- - MCP_FORBIDDEN_REASON_UNSPECIFIED+ - MCP_DENIAL_REASON_UNSPECIFIED- MINTS_CREDENTIAL- RESETS_CREDENTIAL- TAKES_OVER_ACCOUNT@@ -26000,12 +25984,29 @@ components:- MINTS_CREDENTIAL_FOR_OTHERS- REWRITES_SESSION_BOUNDARY- DRIVES_THE_APPROVAL_DECISION+ - ADMINISTERS_THE_WORKSPACE+ - READS_OTHER_USERS_SQL+ - OPENS_AN_ADMIN_CONNECTION+ - SENDS_DATA_TO_A_THIRD_PARTY+ - RETURNS_A_STORED_SECRETdescription: |-- Why an RPC is FORBIDDEN to MCP sessions. The mechanism, not the wording:- each value names what its methods actually do, and the serving side turns- that into a sentence. A denial whose stated reason has drifted from the- mechanism is worse than a bare refusal, because it is the thing the next- reader trusts — so a method changing what it does changes its reason here.+ Why an MCP session may not call an RPC. The mechanism, not the wording: each+ value names what its methods actually do, and the serving side turns that+ into a sentence. A denial whose stated reason has drifted from the mechanism+ is worse than a bare refusal, because it is the thing the next reader trusts+ — so a method changing what it does changes its reason here.++ One enum covers both refused classes, and every value belongs to exactly one+ of them: values 1-8 name a mechanism that breaks the MCP boundary, which is+ what FORBIDDEN means, and values 9-13 name a scope decision this phase took,+ which is what EXCLUDED means. The distinction is real and lives on the class+ annotation — a FORBIDDEN mechanism is a durable never, an EXCLUDED scope+ decision is what a future admin-capable ceiling would argue with, one+ population at a time. Splitting it across two enums as well only made the+ nonsense states representable: a method could carry both, or carry the kind+ that contradicts its class. Neither is expressible now, and the one check+ left — the reason belongs to the class it is used on — is a table the gate+ already keeps for the wording.bytebase.v1.MCPMethodClass:type: stringtitle: MCPMethodClass@@ -26020,12 +26021,11 @@ components:authorization of an MCP session is this classification intersected with thecaller's own RBAC: it can only ever narrow what the human could do, neverwiden it.- Only FORBIDDEN is enforced today. READ, WRITE and EXCLUDED are recorded- classifications and nothing reads them at request time yet — the gate that- selects between them is a later change. A method annotated READ or WRITE is- therefore served exactly as it is today; the annotation states where it- belongs, not where the boundary currently sits. FORBIDDEN is the exception- and is enforced the moment it is annotated.+ Every value is enforced, at the gate on the internal MCP chain. READ and+ WRITE are the serving classes the workspace's MCP capability ceiling selects+ between, EXCLUDED and FORBIDDEN are served by no ceiling, and an unclassified+ method is refused rather than served. Annotating a method is therefore a+ change to what an MCP session can reach, taking effect on the next request.bytebase.v1.MaskingExemptionPolicy:type: objectproperties:diff --git a/proto/gen/grpc-doc/store/README.md b/proto/gen/grpc-doc/store/README.mdindex 49367d080e..11d14aa7b2 100644--- a/proto/gen/grpc-doc/store/README.md+++ b/proto/gen/grpc-doc/store/README.md@@ -4810,7 +4810,7 @@ All other settings live in per-workspace WORKSPACE_PROFILE.| sql_editor_theme_id | [string](#string) | | Enforced SQL Editor theme id: OPAQUE — a frontend-resolved built-in preset id OR a custom theme's uuid. Empty ⇒ default light. || sql_editor_custom_theme | [SQLEditorThemeSetting](#bytebase-store-SQLEditorThemeSetting) | | The enforced CUSTOM theme's full definition — present ONLY when sql_editor_theme_id is a custom uuid. tokens is always complete. || maximum_role_expiration | [google.protobuf.Duration](#google-protobuf-Duration) | | The max expiration duration for request role. Deprecated: use just-in-time access request flows instead. |-| mcp_capability | [WorkspaceProfileSetting.MCPCapability](#bytebase-store-WorkspaceProfileSetting-MCPCapability) | | The maximum capability available to MCP (Model Context Protocol) sessions in this workspace, acting as an admin-set ceiling. Unset is treated as READ_WRITE for backward compatibility; DISABLED rejects all MCP connections. Enforced server-side by the /mcp endpoint. |+| mcp_capability | [WorkspaceProfileSetting.MCPCapability](#bytebase-store-WorkspaceProfileSetting-MCPCapability) | | The maximum capability available to MCP (Model Context Protocol) sessions in this workspace, acting as an admin-set ceiling. Unset is treated as READ_WRITE for backward compatibility; DISABLED rejects all MCP connections. Enforced server-side at two points: the /mcp endpoint decides whether a connection is admitted at all, and the ceiling gate on the internal MCP chain decides, per request, which method classes are served. || directory_sync_token_hash | [string](#string) | | Hex-encoded SHA-256 of the SCIM directory sync token. The plaintext is shown once at rotation and never stored. SHA-256 rather than a slow KDF because the token is 122 bits of crypto/rand, not a human-chosen secret. |diff --git a/proto/gen/grpc-doc/store/index.html b/proto/gen/grpc-doc/store/index.htmlindex acdf1da199..c0afa5a33c 100644--- a/proto/gen/grpc-doc/store/index.html+++ b/proto/gen/grpc-doc/store/index.html@@ -13217,7 +13217,9 @@ Deprecated: use just-in-time access request flows instead. </p></td><td><p>The maximum capability available to MCP (Model Context Protocol) sessions inthis workspace, acting as an admin-set ceiling. Unset is treated asREAD_WRITE for backward compatibility; DISABLED rejects all MCP-connections. Enforced server-side by the /mcp endpoint. </p></td>+connections. Enforced server-side at two points: the /mcp endpoint decides+whether a connection is admitted at all, and the ceiling gate on the+internal MCP chain decides, per request, which method classes are served. </p></td></tr><tr>diff --git a/proto/gen/grpc-doc/v1/README.md b/proto/gen/grpc-doc/v1/README.mdindex bb2eb5960f..bc514ab47d 100644--- a/proto/gen/grpc-doc/v1/README.md+++ b/proto/gen/grpc-doc/v1/README.md@@ -5,8 +5,7 @@- [v1/annotation.proto](#v1_annotation-proto)- [AuthMethod](#bytebase-v1-AuthMethod)- - [MCPExclusionReason](#bytebase-v1-MCPExclusionReason)- - [MCPForbiddenReason](#bytebase-v1-MCPForbiddenReason)+ - [MCPDenialReason](#bytebase-v1-MCPDenialReason)- [MCPMethodClass](#bytebase-v1-MCPMethodClass)- [File-level Extensions](#v1_annotation-proto-extensions)@@ -15,7 +14,6 @@- [File-level Extensions](#v1_annotation-proto-extensions)- [File-level Extensions](#v1_annotation-proto-extensions)- [File-level Extensions](#v1_annotation-proto-extensions)- - [File-level Extensions](#v1_annotation-proto-extensions)- [v1/access_grant_service.proto](#v1_access_grant_service-proto)- [AccessGrant](#bytebase-v1-AccessGrant)@@ -812,38 +810,30 @@ Authorization method for RPC calls.-<a name="bytebase-v1-MCPExclusionReason"></a>--### MCPExclusionReason-Why an RPC is served by no MCP mode. Unlike MCPForbiddenReason, which names-a mechanism that breaks the MCP boundary, these name a scope decision: the-method is out because this phase ships two modes and neither is the right-home for it. Each value is what a future admin-capable ceiling would have to-argue with, one population at a time.--| Name | Number | Description |-| ---- | ------ | ----------- |-| MCP_EXCLUSION_REASON_UNSPECIFIED | 0 | No reason recorded. CI rejects this on a method classified EXCLUDED. |-| ADMINISTERS_THE_WORKSPACE | 1 | Administers the workspace rather than doing database work: identity, credentials, access control, governance policy, billing, workspace and instance configuration, project lifecycle, and the operator's own audit trail. Reading is administration too where the read returns the privilege topology or a stored secret rather than the state of a database. |-| READS_OTHER_USERS_SQL | 2 | Returns SQL that other people wrote. The permission gating it reads as an ordinary list permission, so the exclusion is per method rather than per permission: these methods span the workspace or ignore the per-object sharing that keeps a saved query private. |-| OPENS_AN_ADMIN_CONNECTION | 3 | Opens an admin-credentialed connection to the customer's database and returns live session state from it — including other sessions' in-flight, unmasked SQL. It shares a plain read permission with sibling methods that only read Bytebase's own store. |-| SENDS_DATA_TO_A_THIRD_PARTY | 4 | Spends a stored workspace credential on an outbound call to a third party, which puts whatever the caller passes outside the product. |-| RETURNS_A_STORED_SECRET | 5 | Returns a stored secret in its response body today. These are ordinary reads that belong in a serving class on their merits, and each is here because of a leak that a redaction on the read path would close — the product already redacts the same values elsewhere. This reason is therefore the one that is meant to go away: fixing the leak moves the method to READ, as a reviewed widening, rather than leaving a quiet exposure the moment the ceiling starts serving. |-+<a name="bytebase-v1-MCPDenialReason"></a>+### MCPDenialReason+Why an MCP session may not call an RPC. The mechanism, not the wording: each+value names what its methods actually do, and the serving side turns that+into a sentence. A denial whose stated reason has drifted from the mechanism+is worse than a bare refusal, because it is the thing the next reader trusts+— so a method changing what it does changes its reason here.-<a name="bytebase-v1-MCPForbiddenReason"></a>--### MCPForbiddenReason-Why an RPC is FORBIDDEN to MCP sessions. The mechanism, not the wording:-each value names what its methods actually do, and the serving side turns-that into a sentence. A denial whose stated reason has drifted from the-mechanism is worse than a bare refusal, because it is the thing the next-reader trusts — so a method changing what it does changes its reason here.+One enum covers both refused classes, and every value belongs to exactly one+of them: values 1-8 name a mechanism that breaks the MCP boundary, which is+what FORBIDDEN means, and values 9-13 name a scope decision this phase took,+which is what EXCLUDED means. The distinction is real and lives on the class+annotation — a FORBIDDEN mechanism is a durable never, an EXCLUDED scope+decision is what a future admin-capable ceiling would argue with, one+population at a time. Splitting it across two enums as well only made the+nonsense states representable: a method could carry both, or carry the kind+that contradicts its class. Neither is expressible now, and the one check+left — the reason belongs to the class it is used on — is a table the gate+already keeps for the wording.| Name | Number | Description || ---- | ------ | ----------- |-| MCP_FORBIDDEN_REASON_UNSPECIFIED | 0 | No reason recorded. The method is still denied — mcp_method_class is what enforces — and the denial falls back to generic wording. |+| MCP_DENIAL_REASON_UNSPECIFIED | 0 | No reason recorded. The method is still denied — mcp_method_class is what enforces — and the denial falls back to generic wording. CI rejects this on a method classified FORBIDDEN or EXCLUDED. || MINTS_CREDENTIAL | 1 | Puts a token for the caller's own principal in the response body. || RESETS_CREDENTIAL | 2 | Drives the out-of-band reset flow that sets or delivers the secret a login accepts. || TAKES_OVER_ACCOUNT | 3 | Rewrites an account's own credentials, which would let the session log in as that account. |@@ -852,6 +842,11 @@ reader trusts — so a method changing what it does changes its reason here.| MINTS_CREDENTIAL_FOR_OTHERS | 6 | Leaves someone holding a principal the caller is not — by issuing its credential, carrying an existing one out to a host the caller named, choosing what will later be trusted to mint one, or redirecting where one gets delivered. || REWRITES_SESSION_BOUNDARY | 7 | Rewrites the workspace configuration that governs the session making the call — the MCP switch itself, the sign-in and SSO settings, the mail relay that carries credential resets, and the AI endpoint the stored API key is sent to. A session that can widen its own ceiling is not bounded by it. || DRIVES_THE_APPROVAL_DECISION | 8 | Works the human approval step that gates the change: recording the review decision, or re-running the finding that sets it and can clear the issue outright. An agent composes a change; it does not move its own change through the gate. |+| ADMINISTERS_THE_WORKSPACE | 9 | Administers the workspace rather than doing database work: identity, credentials, access control, governance policy, billing, workspace and instance configuration, project lifecycle, and the operator's own audit trail. Reading is administration too where the read returns the privilege topology or a stored secret rather than the state of a database. |+| READS_OTHER_USERS_SQL | 10 | Returns SQL that other people wrote. The permission gating it reads as an ordinary list permission, so the exclusion is per method rather than per permission: these methods span the workspace or ignore the per-object sharing that keeps a saved query private. |+| OPENS_AN_ADMIN_CONNECTION | 11 | Opens an admin-credentialed connection to the customer's database and returns live session state from it — including other sessions' in-flight, unmasked SQL. It shares a plain read permission with sibling methods that only read Bytebase's own store. |+| SENDS_DATA_TO_A_THIRD_PARTY | 12 | Spends a stored workspace credential on an outbound call to a third party, which puts whatever the caller passes outside the product. |+| RETURNS_A_STORED_SECRET | 13 | Returns a stored secret in its response body today. These are ordinary reads that belong in a serving class on their merits, and each is here because of a leak that a redaction on the read path would close — the product already redacts the same values elsewhere. This reason is therefore the one that is meant to go away: fixing the leak moves the method to READ, as a reviewed widening, rather than leaving a quiet exposure the moment the ceiling starts serving. |@@ -862,20 +857,19 @@ Classification of an RPC for MCP (AI agent) sessions. The effectiveauthorization of an MCP session is this classification intersected with thecaller's own RBAC: it can only ever narrow what the human could do, neverwiden it.-Only FORBIDDEN is enforced today. READ, WRITE and EXCLUDED are recorded-classifications and nothing reads them at request time yet — the gate that-selects between them is a later change. A method annotated READ or WRITE is-therefore served exactly as it is today; the annotation states where it-belongs, not where the boundary currently sits. FORBIDDEN is the exception-and is enforced the moment it is annotated.+Every value is enforced, at the gate on the internal MCP chain. READ and+WRITE are the serving classes the workspace's MCP capability ceiling selects+between, EXCLUDED and FORBIDDEN are served by no ceiling, and an unclassified+method is refused rather than served. Annotating a method is therefore a+change to what an MCP session can reach, taking effect on the next request.| Name | Number | Description || ---- | ------ | ----------- |-| MCP_METHOD_CLASS_UNSPECIFIED | 0 | Not yet classified. Reaches its handler, subject to RBAC as usual. CI rejects this value on any v1 RPC, so it survives only inside a build that has not been linted: a new RPC is classified before it can ship. |+| MCP_METHOD_CLASS_UNSPECIFIED | 0 | Not yet classified, and refused. CI rejects this value on any v1 RPC, so it survives only inside a build that has not been linted: a new RPC is classified before it can ship, and one that somehow reaches an MCP session unclassified is denied rather than guessed at. || READ | 1 | Served to a read-only MCP session and above. || WRITE | 2 | Served to a read-write MCP session only. This is a serving mode, not a verb: a method that only reads still belongs here when a read-only session has no business calling it — taking a copy of data out of the product, or generating migration DDL from a schema the caller supplied. || FORBIDDEN | 3 | Never reachable by an MCP session, whatever the caller's own permissions are. These methods escape the MCP boundary rather than merely exercising a permission: a human with the permission uses the console; an agent acting for them does not get to. |-| EXCLUDED | 4 | Served by no MCP mode this phase ships, and not a durable never. These are workspace administration, plus the handful of methods that do something materially worse than the plain read permission they share suggests.+| EXCLUDED | 4 | Served by no MCP capability ceiling this phase ships, and not a durable never. These are workspace administration, plus the handful of methods that do something materially worse than the plain read permission they share suggests.The line against FORBIDDEN is reversibility. An admin-capable ceiling, if one is ever built, could legitimately serve an EXCLUDED method — that is a product decision nobody has made. It could never serve a FORBIDDEN one, because FORBIDDEN names a mechanism that breaks the MCP boundary itself. Keeping them apart is what stops a future widening from having to re-litigate the credential-minting set alongside the ordinary admin API. |@@ -891,8 +885,9 @@ The line against FORBIDDEN is reversibility. An admin-capable ceiling, if one is| allow_without_credential | bool | .google.protobuf.MethodOptions | 100000 | Whether the method allows access without authentication credentials. || audit | bool | .google.protobuf.MethodOptions | 100003 | Whether to audit calls to this method. || auth_method | AuthMethod | .google.protobuf.MethodOptions | 100002 | The authorization method to use for this RPC. |-| mcp_exclusion_reason | MCPExclusionReason | .google.protobuf.MethodOptions | 100006 | Why the method is served by no MCP mode. Meaningful only alongside mcp_method_class = EXCLUDED, and required there: an exclusion whose reason nobody wrote down is one nobody can revisit, and these are the rows a later admin-capable ceiling has to re-decide one at a time. |-| mcp_forbidden_reason | MCPForbiddenReason | .google.protobuf.MethodOptions | 100005 | Why the method is forbidden to MCP sessions. Meaningful only alongside mcp_method_class = FORBIDDEN; the denial names it so the agent, and the operator reading the audit row, learn why rather than just that it was refused. |+| mcp_denial_reason | MCPDenialReason | .google.protobuf.MethodOptions | 100005 | Why an MCP session may not call the method. Meaningful only alongside mcp_method_class = FORBIDDEN or EXCLUDED, and required on both: the denial names it so the agent, and the operator reading the audit row, learn why rather than just that it was refused, and an exclusion whose reason nobody wrote down is one nobody can revisit.++100006 was mcp_exclusion_reason, folded into mcp_denial_reason above. Do not reuse the number: an extend block cannot carry a `reserved` statement, so this comment is the only marker, and a binary built before the merge reads 100006 as the old enum — giving that number a new meaning would let it read a confident wrong answer instead of nothing. || mcp_method_class | MCPMethodClass | .google.protobuf.MethodOptions | 100004 | How the method is classified for MCP (AI agent) sessions. || permission | string | .google.protobuf.MethodOptions | 100001 | The permission required to call this method. |diff --git a/proto/gen/grpc-doc/v1/index.html b/proto/gen/grpc-doc/v1/index.htmlindex e7dfeb51ad..c66cfda091 100644--- a/proto/gen/grpc-doc/v1/index.html+++ b/proto/gen/grpc-doc/v1/index.html@@ -184,11 +184,7 @@</li><li>- <a href="#bytebase.v1.MCPExclusionReason"><span class="badge">E</span>MCPExclusionReason</a>- </li>-- <li>- <a href="#bytebase.v1.MCPForbiddenReason"><span class="badge">E</span>MCPForbiddenReason</a>+ <a href="#bytebase.v1.MCPDenialReason"><span class="badge">E</span>MCPDenialReason</a></li><li>@@ -220,10 +216,6 @@<a href="#v1%2fannotation.proto-extensions"><span class="badge">X</span>File-level Extensions</a></li>- <li>- <a href="#v1%2fannotation.proto-extensions"><span class="badge">X</span>File-level Extensions</a>- </li>-</ul></li>@@ -3212,72 +3204,8 @@</tbody></table>- <h3 id="bytebase.v1.MCPExclusionReason">MCPExclusionReason</h3>- <p>Why an RPC is served by no MCP mode. Unlike MCPForbiddenReason, which names</p><p>a mechanism that breaks the MCP boundary, these name a scope decision: the</p><p>method is out because this phase ships two modes and neither is the right</p><p>home for it. Each value is what a future admin-capable ceiling would have to</p><p>argue with, one population at a time.</p>- <table class="enum-table">- <thead>- <tr><td>Name</td><td>Number</td><td>Description</td></tr>- </thead>- <tbody>-- <tr>- <td>MCP_EXCLUSION_REASON_UNSPECIFIED</td>- <td>0</td>- <td><p>No reason recorded. CI rejects this on a method classified EXCLUDED.</p></td>- </tr>-- <tr>- <td>ADMINISTERS_THE_WORKSPACE</td>- <td>1</td>- <td><p>Administers the workspace rather than doing database work: identity,-credentials, access control, governance policy, billing, workspace and-instance configuration, project lifecycle, and the operator's own audit-trail. Reading is administration too where the read returns the privilege-topology or a stored secret rather than the state of a database.</p></td>- </tr>-- <tr>- <td>READS_OTHER_USERS_SQL</td>- <td>2</td>- <td><p>Returns SQL that other people wrote. The permission gating it reads as an-ordinary list permission, so the exclusion is per method rather than per-permission: these methods span the workspace or ignore the per-object-sharing that keeps a saved query private.</p></td>- </tr>-- <tr>- <td>OPENS_AN_ADMIN_CONNECTION</td>- <td>3</td>- <td><p>Opens an admin-credentialed connection to the customer's database and-returns live session state from it — including other sessions' in-flight,-unmasked SQL. It shares a plain read permission with sibling methods that-only read Bytebase's own store.</p></td>- </tr>-- <tr>- <td>SENDS_DATA_TO_A_THIRD_PARTY</td>- <td>4</td>- <td><p>Spends a stored workspace credential on an outbound call to a third-party, which puts whatever the caller passes outside the product.</p></td>- </tr>-- <tr>- <td>RETURNS_A_STORED_SECRET</td>- <td>5</td>- <td><p>Returns a stored secret in its response body today. These are ordinary-reads that belong in a serving class on their merits, and each is here-because of a leak that a redaction on the read path would close — the-product already redacts the same values elsewhere. This reason is-therefore the one that is meant to go away: fixing the leak moves the-method to READ, as a reviewed widening, rather than leaving a quiet-exposure the moment the ceiling starts serving.</p></td>- </tr>-- </tbody>- </table>-- <h3 id="bytebase.v1.MCPForbiddenReason">MCPForbiddenReason</h3>- <p>Why an RPC is FORBIDDEN to MCP sessions. The mechanism, not the wording:</p><p>each value names what its methods actually do, and the serving side turns</p><p>that into a sentence. A denial whose stated reason has drifted from the</p><p>mechanism is worse than a bare refusal, because it is the thing the next</p><p>reader trusts — so a method changing what it does changes its reason here.</p>+ <h3 id="bytebase.v1.MCPDenialReason">MCPDenialReason</h3>+ <p>Why an MCP session may not call an RPC. The mechanism, not the wording: each</p><p>value names what its methods actually do, and the serving side turns that</p><p>into a sentence. A denial whose stated reason has drifted from the mechanism</p><p>is worse than a bare refusal, because it is the thing the next reader trusts</p><p>— so a method changing what it does changes its reason here.</p><p>One enum covers both refused classes, and every value belongs to exactly one</p><p>of them: values 1-8 name a mechanism that breaks the MCP boundary, which is</p><p>what FORBIDDEN means, and values 9-13 name a scope decision this phase took,</p><p>which is what EXCLUDED means. The distinction is real and lives on the class</p><p>annotation — a FORBIDDEN mechanism is a durable never, an EXCLUDED scope</p><p>decision is what a future admin-capable ceiling would argue with, one</p><p>population at a time. Splitting it across two enums as well only made the</p><p>nonsense states representable: a method could carry both, or carry the kind</p><p>that contradicts its class. Neither is expressible now, and the one check</p><p>left — the reason belongs to the class it is used on — is a table the gate</p><p>already keeps for the wording.</p><table class="enum-table"><thead><tr><td>Name</td><td>Number</td><td>Description</td></tr>@@ -3285,10 +3213,11 @@ exposure the moment the ceiling starts serving.</p></td><tbody><tr>- <td>MCP_FORBIDDEN_REASON_UNSPECIFIED</td>+ <td>MCP_DENIAL_REASON_UNSPECIFIED</td><td>0</td><td><p>No reason recorded. The method is still denied — mcp_method_class is what-enforces — and the denial falls back to generic wording.</p></td>+enforces — and the denial falls back to generic wording. CI rejects this+on a method classified FORBIDDEN or EXCLUDED.</p></td></tr><tr>@@ -3352,11 +3281,58 @@ outright. An agent composes a change; it does not move its own changethrough the gate.</p></td></tr>+ <tr>+ <td>ADMINISTERS_THE_WORKSPACE</td>+ <td>9</td>+ <td><p>Administers the workspace rather than doing database work: identity,+credentials, access control, governance policy, billing, workspace and+instance configuration, project lifecycle, and the operator's own audit+trail. Reading is administration too where the read returns the privilege+topology or a stored secret rather than the state of a database.</p></td>+ </tr>++ <tr>+ <td>READS_OTHER_USERS_SQL</td>+ <td>10</td>+ <td><p>Returns SQL that other people wrote. The permission gating it reads as an+ordinary list permission, so the exclusion is per method rather than per+permission: these methods span the workspace or ignore the per-object+sharing that keeps a saved query private.</p></td>+ </tr>++ <tr>+ <td>OPENS_AN_ADMIN_CONNECTION</td>+ <td>11</td>+ <td><p>Opens an admin-credentialed connection to the customer's database and+returns live session state from it — including other sessions' in-flight,+unmasked SQL. It shares a plain read permission with sibling methods that+only read Bytebase's own store.</p></td>+ </tr>++ <tr>+ <td>SENDS_DATA_TO_A_THIRD_PARTY</td>+ <td>12</td>+ <td><p>Spends a stored workspace credential on an outbound call to a third+party, which puts whatever the caller passes outside the product.</p></td>+ </tr>++ <tr>+ <td>RETURNS_A_STORED_SECRET</td>+ <td>13</td>+ <td><p>Returns a stored secret in its response body today. These are ordinary+reads that belong in a serving class on their merits, and each is here+because of a leak that a redaction on the read path would close — the+product already redacts the same values elsewhere. This reason is+therefore the one that is meant to go away: fixing the leak moves the+method to READ, as a reviewed widening, rather than leaving a quiet+exposure the moment the ceiling starts serving.</p></td>+ </tr>+</tbody></table><h3 id="bytebase.v1.MCPMethodClass">MCPMethodClass</h3>- <p>Classification of an RPC for MCP (AI agent) sessions. The effective</p><p>authorization of an MCP session is this classification intersected with the</p><p>caller's own RBAC: it can only ever narrow what the human could do, never</p><p>widen it.</p><p>Only FORBIDDEN is enforced today. READ, WRITE and EXCLUDED are recorded</p><p>classifications and nothing reads them at request time yet — the gate that</p><p>selects between them is a later change. A method annotated READ or WRITE is</p><p>therefore served exactly as it is today; the annotation states where it</p><p>belongs, not where the boundary currently sits. FORBIDDEN is the exception</p><p>and is enforced the moment it is annotated.</p>+ <p>Classification of an RPC for MCP (AI agent) sessions. The effective</p><p>authorization of an MCP session is this classification intersected with the</p><p>caller's own RBAC: it can only ever narrow what the human could do, never</p><p>widen it.</p><p>Every value is enforced, at the gate on the internal MCP chain. READ and</p><p>WRITE are the serving classes the workspace's MCP capability ceiling selects</p><p>between, EXCLUDED and FORBIDDEN are served by no ceiling, and an unclassified</p><p>method is refused rather than served. Annotating a method is therefore a</p><p>change to what an MCP session can reach, taking effect on the next request.</p><table class="enum-table"><thead><tr><td>Name</td><td>Number</td><td>Description</td></tr>@@ -3366,9 +3342,10 @@ through the gate.</p></td><tr><td>MCP_METHOD_CLASS_UNSPECIFIED</td><td>0</td>- <td><p>Not yet classified. Reaches its handler, subject to RBAC as usual. CI-rejects this value on any v1 RPC, so it survives only inside a build that-has not been linted: a new RPC is classified before it can ship.</p></td>+ <td><p>Not yet classified, and refused. CI rejects this value on any v1 RPC, so+it survives only inside a build that has not been linted: a new RPC is+classified before it can ship, and one that somehow reaches an MCP session+unclassified is denied rather than guessed at.</p></td></tr><tr>@@ -3398,9 +3375,10 @@ console; an agent acting for them does not get to.</p></td><tr><td>EXCLUDED</td><td>4</td>- <td><p>Served by no MCP mode this phase ships, and not a durable never. These are-workspace administration, plus the handful of methods that do something-materially worse than the plain read permission they share suggests.+ <td><p>Served by no MCP capability ceiling this phase ships, and not a durable+never. These are workspace administration, plus the handful of methods+that do something materially worse than the plain read permission they+share suggests.The line against FORBIDDEN is reversibility. An admin-capable ceiling, ifone is ever built, could legitimately serve an EXCLUDED method — that is a@@ -3447,25 +3425,21 @@ re-litigate the credential-minting set alongside the ordinary admin API.</p></td</tr><tr>- <td>mcp_exclusion_reason</td>- <td><a href="#bytebase.v1.MCPExclusionReason">MCPExclusionReason</a></td>- <td><a href="#google.protobuf.MethodOptions">.google.protobuf.MethodOptions</a></td>- <td>100006</td>- <td><p>Why the method is served by no MCP mode. Meaningful only alongside-mcp_method_class = EXCLUDED, and required there: an exclusion whose reason-nobody wrote down is one nobody can revisit, and these are the rows a-later admin-capable ceiling has to re-decide one at a time.</p></td>- </tr>-- <tr>- <td>mcp_forbidden_reason</td>- <td><a href="#bytebase.v1.MCPForbiddenReason">MCPForbiddenReason</a></td>+ <td>mcp_denial_reason</td>+ <td><a href="#bytebase.v1.MCPDenialReason">MCPDenialReason</a></td><td><a href="#google.protobuf.MethodOptions">.google.protobuf.MethodOptions</a></td><td>100005</td>- <td><p>Why the method is forbidden to MCP sessions. Meaningful only alongside-mcp_method_class = FORBIDDEN; the denial names it so the agent, and the-operator reading the audit row, learn why rather than just that it was-refused.</p></td>+ <td><p>Why an MCP session may not call the method. Meaningful only alongside+mcp_method_class = FORBIDDEN or EXCLUDED, and required on both: the denial+names it so the agent, and the operator reading the audit row, learn why+rather than just that it was refused, and an exclusion whose reason nobody+wrote down is one nobody can revisit.++100006 was mcp_exclusion_reason, folded into mcp_denial_reason above. Do+not reuse the number: an extend block cannot carry a `reserved` statement,+so this comment is the only marker, and a binary built before the merge+reads 100006 as the old enum — giving that number a new meaning would let+it read a confident wrong answer instead of nothing.</p></td></tr><tr>diff --git a/proto/store/store/setting.proto b/proto/store/store/setting.protoindex 0d5843b886..d17a77ba1c 100644--- a/proto/store/store/setting.proto+++ b/proto/store/store/setting.proto@@ -179,7 +179,9 @@ message WorkspaceProfileSetting {// The maximum capability available to MCP (Model Context Protocol) sessions in// this workspace, acting as an admin-set ceiling. Unset is treated as// READ_WRITE for backward compatibility; DISABLED rejects all MCP- // connections. Enforced server-side by the /mcp endpoint.+ // connections. Enforced server-side at two points: the /mcp endpoint decides+ // whether a connection is admitted at all, and the ceiling gate on the+ // internal MCP chain decides, per request, which method classes are served.MCPCapability mcp_capability = 26;// Hex-encoded SHA-256 of the SCIM directory sync token. The plaintext is showndiff --git a/proto/v1/v1/access_grant_service.proto b/proto/v1/v1/access_grant_service.protoindex 7b6444a4ef..51a7334307 100644--- a/proto/v1/v1/access_grant_service.proto+++ b/proto/v1/v1/access_grant_service.proto@@ -21,7 +21,7 @@ service AccessGrantService {option (bytebase.v1.permission) = "bb.accessGrants.get";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Lists access grants in a project.@@ -31,7 +31,7 @@ service AccessGrantService {option (bytebase.v1.permission) = "bb.accessGrants.list";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Creates an access grant.@@ -45,7 +45,7 @@ service AccessGrantService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Activates a pending access grant.@@ -59,7 +59,7 @@ service AccessGrantService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Revokes an active access grant.@@ -73,7 +73,7 @@ service AccessGrantService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Searches access grants created by the caller.diff --git a/proto/v1/v1/actuator_service.proto b/proto/v1/v1/actuator_service.protoindex c98326e7cf..3bdb5fa8e6 100644--- a/proto/v1/v1/actuator_service.proto+++ b/proto/v1/v1/actuator_service.proto@@ -33,7 +33,7 @@ service ActuatorService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}}diff --git a/proto/v1/v1/ai_service.proto b/proto/v1/v1/ai_service.protoindex a01a4b534b..4d30ac7a12 100644--- a/proto/v1/v1/ai_service.proto+++ b/proto/v1/v1/ai_service.proto@@ -18,7 +18,7 @@ service AIService {};option (bytebase.v1.auth_method) = CUSTOM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = SENDS_DATA_TO_A_THIRD_PARTY;+ option (bytebase.v1.mcp_denial_reason) = SENDS_DATA_TO_A_THIRD_PARTY;}}diff --git a/proto/v1/v1/annotation.proto b/proto/v1/v1/annotation.protoindex b7a612ffe9..e11f2e029c 100644--- a/proto/v1/v1/annotation.proto+++ b/proto/v1/v1/annotation.proto@@ -18,16 +18,17 @@ extend google.protobuf.MethodOptions {bool audit = 100003;// How the method is classified for MCP (AI agent) sessions.MCPMethodClass mcp_method_class = 100004;- // Why the method is forbidden to MCP sessions. Meaningful only alongside- // mcp_method_class = FORBIDDEN; the denial names it so the agent, and the- // operator reading the audit row, learn why rather than just that it was- // refused.- MCPForbiddenReason mcp_forbidden_reason = 100005;- // Why the method is served by no MCP mode. Meaningful only alongside- // mcp_method_class = EXCLUDED, and required there: an exclusion whose reason- // nobody wrote down is one nobody can revisit, and these are the rows a- // later admin-capable ceiling has to re-decide one at a time.- MCPExclusionReason mcp_exclusion_reason = 100006;+ // Why an MCP session may not call the method. Meaningful only alongside+ // mcp_method_class = FORBIDDEN or EXCLUDED, and required on both: the denial+ // names it so the agent, and the operator reading the audit row, learn why+ // rather than just that it was refused, and an exclusion whose reason nobody+ // wrote down is one nobody can revisit.+ MCPDenialReason mcp_denial_reason = 100005;+ // 100006 was mcp_exclusion_reason, folded into mcp_denial_reason above. Do+ // not reuse the number: an extend block cannot carry a `reserved` statement,+ // so this comment is the only marker, and a binary built before the merge+ // reads 100006 as the old enum — giving that number a new meaning would let+ // it read a confident wrong answer instead of nothing.}// Authorization method for RPC calls.@@ -44,16 +45,16 @@ enum AuthMethod {// authorization of an MCP session is this classification intersected with the// caller's own RBAC: it can only ever narrow what the human could do, never// widen it.-// Only FORBIDDEN is enforced today. READ, WRITE and EXCLUDED are recorded-// classifications and nothing reads them at request time yet — the gate that-// selects between them is a later change. A method annotated READ or WRITE is-// therefore served exactly as it is today; the annotation states where it-// belongs, not where the boundary currently sits. FORBIDDEN is the exception-// and is enforced the moment it is annotated.+// Every value is enforced, at the gate on the internal MCP chain. READ and+// WRITE are the serving classes the workspace's MCP capability ceiling selects+// between, EXCLUDED and FORBIDDEN are served by no ceiling, and an unclassified+// method is refused rather than served. Annotating a method is therefore a+// change to what an MCP session can reach, taking effect on the next request.enum MCPMethodClass {- // Not yet classified. Reaches its handler, subject to RBAC as usual. CI- // rejects this value on any v1 RPC, so it survives only inside a build that- // has not been linted: a new RPC is classified before it can ship.+ // Not yet classified, and refused. CI rejects this value on any v1 RPC, so+ // it survives only inside a build that has not been linted: a new RPC is+ // classified before it can ship, and one that somehow reaches an MCP session+ // unclassified is denied rather than guessed at.MCP_METHOD_CLASS_UNSPECIFIED = 0;// Served to a read-only MCP session and above.READ = 1;@@ -67,9 +68,10 @@ enum MCPMethodClass {// merely exercising a permission: a human with the permission uses the// console; an agent acting for them does not get to.FORBIDDEN = 3;- // Served by no MCP mode this phase ships, and not a durable never. These are- // workspace administration, plus the handful of methods that do something- // materially worse than the plain read permission they share suggests.+ // Served by no MCP capability ceiling this phase ships, and not a durable+ // never. These are workspace administration, plus the handful of methods+ // that do something materially worse than the plain read permission they+ // share suggests.//// The line against FORBIDDEN is reversibility. An admin-capable ceiling, if// one is ever built, could legitimately serve an EXCLUDED method — that is a@@ -80,15 +82,32 @@ enum MCPMethodClass {EXCLUDED = 4;}-// Why an RPC is FORBIDDEN to MCP sessions. The mechanism, not the wording:-// each value names what its methods actually do, and the serving side turns-// that into a sentence. A denial whose stated reason has drifted from the-// mechanism is worse than a bare refusal, because it is the thing the next-// reader trusts — so a method changing what it does changes its reason here.-enum MCPForbiddenReason {+// Why an MCP session may not call an RPC. The mechanism, not the wording: each+// value names what its methods actually do, and the serving side turns that+// into a sentence. A denial whose stated reason has drifted from the mechanism+// is worse than a bare refusal, because it is the thing the next reader trusts+// — so a method changing what it does changes its reason here.+//+// One enum covers both refused classes, and every value belongs to exactly one+// of them: values 1-8 name a mechanism that breaks the MCP boundary, which is+// what FORBIDDEN means, and values 9-13 name a scope decision this phase took,+// which is what EXCLUDED means. The distinction is real and lives on the class+// annotation — a FORBIDDEN mechanism is a durable never, an EXCLUDED scope+// decision is what a future admin-capable ceiling would argue with, one+// population at a time. Splitting it across two enums as well only made the+// nonsense states representable: a method could carry both, or carry the kind+// that contradicts its class. Neither is expressible now, and the one check+// left — the reason belongs to the class it is used on — is a table the gate+// already keeps for the wording.+enum MCPDenialReason {// No reason recorded. The method is still denied — mcp_method_class is what- // enforces — and the denial falls back to generic wording.- MCP_FORBIDDEN_REASON_UNSPECIFIED = 0;+ // enforces — and the denial falls back to generic wording. CI rejects this+ // on a method classified FORBIDDEN or EXCLUDED.+ MCP_DENIAL_REASON_UNSPECIFIED = 0;++ // 1-8: FORBIDDEN. The method escapes the MCP boundary rather than merely+ // exercising a permission, so no ceiling can ever serve it.+// Puts a token for the caller's own principal in the response body.MINTS_CREDENTIAL = 1;// Drives the out-of-band reset flow that sets or delivers the secret a@@ -118,35 +137,30 @@ enum MCPForbiddenReason {// outright. An agent composes a change; it does not move its own change// through the gate.DRIVES_THE_APPROVAL_DECISION = 8;-}-// Why an RPC is served by no MCP mode. Unlike MCPForbiddenReason, which names-// a mechanism that breaks the MCP boundary, these name a scope decision: the-// method is out because this phase ships two modes and neither is the right-// home for it. Each value is what a future admin-capable ceiling would have to-// argue with, one population at a time.-enum MCPExclusionReason {- // No reason recorded. CI rejects this on a method classified EXCLUDED.- MCP_EXCLUSION_REASON_UNSPECIFIED = 0;+ // 9-13: EXCLUDED. The method is out because this phase ships two modes and+ // neither is the right home for it, which is a decision rather than a+ // mechanism.+// Administers the workspace rather than doing database work: identity,// credentials, access control, governance policy, billing, workspace and// instance configuration, project lifecycle, and the operator's own audit// trail. Reading is administration too where the read returns the privilege// topology or a stored secret rather than the state of a database.- ADMINISTERS_THE_WORKSPACE = 1;+ ADMINISTERS_THE_WORKSPACE = 9;// Returns SQL that other people wrote. The permission gating it reads as an// ordinary list permission, so the exclusion is per method rather than per// permission: these methods span the workspace or ignore the per-object// sharing that keeps a saved query private.- READS_OTHER_USERS_SQL = 2;+ READS_OTHER_USERS_SQL = 10;// Opens an admin-credentialed connection to the customer's database and// returns live session state from it — including other sessions' in-flight,// unmasked SQL. It shares a plain read permission with sibling methods that// only read Bytebase's own store.- OPENS_AN_ADMIN_CONNECTION = 3;+ OPENS_AN_ADMIN_CONNECTION = 11;// Spends a stored workspace credential on an outbound call to a third// party, which puts whatever the caller passes outside the product.- SENDS_DATA_TO_A_THIRD_PARTY = 4;+ SENDS_DATA_TO_A_THIRD_PARTY = 12;// Returns a stored secret in its response body today. These are ordinary// reads that belong in a serving class on their merits, and each is here// because of a leak that a redaction on the read path would close — the@@ -154,5 +168,5 @@ enum MCPExclusionReason {// therefore the one that is meant to go away: fixing the leak moves the// method to READ, as a reviewed widening, rather than leaving a quiet// exposure the moment the ceiling starts serving.- RETURNS_A_STORED_SECRET = 5;+ RETURNS_A_STORED_SECRET = 13;}diff --git a/proto/v1/v1/audit_log_service.proto b/proto/v1/v1/audit_log_service.protoindex ce730e4a3e..4e3992d829 100644--- a/proto/v1/v1/audit_log_service.proto+++ b/proto/v1/v1/audit_log_service.proto@@ -31,7 +31,7 @@ service AuditLogService {option (bytebase.v1.permission) = "bb.auditLogs.search";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Exports audit logs in a specified format for external analysis.@@ -49,7 +49,7 @@ service AuditLogService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}}diff --git a/proto/v1/v1/auth_service.proto b/proto/v1/v1/auth_service.protoindex 14440c6c39..dd7f09f517 100644--- a/proto/v1/v1/auth_service.proto+++ b/proto/v1/v1/auth_service.proto@@ -41,7 +41,7 @@ service AuthService {option (bytebase.v1.allow_without_credential) = true;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = MINTS_CREDENTIAL;+ option (bytebase.v1.mcp_denial_reason) = MINTS_CREDENTIAL;}// Logs out the current user session.@@ -54,7 +54,7 @@ service AuthService {option (bytebase.v1.allow_without_credential) = true;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = ENDS_SESSION;+ option (bytebase.v1.mcp_denial_reason) = ENDS_SESSION;}// Exchanges an external OIDC token for a Bytebase access token.@@ -68,7 +68,7 @@ service AuthService {option (bytebase.v1.allow_without_credential) = true;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = MINTS_CREDENTIAL;+ option (bytebase.v1.mcp_denial_reason) = MINTS_CREDENTIAL;}// Registers a new user account. Creates a principal and assigns a workspace:@@ -83,7 +83,7 @@ service AuthService {option (bytebase.v1.allow_without_credential) = true;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = MINTS_CREDENTIAL;+ option (bytebase.v1.mcp_denial_reason) = MINTS_CREDENTIAL;}// Refreshes the access token using the refresh token cookie.@@ -95,7 +95,7 @@ service AuthService {};option (bytebase.v1.allow_without_credential) = true;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = MINTS_CREDENTIAL;+ option (bytebase.v1.mcp_denial_reason) = MINTS_CREDENTIAL;}// Switches the current user's active workspace and issues new tokens.@@ -107,7 +107,7 @@ service AuthService {};option (bytebase.v1.auth_method) = CUSTOM;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = MINTS_CREDENTIAL;+ option (bytebase.v1.mcp_denial_reason) = MINTS_CREDENTIAL;}// Requests a password reset email for the given email address.@@ -121,7 +121,7 @@ service AuthService {option (bytebase.v1.allow_without_credential) = true;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = RESETS_CREDENTIAL;+ option (bytebase.v1.mcp_denial_reason) = RESETS_CREDENTIAL;}// Resets the user's password using a password reset token from email.@@ -134,7 +134,7 @@ service AuthService {option (bytebase.v1.allow_without_credential) = true;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = RESETS_CREDENTIAL;+ option (bytebase.v1.mcp_denial_reason) = RESETS_CREDENTIAL;}// Sends a 6-digit verification code to the email for login/signup.@@ -148,7 +148,7 @@ service AuthService {option (bytebase.v1.allow_without_credential) = true;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = RESETS_CREDENTIAL;+ option (bytebase.v1.mcp_denial_reason) = RESETS_CREDENTIAL;}}diff --git a/proto/v1/v1/database_catalog_service.proto b/proto/v1/v1/database_catalog_service.protoindex d64c13f55d..313e034de1 100644--- a/proto/v1/v1/database_catalog_service.proto+++ b/proto/v1/v1/database_catalog_service.proto@@ -41,7 +41,7 @@ service DatabaseCatalogService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}}diff --git a/proto/v1/v1/group_service.proto b/proto/v1/v1/group_service.protoindex 30a917b347..4d769788c7 100644--- a/proto/v1/v1/group_service.proto+++ b/proto/v1/v1/group_service.proto@@ -24,7 +24,7 @@ service GroupService {option (bytebase.v1.permission) = "bb.groups.get";option (bytebase.v1.auth_method) = CUSTOM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Gets multiple groups in a single request.@@ -35,7 +35,7 @@ service GroupService {option (bytebase.v1.permission) = "bb.groups.get";option (bytebase.v1.auth_method) = CUSTOM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Lists all groups in the workspace.@@ -46,7 +46,7 @@ service GroupService {option (bytebase.v1.permission) = "bb.groups.list";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Creates a new group.@@ -61,7 +61,7 @@ service GroupService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Updates a group. Group owners or users with bb.groups.update permission can update.@@ -77,7 +77,7 @@ service GroupService {option (bytebase.v1.auth_method) = CUSTOM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Deletes a group. Group owners or users with bb.groups.delete permission can delete.@@ -89,7 +89,7 @@ service GroupService {option (bytebase.v1.auth_method) = CUSTOM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}}diff --git a/proto/v1/v1/idp_service.proto b/proto/v1/v1/idp_service.protoindex 7ca1fcb181..b42c1e252a 100644--- a/proto/v1/v1/idp_service.proto+++ b/proto/v1/v1/idp_service.proto@@ -23,7 +23,7 @@ service IdentityProviderService {option (bytebase.v1.permission) = "bb.identityProviders.get";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Lists all configured identity providers (public endpoint for login page).@@ -37,7 +37,7 @@ service IdentityProviderService {option (bytebase.v1.allow_without_credential) = true;// The method requires no authentication thus no authorization.option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Creates a new identity provider.@@ -52,7 +52,7 @@ service IdentityProviderService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = MINTS_CREDENTIAL_FOR_OTHERS;+ option (bytebase.v1.mcp_denial_reason) = MINTS_CREDENTIAL_FOR_OTHERS;}// Updates an identity provider.@@ -68,7 +68,7 @@ service IdentityProviderService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = MINTS_CREDENTIAL_FOR_OTHERS;+ option (bytebase.v1.mcp_denial_reason) = MINTS_CREDENTIAL_FOR_OTHERS;}// Deletes an identity provider.@@ -80,7 +80,7 @@ service IdentityProviderService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Tests the connection and configuration of an identity provider.@@ -93,7 +93,7 @@ service IdentityProviderService {option (bytebase.v1.permission) = "bb.identityProviders.update";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = MINTS_CREDENTIAL_FOR_OTHERS;+ option (bytebase.v1.mcp_denial_reason) = MINTS_CREDENTIAL_FOR_OTHERS;}}diff --git a/proto/v1/v1/instance_role_service.proto b/proto/v1/v1/instance_role_service.protoindex 47cf564f75..9b6f3a68e4 100644--- a/proto/v1/v1/instance_role_service.proto+++ b/proto/v1/v1/instance_role_service.proto@@ -23,7 +23,7 @@ service InstanceRoleService {option (bytebase.v1.permission) = "bb.instanceRoles.list";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = RETURNS_A_STORED_SECRET;+ option (bytebase.v1.mcp_denial_reason) = RETURNS_A_STORED_SECRET;}}diff --git a/proto/v1/v1/instance_service.proto b/proto/v1/v1/instance_service.protoindex f43e204c1f..de80c8abc1 100644--- a/proto/v1/v1/instance_service.proto+++ b/proto/v1/v1/instance_service.proto@@ -30,7 +30,7 @@ service InstanceService {option (bytebase.v1.permission) = "bb.instances.get";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = RETURNS_A_STORED_SECRET;+ option (bytebase.v1.mcp_denial_reason) = RETURNS_A_STORED_SECRET;}// Lists database instances, optionally within a project.@@ -44,7 +44,7 @@ service InstanceService {option (bytebase.v1.permission) = "bb.instances.list";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = RETURNS_A_STORED_SECRET;+ option (bytebase.v1.mcp_denial_reason) = RETURNS_A_STORED_SECRET;}// Creates a new database instance.@@ -63,7 +63,7 @@ service InstanceService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Updates a database instance.@@ -82,7 +82,7 @@ service InstanceService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Deletes or soft-deletes a database instance.@@ -99,7 +99,7 @@ service InstanceService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Restores a soft-deleted database instance.@@ -119,7 +119,7 @@ service InstanceService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Syncs database schemas and metadata from an instance.@@ -152,7 +152,7 @@ service InstanceService {option (bytebase.v1.permission) = "bb.instances.get";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Syncs multiple instances in a single request.@@ -186,7 +186,7 @@ service InstanceService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Adds a read-only data source to an instance.@@ -204,7 +204,7 @@ service InstanceService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Removes a read-only data source from an instance.@@ -222,7 +222,7 @@ service InstanceService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Updates a data source configuration.@@ -241,7 +241,7 @@ service InstanceService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = MINTS_CREDENTIAL_FOR_OTHERS;+ option (bytebase.v1.mcp_denial_reason) = MINTS_CREDENTIAL_FOR_OTHERS;}}diff --git a/proto/v1/v1/issue_service.proto b/proto/v1/v1/issue_service.protoindex 0000f27014..76c717ee6f 100644--- a/proto/v1/v1/issue_service.proto+++ b/proto/v1/v1/issue_service.proto@@ -42,15 +42,20 @@ service IssueService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;// WRITE covers the DATABASE_CHANGE issue this method exists for. It does- // not cover the other two types, which complete on creation whenever the- // workspace rule produces no approval template, each reaching past a- // method that is EXCLUDED for exactly that outcome: ROLE_GRANT writes the- // project IAM binding for a grantee the request names, which is- // ProjectService/SetIamPolicy; ACCESS_GRANT sets the grant ACTIVE, which- // is AccessGrantService/ActivateAccessGrant. A class annotation cannot- // split by request field, so the ceiling PR owes a carve-out refusing- // those two types on the MCP path. UpdateIssue reaches the same completion- // through allow_missing and carries the same debt.+ // not cover a ROLE_GRANT issue, which completes on creation whenever the+ // workspace rule produces no approval template and then writes the project+ // IAM binding for a grantee the request names — which is+ // ProjectService/SetIamPolicy, EXCLUDED for exactly that outcome. A class+ // annotation cannot split by request field, so the MCP gate carries a+ // request-shape refusal for this method: it admits DATABASE_CHANGE and+ // refuses every other type (backend/api/v1/mcp_gate.go,+ // mcpRequestShapeRefusals). UpdateIssue reaches the same creation through+ // allow_missing and is refused with it.+ //+ // An ACCESS_GRANT issue is refused by the same allow-list and does not+ // reach this handler in the first place: buildIssueMessage has no arm for+ // it, so the type is an invalid argument here. Those issues are written by+ // AccessGrantService/CreateAccessGrant, which is EXCLUDED.option (bytebase.v1.mcp_method_class) = WRITE;}@@ -87,6 +92,12 @@ service IssueService {option (bytebase.v1.permission) = "bb.issues.update";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;+ // WRITE, and editing an issue is an agent's job — including an edit that+ // resets approval finding and sends the issue back for review. What this+ // does not cover is creation: with allow_missing set on an issue that does+ // not exist, the handler calls CreateIssue with the request's own issue, so+ // the MCP gate applies CreateIssue's request-shape refusal here too+ // whenever allow_missing is set.option (bytebase.v1.mcp_method_class) = WRITE;}@@ -151,7 +162,7 @@ service IssueService {option (bytebase.v1.auth_method) = CUSTOM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = DRIVES_THE_APPROVAL_DECISION;+ option (bytebase.v1.mcp_denial_reason) = DRIVES_THE_APPROVAL_DECISION;}// Rejects an issue. Access determined by approval flow configuration - caller must be a designated approver for the current approval step.@@ -164,7 +175,7 @@ service IssueService {option (bytebase.v1.auth_method) = CUSTOM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = DRIVES_THE_APPROVAL_DECISION;+ option (bytebase.v1.mcp_denial_reason) = DRIVES_THE_APPROVAL_DECISION;}// Requests changes on an issue. Access determined by approval flow configuration - caller must be a designated approver for the current approval step.@@ -210,7 +221,7 @@ service IssueService {option (bytebase.v1.auth_method) = CUSTOM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = DRIVES_THE_APPROVAL_DECISION;+ option (bytebase.v1.mcp_denial_reason) = DRIVES_THE_APPROVAL_DECISION;}}diff --git a/proto/v1/v1/org_policy_service.proto b/proto/v1/v1/org_policy_service.protoindex 8247eaf6dd..33c27f2905 100644--- a/proto/v1/v1/org_policy_service.proto+++ b/proto/v1/v1/org_policy_service.proto@@ -28,7 +28,7 @@ service OrgPolicyService {option (bytebase.v1.permission) = "bb.policies.get";option (bytebase.v1.auth_method) = CUSTOM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Lists policies at a specified resource level.@@ -44,7 +44,7 @@ service OrgPolicyService {option (bytebase.v1.permission) = "bb.policies.list";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Creates a new organizational policy.@@ -68,7 +68,7 @@ service OrgPolicyService {option (bytebase.v1.auth_method) = CUSTOM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Updates an existing organizational policy.@@ -92,7 +92,7 @@ service OrgPolicyService {option (bytebase.v1.auth_method) = CUSTOM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Deletes an organizational policy.@@ -109,7 +109,7 @@ service OrgPolicyService {option (bytebase.v1.auth_method) = CUSTOM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}}diff --git a/proto/v1/v1/project_service.proto b/proto/v1/v1/project_service.protoindex 5ce68a0420..d87f6649e6 100644--- a/proto/v1/v1/project_service.proto+++ b/proto/v1/v1/project_service.proto@@ -27,7 +27,7 @@ service ProjectService {option (bytebase.v1.permission) = "bb.projects.get";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = RETURNS_A_STORED_SECRET;+ option (bytebase.v1.mcp_denial_reason) = RETURNS_A_STORED_SECRET;}// BatchGetProjects retrieves multiple projects by their names.@@ -37,7 +37,7 @@ service ProjectService {option (bytebase.v1.permission) = "bb.projects.get";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = RETURNS_A_STORED_SECRET;+ option (bytebase.v1.mcp_denial_reason) = RETURNS_A_STORED_SECRET;}// Lists all projects in the workspace with optional filtering.@@ -48,7 +48,7 @@ service ProjectService {option (bytebase.v1.permission) = "bb.projects.list";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = RETURNS_A_STORED_SECRET;+ option (bytebase.v1.mcp_denial_reason) = RETURNS_A_STORED_SECRET;}// Searches for projects with advanced filtering capabilities.@@ -62,7 +62,7 @@ service ProjectService {option (bytebase.v1.auth_method) = CUSTOM;// TODO(d): secure it.option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = RETURNS_A_STORED_SECRET;+ option (bytebase.v1.mcp_denial_reason) = RETURNS_A_STORED_SECRET;}// Creates a new project in the workspace.@@ -77,7 +77,7 @@ service ProjectService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Updates an existing project's properties.@@ -92,7 +92,7 @@ service ProjectService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Deletes (soft-delete or purge) a project.@@ -104,7 +104,7 @@ service ProjectService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Restores a soft-deleted project.@@ -118,7 +118,7 @@ service ProjectService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Deletes multiple projects in a single operation.@@ -132,7 +132,7 @@ service ProjectService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Retrieves the IAM policy for a project.@@ -142,7 +142,7 @@ service ProjectService {option (bytebase.v1.permission) = "bb.projects.getIamPolicy";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Sets the IAM policy for a project.@@ -156,7 +156,7 @@ service ProjectService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Adds a webhook to a project for notifications.@@ -170,7 +170,7 @@ service ProjectService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Updates an existing webhook configuration.@@ -185,7 +185,7 @@ service ProjectService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Removes a webhook from a project.@@ -199,7 +199,7 @@ service ProjectService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Tests a webhook by sending a test notification.@@ -212,7 +212,7 @@ service ProjectService {option (bytebase.v1.permission) = "bb.projects.update";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = SENDS_DATA_TO_A_THIRD_PARTY;+ option (bytebase.v1.mcp_denial_reason) = SENDS_DATA_TO_A_THIRD_PARTY;}}diff --git a/proto/v1/v1/query_history_service.proto b/proto/v1/v1/query_history_service.protoindex 42caeab695..850b47cfd5 100644--- a/proto/v1/v1/query_history_service.proto+++ b/proto/v1/v1/query_history_service.proto@@ -35,7 +35,7 @@ service QueryHistoryService {option (bytebase.v1.permission) = "bb.queryHistories.list";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = READS_OTHER_USERS_SQL;+ option (bytebase.v1.mcp_denial_reason) = READS_OTHER_USERS_SQL;}// GetQueryHistory gets a single query history for the caller.diff --git a/proto/v1/v1/review_config_service.proto b/proto/v1/v1/review_config_service.protoindex 3c74f4c7b5..b15288ed19 100644--- a/proto/v1/v1/review_config_service.proto+++ b/proto/v1/v1/review_config_service.proto@@ -28,7 +28,7 @@ service ReviewConfigService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Lists all SQL review configurations.@@ -64,7 +64,7 @@ service ReviewConfigService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Deletes a SQL review configuration.@@ -76,7 +76,7 @@ service ReviewConfigService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}}diff --git a/proto/v1/v1/role_service.proto b/proto/v1/v1/role_service.protoindex f09f367a4a..50f877997c 100644--- a/proto/v1/v1/role_service.proto+++ b/proto/v1/v1/role_service.proto@@ -22,7 +22,7 @@ service RoleService {option (bytebase.v1.permission) = "bb.roles.list";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Retrieves a role by name.@@ -33,7 +33,7 @@ service RoleService {option (bytebase.v1.permission) = "bb.roles.get";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Creates a new custom role.@@ -47,7 +47,7 @@ service RoleService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Updates a role's properties.@@ -63,7 +63,7 @@ service RoleService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Deletes a custom role.@@ -75,7 +75,7 @@ service RoleService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}}diff --git a/proto/v1/v1/rollout_service.proto b/proto/v1/v1/rollout_service.protoindex ff35c24b19..750e1c2291 100644--- a/proto/v1/v1/rollout_service.proto+++ b/proto/v1/v1/rollout_service.proto@@ -51,14 +51,18 @@ service RolloutService {// only one of them is fixable at the MCP layer. Both are stated here// because the gate PR is the reader who needs them.//- // 1. The gate PR OWES A RULE. Both approval checks on this path are+ // 1. DELIVERED by the gate PR (1b-2), as rejectMCPOriginatedIssuelessRollout+ // in rollout_service.go, on CreateRollout and BatchRunTasks both.+ // Both approval checks on this path are// guarded on a LINKED ISSUE existing (rollout_service.go, and the// locked re-check in component/review/rollout.go), so a plan created// without one reaches task creation with no approval whatever// require_issue_approval says. The rule to implement: on the MCP path,// refuse CreateRollout and BatchRunTasks when the project sets// require_issue_approval and the plan has no linked approved issue.- // Not because the behavior is a defect — the shipped GitOps Service+ // It keys on the delegated grant, so the console and the GitOps agent+ // are unaffected, and it bites on CreateRollout first per the ordering+ // trap below. Not because the behavior is a defect — the shipped GitOps Service// Agent role holds no issue permission at all, so issueless deployment// is a supported product contract, and READ_WRITE preserves supported// contracts. Because without the rule the four FORBIDDEN approval@@ -123,7 +127,7 @@ service RolloutService {option (bytebase.v1.permission) = "bb.taskRuns.list";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = OPENS_AN_ADMIN_CONNECTION;+ option (bytebase.v1.mcp_denial_reason) = OPENS_AN_ADMIN_CONNECTION;}// Executes multiple tasks in a rollout stage.@@ -138,9 +142,10 @@ service RolloutService {option (bytebase.v1.audit) = true;// WRITE, and the same two cases as CreateRollout reach it — this is the// method that actually starts execution. Its approval check carries the- // identical linked-issue guard, so the rule the gate PR owes covers this- // method too; and it runs whatever tasks the live group resolution- // produced, which no MCP rule can constrain. Both stated on CreateRollout.+ // identical linked-issue guard, so 1b-2's rule covers this method too+ // (rejectMCPOriginatedIssuelessRollout, rollout_service.go); and it runs+ // whatever tasks the live group resolution produced, which no MCP rule can+ // constrain. Both stated on CreateRollout.option (bytebase.v1.mcp_method_class) = WRITE;}diff --git a/proto/v1/v1/saved_query_service.proto b/proto/v1/v1/saved_query_service.protoindex 92d8dc0f5e..dc62816eac 100644--- a/proto/v1/v1/saved_query_service.proto+++ b/proto/v1/v1/saved_query_service.proto@@ -64,7 +64,7 @@ service SavedQueryService {option (bytebase.v1.permission) = "bb.savedQueries.list";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = READS_OTHER_USERS_SQL;+ option (bytebase.v1.mcp_denial_reason) = READS_OTHER_USERS_SQL;}// Search saved queries in one project. Returns content previews of the@@ -160,7 +160,7 @@ service SavedQueryService {option (google.api.method_signature) = "resource";option (bytebase.v1.auth_method) = CUSTOM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Replace a saved query's sharing policy in full. `policy.etag` must match@@ -176,7 +176,7 @@ service SavedQueryService {option (bytebase.v1.auth_method) = CUSTOM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}}diff --git a/proto/v1/v1/service_account_service.proto b/proto/v1/v1/service_account_service.protoindex 4a5f2ab5de..85e78bc798 100644--- a/proto/v1/v1/service_account_service.proto+++ b/proto/v1/v1/service_account_service.proto@@ -34,7 +34,7 @@ service ServiceAccountService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = MINTS_CREDENTIAL_FOR_OTHERS;+ option (bytebase.v1.mcp_denial_reason) = MINTS_CREDENTIAL_FOR_OTHERS;}// Gets a service account by name.@@ -45,7 +45,7 @@ service ServiceAccountService {option (bytebase.v1.permission) = "bb.serviceAccounts.get";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Lists service accounts.@@ -60,7 +60,7 @@ service ServiceAccountService {option (bytebase.v1.permission) = "bb.serviceAccounts.list";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Updates a service account.@@ -75,7 +75,7 @@ service ServiceAccountService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = MINTS_CREDENTIAL_FOR_OTHERS;+ option (bytebase.v1.mcp_denial_reason) = MINTS_CREDENTIAL_FOR_OTHERS;}// Deletes a service account.@@ -87,7 +87,7 @@ service ServiceAccountService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Restores a deleted service account.@@ -101,7 +101,7 @@ service ServiceAccountService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}}diff --git a/proto/v1/v1/setting_service.proto b/proto/v1/v1/setting_service.protoindex f95e01587e..41e31ab8b6 100644--- a/proto/v1/v1/setting_service.proto+++ b/proto/v1/v1/setting_service.proto@@ -26,7 +26,7 @@ service SettingService {option (bytebase.v1.permission) = "bb.settings.list";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Retrieves a workspace setting by name.@@ -37,7 +37,7 @@ service SettingService {option (bytebase.v1.permission) = "bb.settings.get";option (bytebase.v1.auth_method) = CUSTOM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Updates a workspace setting.@@ -51,7 +51,7 @@ service SettingService {option (bytebase.v1.auth_method) = CUSTOM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = REWRITES_SESSION_BOUNDARY;+ option (bytebase.v1.mcp_denial_reason) = REWRITES_SESSION_BOUNDARY;}// Sends a test email using the provided config (without persisting).@@ -64,7 +64,7 @@ service SettingService {option (bytebase.v1.permission) = "bb.settings.set";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = MINTS_CREDENTIAL_FOR_OTHERS;+ option (bytebase.v1.mcp_denial_reason) = MINTS_CREDENTIAL_FOR_OTHERS;}}diff --git a/proto/v1/v1/sql_service.proto b/proto/v1/v1/sql_service.protoindex dd5ec77808..17f40d230b 100644--- a/proto/v1/v1/sql_service.proto+++ b/proto/v1/v1/sql_service.proto@@ -45,7 +45,7 @@ service SQLService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = OPENS_AN_ADMIN_CONNECTION;+ option (bytebase.v1.mcp_denial_reason) = OPENS_AN_ADMIN_CONNECTION;}// Deprecated: use QueryHistoryService.SearchQueryHistories instead.@@ -67,7 +67,7 @@ service SQLService {option (bytebase.v1.permission) = "bb.queryHistories.list";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = READS_OTHER_USERS_SQL;+ option (bytebase.v1.mcp_denial_reason) = READS_OTHER_USERS_SQL;}// Deprecated: use QueryHistoryService.GetQueryHistory instead.diff --git a/proto/v1/v1/subscription_service.proto b/proto/v1/v1/subscription_service.protoindex 1c4b86dcd9..c62a37267a 100644--- a/proto/v1/v1/subscription_service.proto+++ b/proto/v1/v1/subscription_service.proto@@ -19,7 +19,7 @@ service SubscriptionService {option (google.api.http) = {get: "/v1/subscription"};option (google.api.method_signature) = "";option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Exports active VCS users as CSV.@@ -29,7 +29,7 @@ service SubscriptionService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Uploads an enterprise license (self-hosted only).@@ -42,7 +42,7 @@ service SubscriptionService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// CreatePurchase creates a new subscription purchase (SaaS only).@@ -56,7 +56,7 @@ service SubscriptionService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// UpdatePurchase updates an existing subscription (SaaS only).@@ -70,7 +70,7 @@ service SubscriptionService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// CancelPurchase cancels an active subscription (SaaS only).@@ -83,7 +83,7 @@ service SubscriptionService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// GetPaymentInfo returns payment details for the current subscription (SaaS only).@@ -92,7 +92,7 @@ service SubscriptionService {option (bytebase.v1.permission) = "bb.subscription.manage";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// VerifyCheckoutSession verifies a Stripe Checkout Session status (SaaS only).@@ -101,14 +101,14 @@ service SubscriptionService {option (bytebase.v1.permission) = "bb.subscription.manage";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// ListPurchasePlans returns available plans for self-service purchase.rpc ListPurchasePlans(ListPurchasePlansRequest) returns (ListPurchasePlansResponse) {option (google.api.http) = {get: "/v1/subscription/plans"};option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}}diff --git a/proto/v1/v1/user_service.proto b/proto/v1/v1/user_service.protoindex 3165aacdab..8d33c5223e 100644--- a/proto/v1/v1/user_service.proto+++ b/proto/v1/v1/user_service.proto@@ -26,7 +26,7 @@ service UserService {option (bytebase.v1.permission) = "bb.users.get";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Get the users in batch.@@ -37,7 +37,7 @@ service UserService {option (bytebase.v1.permission) = "bb.users.get";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Get the current authenticated user.@@ -47,7 +47,7 @@ service UserService {option (bytebase.v1.allow_without_credential) = true;option (bytebase.v1.auth_method) = CUSTOM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = RETURNS_A_STORED_SECRET;+ option (bytebase.v1.mcp_denial_reason) = RETURNS_A_STORED_SECRET;}// List all users.@@ -59,7 +59,7 @@ service UserService {option (bytebase.v1.permission) = "bb.users.list";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Creates a user in the caller's workspace (admin action, self-hosted only).@@ -75,7 +75,7 @@ service UserService {option (bytebase.v1.permission) = "bb.users.create";option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = MINTS_CREDENTIAL_FOR_OTHERS;+ option (bytebase.v1.mcp_denial_reason) = MINTS_CREDENTIAL_FOR_OTHERS;}// Updates a user. Users can update their own profile, or users with bb.users.update permission can update any user.@@ -90,7 +90,7 @@ service UserService {option (bytebase.v1.auth_method) = CUSTOM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = TAKES_OVER_ACCOUNT;+ option (bytebase.v1.mcp_denial_reason) = TAKES_OVER_ACCOUNT;}// Deletes a user. Requires bb.users.delete permission with additional validation: the last remaining workspace admin cannot be deleted.@@ -101,7 +101,7 @@ service UserService {option (bytebase.v1.auth_method) = CUSTOM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Restores a deleted user.@@ -114,7 +114,7 @@ service UserService {option (bytebase.v1.auth_method) = CUSTOM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Updates a user's email address.@@ -129,7 +129,7 @@ service UserService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = MINTS_CREDENTIAL_FOR_OTHERS;+ option (bytebase.v1.mcp_denial_reason) = MINTS_CREDENTIAL_FOR_OTHERS;}}diff --git a/proto/v1/v1/workload_identity_service.proto b/proto/v1/v1/workload_identity_service.protoindex 47c02bc3f7..81c897adc9 100644--- a/proto/v1/v1/workload_identity_service.proto+++ b/proto/v1/v1/workload_identity_service.proto@@ -34,7 +34,7 @@ service WorkloadIdentityService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = MINTS_CREDENTIAL_FOR_OTHERS;+ option (bytebase.v1.mcp_denial_reason) = MINTS_CREDENTIAL_FOR_OTHERS;}// Gets a workload identity by name.@@ -45,7 +45,7 @@ service WorkloadIdentityService {option (bytebase.v1.permission) = "bb.workloadIdentities.get";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Lists workload identities.@@ -60,7 +60,7 @@ service WorkloadIdentityService {option (bytebase.v1.permission) = "bb.workloadIdentities.list";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Updates a workload identity.@@ -75,7 +75,7 @@ service WorkloadIdentityService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = MINTS_CREDENTIAL_FOR_OTHERS;+ option (bytebase.v1.mcp_denial_reason) = MINTS_CREDENTIAL_FOR_OTHERS;}// Deletes a workload identity.@@ -87,7 +87,7 @@ service WorkloadIdentityService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Restores a deleted workload identity.@@ -101,7 +101,7 @@ service WorkloadIdentityService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}}diff --git a/proto/v1/v1/workspace_service.proto b/proto/v1/v1/workspace_service.protoindex 7bb8430f3f..26a6bfecba 100644--- a/proto/v1/v1/workspace_service.proto+++ b/proto/v1/v1/workspace_service.proto@@ -43,7 +43,7 @@ service WorkspaceService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Retrieves IAM policy for the workspace.@@ -53,7 +53,7 @@ service WorkspaceService {option (bytebase.v1.permission) = "bb.workspaces.getIamPolicy";option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Deletes a workspace. SaaS only. Cancels any active subscription and@@ -65,7 +65,7 @@ service WorkspaceService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = ENDS_MEMBERSHIP;+ option (bytebase.v1.mcp_denial_reason) = ENDS_MEMBERSHIP;}// Removes the calling user from a workspace and switches to the next@@ -79,7 +79,7 @@ service WorkspaceService {option (bytebase.v1.auth_method) = CUSTOM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = ENDS_MEMBERSHIP;+ option (bytebase.v1.mcp_denial_reason) = ENDS_MEMBERSHIP;}// Sets IAM policy for the workspace.@@ -93,7 +93,7 @@ service WorkspaceService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = EXCLUDED;- option (bytebase.v1.mcp_exclusion_reason) = ADMINISTERS_THE_WORKSPACE;+ option (bytebase.v1.mcp_denial_reason) = ADMINISTERS_THE_WORKSPACE;}// Mints a new directory sync (SCIM) token, immediately invalidating the@@ -111,7 +111,7 @@ service WorkspaceService {option (bytebase.v1.auth_method) = IAM;option (bytebase.v1.audit) = true;option (bytebase.v1.mcp_method_class) = FORBIDDEN;- option (bytebase.v1.mcp_forbidden_reason) = MINTS_CREDENTIAL_FOR_OTHERS;+ option (bytebase.v1.mcp_denial_reason) = MINTS_CREDENTIAL_FOR_OTHERS;}}