Skip to content

AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.

fix(backend): authorize team management by target team id, drop active-team requirement (#13524)

Nicholas Tindlef1a1607e67bf
diff --git a/autogpt_platform/backend/backend/api/features/orgs/regression_test.py b/autogpt_platform/backend/backend/api/features/orgs/regression_test.py
index 0f7add7e5b..d899f93f44 100644
--- a/autogpt_platform/backend/backend/api/features/orgs/regression_test.py
+++ b/autogpt_platform/backend/backend/api/features/orgs/regression_test.py
@@ -13,6 +13,7 @@ from datetime import datetime, timezone
from unittest.mock import AsyncMock, MagicMock, patch
import pytest
+from autogpt_libs.auth.models import RequestContext
from fastapi import HTTPException
# ---------------------------------------------------------------------------
@@ -3218,11 +3219,19 @@ class TestReviewFindings:
return m
def _owner_ctx(self, org_id="org-review-1", team_id="team-review-1"):
- ctx = MagicMock()
- ctx.user_id = USER_ID
- ctx.org_id = org_id
- ctx.team_id = team_id
- return ctx
+ # A MagicMock grants every permission: check_org_permission reads
+ # ctx.is_org_owner etc., and an auto-created attribute is truthy.
+ return RequestContext(
+ user_id=USER_ID,
+ org_id=org_id,
+ team_id=team_id,
+ is_org_owner=True,
+ is_org_admin=False,
+ is_org_billing_manager=False,
+ is_team_admin=False,
+ is_team_billing_manager=False,
+ seat_status="ACTIVE",
+ )
def _make_invitation(self, **overrides):
m = MagicMock()
@@ -3369,30 +3378,41 @@ class TestReviewFindings:
assert exc_info.value.status_code == 403
# ------------------------------------------------------------------
- # 6. update_team ctx.team_id / ws_id mismatch
+ # 6. update_team authorizes by target team, not active team (SECRT-2453)
# ------------------------------------------------------------------
@pytest.mark.asyncio
- async def test_update_team_rejects_mismatched_team_id(self):
- """PATCH /teams/{ws_id} should reject when ctx.team_id != ws_id."""
+ async def test_update_team_authorizes_by_target_not_active_team(self):
+ """PATCH /teams/{ws_id} authorizes against the target team from the
+ URL, independent of the caller's active team. An org admin
+ (MANAGE_WORKSPACES) may update a team even when ctx.team_id differs."""
from backend.api.features.orgs.team_model import UpdateTeamRequest
from backend.api.features.orgs.team_routes import update_team
+ # Active team is team-1; the target is a different team in the same org.
ctx = self._owner_ctx(org_id="org-review-1", team_id="team-1")
- # Mock the team_db.get_team call that validates org ownership
- with patch(
- "backend.api.features.orgs.team_routes.team_db.get_team",
- new_callable=AsyncMock,
+ updated = MagicMock()
+ with (
+ patch(
+ "backend.api.features.orgs.team_routes.team_db.get_team",
+ new_callable=AsyncMock,
+ ),
+ patch(
+ "backend.api.features.orgs.team_routes.team_db.update_team",
+ new_callable=AsyncMock,
+ return_value=updated,
+ ) as mock_update,
):
- with pytest.raises(HTTPException) as exc_info:
- await update_team(
- org_id="org-review-1",
- ws_id="team-2", # different from ctx.team_id
- request=UpdateTeamRequest(name="Hacked"),
- ctx=ctx,
- )
- assert exc_info.value.status_code == 403
+ result = await update_team(
+ org_id="org-review-1",
+ ws_id="team-2", # different from ctx.team_id
+ request=UpdateTeamRequest(name="Renamed"),
+ ctx=ctx,
+ )
+
+ assert result is updated
+ mock_update.assert_awaited_once()
# ------------------------------------------------------------------
# 7. reject_transfer has no org membership check
diff --git a/autogpt_platform/backend/backend/api/features/orgs/routes_test.py b/autogpt_platform/backend/backend/api/features/orgs/routes_test.py
index 352e06c37b..f5eaafa911 100644
--- a/autogpt_platform/backend/backend/api/features/orgs/routes_test.py
+++ b/autogpt_platform/backend/backend/api/features/orgs/routes_test.py
@@ -2924,6 +2924,414 @@ class TestPersonalOrgBootstrapOnDemand:
self.create_org.assert_not_called()
+# ═══════════════════════════════════════════════════════════════════════════════
+# SECRT-2453: Manage teams by target ws_id, independent of active-team header
+# ═══════════════════════════════════════════════════════════════════════════════
+
+
+def _mgmt_ctx(
+ *,
+ user_id=USER_ID,
+ org_id=ORG_ID,
+ team_id=None,
+ org_owner=False,
+ org_admin=False,
+ team_admin=False,
+) -> RequestContext:
+ return RequestContext(
+ user_id=user_id,
+ org_id=org_id,
+ team_id=team_id,
+ is_org_owner=org_owner,
+ is_org_admin=org_admin,
+ is_org_billing_manager=False,
+ is_team_admin=team_admin,
+ is_team_billing_manager=False,
+ seat_status="ACTIVE",
+ )
+
+
+class TestTeamManagementByTeamId:
+ """Mutating team routes authorize against the target team in the URL path.
+
+ Allowed for an admin of that team OR an org admin (MANAGE_WORKSPACES),
+ regardless of the caller's active-team (X-Team-Id) context. Exercises the
+ real ``_authorize_team_management`` helper against a mocked Prisma boundary.
+ """
+
+ @pytest.fixture(autouse=True)
+ def _mock_prisma(self, mocker):
+ self.prisma = MagicMock()
+ mocker.patch("backend.api.features.orgs.team_db.prisma", self.prisma)
+
+ @pytest.fixture
+ def _app_and_client(self):
+ from fastapi.responses import JSONResponse
+
+ from backend.api.features.orgs.team_routes import router
+
+ app = fastapi.FastAPI()
+ app.include_router(router, prefix="/api/orgs/{org_id}/workspaces")
+
+ # Mirror the production mapping of NotFoundError -> 404 (registered on
+ # the real app in rest_api.py) so cross-org lookups surface as 404.
+ async def _not_found(request, exc):
+ return JSONResponse(status_code=404, content={"detail": str(exc)})
+
+ app.add_exception_handler(NotFoundError, _not_found)
+ self.app = app
+ client = fastapi.testclient.TestClient(app)
+ yield app, client
+ app.dependency_overrides.clear()
+
+ def _use_ctx(self, ctx: RequestContext):
+ from autogpt_libs.auth import get_request_context
+
+ self.app.dependency_overrides[get_request_context] = lambda: ctx
+
+ # --- team settings update (PATCH /{ws_id}) ------------------------------
+
+ def test_team_admin_updates_settings_without_active_team_context(
+ self, _app_and_client
+ ):
+ _, client = _app_and_client
+ self.prisma.team.find_unique = AsyncMock(
+ return_value=_make_workspace(id=WS_ID, isDefault=False)
+ )
+ self.prisma.teammember.find_unique = AsyncMock(
+ return_value=_make_ws_member(
+ workspaceId=WS_ID, userId=USER_ID, isAdmin=True
+ )
+ )
+ self.prisma.team.update = AsyncMock()
+ # No active team: team_id is None (no X-Team-Id header).
+ self._use_ctx(_mgmt_ctx(user_id=USER_ID, team_id=None, team_admin=False))
+
+ resp = client.patch(
+ f"/api/orgs/{ORG_ID}/workspaces/{WS_ID}", json={"name": "Renamed"}
+ )
+
+ assert resp.status_code == 200
+ self.prisma.team.update.assert_awaited_once()
+ # The admin lookup must target the URL's ws_id, not the caller's
+ # (absent) active team.
+ self.prisma.teammember.find_unique.assert_awaited_with(
+ where={"teamId_userId": {"teamId": WS_ID, "userId": USER_ID}}
+ )
+
+ def test_org_admin_updates_team_they_do_not_belong_to(self, _app_and_client):
+ _, client = _app_and_client
+ self.prisma.team.find_unique = AsyncMock(
+ return_value=_make_workspace(id=WS_ID, isDefault=False)
+ )
+ # Org admin is not a member of the target team.
+ self.prisma.teammember.find_unique = AsyncMock(return_value=None)
+ self.prisma.team.update = AsyncMock()
+ self._use_ctx(_mgmt_ctx(user_id=USER_ID, org_admin=True))
+
+ resp = client.patch(
+ f"/api/orgs/{ORG_ID}/workspaces/{WS_ID}", json={"name": "Renamed"}
+ )
+
+ assert resp.status_code == 200
+ self.prisma.team.update.assert_awaited_once()
+ # Org permission short-circuits before the team-admin lookup.
+ self.prisma.teammember.find_unique.assert_not_awaited()
+
+ def test_plain_org_member_cannot_update_team(self, _app_and_client):
+ _, client = _app_and_client
+ self.prisma.team.find_unique = AsyncMock(
+ return_value=_make_workspace(id=WS_ID, isDefault=False)
+ )
+ self.prisma.teammember.find_unique = AsyncMock(return_value=None)
+ self.prisma.team.update = AsyncMock()
+ self._use_ctx(_mgmt_ctx(user_id=OTHER_USER_ID))
+
+ resp = client.patch(
+ f"/api/orgs/{ORG_ID}/workspaces/{WS_ID}", json={"name": "Renamed"}
+ )
+
+ assert resp.status_code == 403
+ self.prisma.team.update.assert_not_awaited()
+
+ def test_admin_of_different_team_cannot_update_target(self, _app_and_client):
+ _, client = _app_and_client
+ self.prisma.team.find_unique = AsyncMock(
+ return_value=_make_workspace(id=WS_ID, isDefault=False)
+ )
+ # No admin row for the *target* team, even though the caller's active
+ # team ("ws-other") has them as admin.
+ self.prisma.teammember.find_unique = AsyncMock(return_value=None)
+ self.prisma.team.update = AsyncMock()
+ self._use_ctx(
+ _mgmt_ctx(user_id=OTHER_USER_ID, team_id="ws-other", team_admin=True)
+ )
+
+ resp = client.patch(
+ f"/api/orgs/{ORG_ID}/workspaces/{WS_ID}", json={"name": "Renamed"}
+ )
+
+ assert resp.status_code == 403
+ self.prisma.team.update.assert_not_awaited()
+ self.prisma.teammember.find_unique.assert_awaited_with(
+ where={"teamId_userId": {"teamId": WS_ID, "userId": OTHER_USER_ID}}
+ )
+
+ # --- member role update (PATCH /{ws_id}/members/{uid}) ------------------
+
+ def _stub_member_update(self):
+ self.prisma.team.find_unique = AsyncMock(
+ return_value=_make_workspace(id=WS_ID, isDefault=False)
+ )
+ self.prisma.teammember.update = AsyncMock()
+ self.prisma.teammember.find_many = AsyncMock(
+ return_value=[_make_ws_member(workspaceId=WS_ID, userId=OTHER_USER_ID)]
+ )
+
+ def test_team_admin_updates_member_without_active_team_context(
+ self, _app_and_client
+ ):
+ _, client = _app_and_client
+ self._stub_member_update()
+ self.prisma.teammember.find_unique = AsyncMock(
+ return_value=_make_ws_member(
+ workspaceId=WS_ID, userId=USER_ID, isAdmin=True
+ )
+ )
+ self._use_ctx(_mgmt_ctx(user_id=USER_ID, team_id=None))
+
+ resp = client.patch(
+ f"/api/orgs/{ORG_ID}/workspaces/{WS_ID}/members/{OTHER_USER_ID}",
+ json={"is_admin": True},
+ )
+
+ assert resp.status_code == 200
+ self.prisma.teammember.update.assert_awaited_once()
+
+ def test_org_admin_updates_member_of_team_they_do_not_belong_to(
+ self, _app_and_client
+ ):
+ _, client = _app_and_client
+ self._stub_member_update()
+ self.prisma.teammember.find_unique = AsyncMock(return_value=None)
+ self._use_ctx(_mgmt_ctx(user_id=USER_ID, org_admin=True))
+
+ resp = client.patch(
+ f"/api/orgs/{ORG_ID}/workspaces/{WS_ID}/members/{OTHER_USER_ID}",
+ json={"is_admin": True},
+ )
+
+ assert resp.status_code == 200
+ self.prisma.teammember.update.assert_awaited_once()
+ self.prisma.teammember.find_unique.assert_not_awaited()
+
+ def test_plain_org_member_cannot_update_member(self, _app_and_client):
+ _, client = _app_and_client
+ self._stub_member_update()
+ self.prisma.teammember.find_unique = AsyncMock(return_value=None)
+ self._use_ctx(_mgmt_ctx(user_id=OTHER_USER_ID))
+
+ resp = client.patch(
+ f"/api/orgs/{ORG_ID}/workspaces/{WS_ID}/members/{OTHER_USER_ID}",
+ json={"is_admin": True},
+ )
+
+ assert resp.status_code == 403
+ self.prisma.teammember.update.assert_not_awaited()
+
+ def test_admin_of_different_team_cannot_update_member(self, _app_and_client):
+ _, client = _app_and_client
+ self._stub_member_update()
+ self.prisma.teammember.find_unique = AsyncMock(return_value=None)
+ self._use_ctx(
+ _mgmt_ctx(user_id=OTHER_USER_ID, team_id="ws-other", team_admin=True)
+ )
+
+ resp = client.patch(
+ f"/api/orgs/{ORG_ID}/workspaces/{WS_ID}/members/{OTHER_USER_ID}",
+ json={"is_admin": True},
+ )
+
+ assert resp.status_code == 403
+ self.prisma.teammember.update.assert_not_awaited()
+
+ # --- member add (POST /{ws_id}/members) ---------------------------------
+
+ def test_team_admin_adds_member_without_active_team_context(self, _app_and_client):
+ _, client = _app_and_client
+ self.prisma.team.find_unique = AsyncMock(
+ return_value=_make_workspace(id=WS_ID, isDefault=False)
+ )
+ # Caller is an active admin of the target team; no X-Team-Id header.
+ self.prisma.teammember.find_unique = AsyncMock(
+ return_value=_make_ws_member(
+ workspaceId=WS_ID, userId=USER_ID, isAdmin=True
+ )
+ )
+ self.prisma.orgmember.find_unique = AsyncMock(return_value=MagicMock())
+ self.prisma.teammember.create = AsyncMock(
+ return_value=_make_ws_member(workspaceId=WS_ID, userId=OTHER_USER_ID)
+ )
+ self._use_ctx(_mgmt_ctx(user_id=USER_ID, team_id=None))
+
+ resp = client.post(
+ f"/api/orgs/{ORG_ID}/workspaces/{WS_ID}/members",
+ json={"user_id": OTHER_USER_ID},
+ )
+
+ assert resp.status_code == 200
+ self.prisma.teammember.create.assert_awaited_once()
+
+ def test_plain_org_member_cannot_add_member(self, _app_and_client):
+ _, client = _app_and_client
+ self.prisma.team.find_unique = AsyncMock(
+ return_value=_make_workspace(id=WS_ID, isDefault=False)
+ )
+ self.prisma.teammember.find_unique = AsyncMock(return_value=None)
+ self.prisma.teammember.create = AsyncMock()
+ self._use_ctx(_mgmt_ctx(user_id=OTHER_USER_ID))
+
+ resp = client.post(
+ f"/api/orgs/{ORG_ID}/workspaces/{WS_ID}/members",
+ json={"user_id": "user-new"},
+ )
+
+ assert resp.status_code == 403
+ self.prisma.teammember.create.assert_not_awaited()
+
+ # --- member removal (DELETE /{ws_id}/members/{uid}) ---------------------
+
+ def test_org_admin_removes_member_of_team_they_do_not_belong_to(
+ self, _app_and_client
+ ):
+ _, client = _app_and_client
+ self.prisma.team.find_unique = AsyncMock(
+ return_value=_make_workspace(id=WS_ID, isDefault=False)
+ )
+ # Only remove_team_member's target lookup hits this (org permission
+ # short-circuits before is_admin_of_team); target is not an admin.
+ self.prisma.teammember.find_unique = AsyncMock(
+ return_value=_make_ws_member(
+ workspaceId=WS_ID, userId=OTHER_USER_ID, isAdmin=False
+ )
+ )
+ self.prisma.teammember.delete = AsyncMock()
+ self._use_ctx(_mgmt_ctx(user_id=USER_ID, org_admin=True))
+
+ resp = client.delete(
+ f"/api/orgs/{ORG_ID}/workspaces/{WS_ID}/members/{OTHER_USER_ID}"
+ )
+
+ assert resp.status_code == 204
+ self.prisma.teammember.delete.assert_awaited_once()
+
+ def test_admin_of_different_team_cannot_remove_member(self, _app_and_client):
+ _, client = _app_and_client
+ self.prisma.team.find_unique = AsyncMock(
+ return_value=_make_workspace(id=WS_ID, isDefault=False)
+ )
+ # No membership row for the *target* team despite the caller's active
+ # team ("ws-other") having them as admin.
+ self.prisma.teammember.find_unique = AsyncMock(return_value=None)
+ self.prisma.teammember.delete = AsyncMock()
+ self._use_ctx(
+ _mgmt_ctx(user_id=OTHER_USER_ID, team_id="ws-other", team_admin=True)
+ )
+
+ resp = client.delete(
+ f"/api/orgs/{ORG_ID}/workspaces/{WS_ID}/members/{OTHER_USER_ID}"
+ )
+
+ assert resp.status_code == 403
+ self.prisma.teammember.delete.assert_not_awaited()
+
+ # --- is_admin_of_team denial branches -----------------------------------
+
+ def test_active_non_admin_member_cannot_update_team(self, _app_and_client):
+ _, client = _app_and_client
+ self.prisma.team.find_unique = AsyncMock(
+ return_value=_make_workspace(id=WS_ID, isDefault=False)
+ )
+ # Caller IS an active member of the target team — but not an admin.
+ self.prisma.teammember.find_unique = AsyncMock(
+ return_value=_make_ws_member(
+ workspaceId=WS_ID, userId=USER_ID, isAdmin=False, status="ACTIVE"
+ )
+ )
+ self.prisma.team.update = AsyncMock()
+ self._use_ctx(_mgmt_ctx(user_id=USER_ID))
+
+ resp = client.patch(
+ f"/api/orgs/{ORG_ID}/workspaces/{WS_ID}", json={"name": "Renamed"}
+ )
+
+ assert resp.status_code == 403
+ self.prisma.team.update.assert_not_awaited()
+
+ @pytest.mark.parametrize("member_status", ["INVITED", "SUSPENDED"])
+ def test_non_active_team_admin_cannot_update_team(
+ self, _app_and_client, member_status
+ ):
+ _, client = _app_and_client
+ self.prisma.team.find_unique = AsyncMock(
+ return_value=_make_workspace(id=WS_ID, isDefault=False)
+ )
+ # Caller has an admin row for the target team, but is not ACTIVE.
+ self.prisma.teammember.find_unique = AsyncMock(
+ return_value=_make_ws_member(
+ workspaceId=WS_ID, userId=USER_ID, isAdmin=True, status=member_status
+ )
+ )
+ self.prisma.team.update = AsyncMock()
+ self._use_ctx(_mgmt_ctx(user_id=USER_ID))
+
+ resp = client.patch(
+ f"/api/orgs/{ORG_ID}/workspaces/{WS_ID}", json={"name": "Renamed"}
+ )
+
+ assert resp.status_code == 403
+ self.prisma.team.update.assert_not_awaited()
+
+ # --- cross-org guard ----------------------------------------------------
+
+ def test_caller_from_other_org_is_rejected_before_any_lookup(self, _app_and_client):
+ _, client = _app_and_client
+ self.prisma.team.find_unique = AsyncMock()
+ self.prisma.team.update = AsyncMock()
+ # Caller's header org context differs from the org in the URL path.
+ self._use_ctx(_mgmt_ctx(user_id=USER_ID, org_id="org-bbb", org_admin=True))
+
+ resp = client.patch(
+ f"/api/orgs/{ORG_ID}/workspaces/{WS_ID}", json={"name": "Renamed"}
+ )
+
+ assert resp.status_code == 403
+ self.prisma.team.find_unique.assert_not_awaited()
+ self.prisma.team.update.assert_not_awaited()
+
+ def test_target_team_in_other_org_is_rejected(self, _app_and_client):
+ _, client = _app_and_client
+ # Target team belongs to a different org than the caller's context.
+ self.prisma.team.find_unique = AsyncMock(
+ return_value=_make_workspace(id=WS_ID, orgId="org-other", isDefault=False)
+ )
+ self.prisma.teammember.find_unique = AsyncMock(
+ return_value=_make_ws_member(
+ workspaceId=WS_ID, userId=USER_ID, isAdmin=True
+ )
+ )
+ self.prisma.team.update = AsyncMock()
+ self._use_ctx(_mgmt_ctx(user_id=USER_ID, org_admin=True))
+
+ resp = client.patch(
+ f"/api/orgs/{ORG_ID}/workspaces/{WS_ID}", json={"name": "Renamed"}
+ )
+
+ # get_team raises NotFoundError because the team is not in ORG_ID.
+ assert resp.status_code == 404
+ self.prisma.team.update.assert_not_awaited()
+
+
class TestCanonicalPersonalOrgOrdering:
"""The personal-org lookup must agree with auth's oldest-first rule so
every path resolves the same canonical org when a user briefly has more
diff --git a/autogpt_platform/backend/backend/api/features/orgs/team_db.py b/autogpt_platform/backend/backend/api/features/orgs/team_db.py
index 3a0c52d96f..bec5950d1b 100644
--- a/autogpt_platform/backend/backend/api/features/orgs/team_db.py
+++ b/autogpt_platform/backend/backend/api/features/orgs/team_db.py
@@ -148,6 +148,14 @@ async def list_team_members(ws_id: str) -> list[TeamMemberResponse]:
return [TeamMemberResponse.from_db(m) for m in members]
+async def is_admin_of_team(ws_id: str, user_id: str) -> bool:
+ """Return True if the user is an active admin of the workspace."""
+ member = await prisma.teammember.find_unique(
+ where={"teamId_userId": {"teamId": ws_id, "userId": user_id}}
+ )
+ return bool(member and member.isAdmin and member.status == "ACTIVE")
+
+
async def add_team_member(
ws_id: str,
user_id: str,
diff --git a/autogpt_platform/backend/backend/api/features/orgs/team_routes.py b/autogpt_platform/backend/backend/api/features/orgs/team_routes.py
index 441aa7a51b..2fd33c2f32 100644
--- a/autogpt_platform/backend/backend/api/features/orgs/team_routes.py
+++ b/autogpt_platform/backend/backend/api/features/orgs/team_routes.py
@@ -2,13 +2,9 @@
from typing import Annotated
-from autogpt_libs.auth import (
- get_request_context,
- requires_org_permission,
- requires_team_permission,
-)
+from autogpt_libs.auth import get_request_context, requires_org_permission
from autogpt_libs.auth.models import RequestContext
-from autogpt_libs.auth.permissions import OrgAction, TeamAction
+from autogpt_libs.auth.permissions import OrgAction, check_org_permission
from fastapi import APIRouter, HTTPException, Security
from . import team_db as team_db
@@ -24,6 +20,27 @@ from .team_model import (
router = APIRouter()
+async def _authorize_team_management(
+ ctx: RequestContext, org_id: str, ws_id: str
+) -> None:
+ """Authorize a management action against the target workspace from the URL path.
+
+ Independent of the caller's active team (X-Team-Id): allowed when the caller
+ administers the target workspace directly, or holds org-level MANAGE_WORKSPACES
+ over the org that owns it. The target workspace must belong to the path org.
+ """
+ if ctx.org_id != org_id:
+ raise HTTPException(403, detail="Not a member of this organization")
+ await team_db.get_team(ws_id, expected_org_id=org_id)
+ if check_org_permission(ctx, OrgAction.MANAGE_WORKSPACES):
+ return
+ if await team_db.is_admin_of_team(ws_id, ctx.user_id):
+ return
+ raise HTTPException(
+ 403, detail="Must be a workspace admin or org admin to manage this workspace"
+ )
+
+
@router.post(
"",
summary="Create workspace",
@@ -86,15 +103,9 @@ async def update_team(
org_id: str,
ws_id: str,
request: UpdateTeamRequest,
- ctx: Annotated[
- RequestContext,
- Security(requires_team_permission(TeamAction.MANAGE_SETTINGS)),
- ],
+ ctx: Annotated[RequestContext, Security(get_request_context)],
) -> TeamResponse:
- if ctx.team_id != ws_id:
- raise HTTPException(403, detail="Team context does not match the target team")
- # Verify workspace belongs to org (ctx validates workspace membership)
- await team_db.get_team(ws_id, expected_org_id=org_id)
+ await _authorize_team_management(ctx, org_id, ws_id)
return await team_db.update_team(
ws_id,
{
@@ -119,6 +130,10 @@ async def delete_team(
Security(requires_org_permission(OrgAction.MANAGE_WORKSPACES)),
],
) -> None:
+ # Deliberate asymmetry with _authorize_team_management: team admins may
+ # rename a team and manage its members, but deletion is destructive and
+ # stays org-admin-only (MANAGE_WORKSPACES).
+ #
# MANAGE_WORKSPACES only proves the caller administers their *active*
# org (ctx.org_id); without this guard an admin of org A could delete
# a workspace in org B (the permission passes, and get_team only checks
@@ -188,13 +203,9 @@ async def add_member(
org_id: str,
ws_id: str,
request: AddTeamMemberRequest,
- ctx: Annotated[
- RequestContext,
- Security(requires_team_permission(TeamAction.MANAGE_MEMBERS)),
- ],
+ ctx: Annotated[RequestContext, Security(get_request_context)],
) -> TeamMemberResponse:
- if ctx.team_id != ws_id:
- raise HTTPException(403, detail="Team context does not match the target team")
+ await _authorize_team_management(ctx, org_id, ws_id)
return await team_db.add_team_member(
ws_id=ws_id,
user_id=request.user_id,
@@ -215,13 +226,9 @@ async def update_member(
ws_id: str,
uid: str,
request: UpdateTeamMemberRequest,
- ctx: Annotated[
- RequestContext,
- Security(requires_team_permission(TeamAction.MANAGE_MEMBERS)),
- ],
+ ctx: Annotated[RequestContext, Security(get_request_context)],
) -> TeamMemberResponse:
- if ctx.team_id != ws_id:
- raise HTTPException(403, detail="Team context does not match the target team")
+ await _authorize_team_management(ctx, org_id, ws_id)
return await team_db.update_team_member(
ws_id=ws_id,
user_id=uid,
@@ -240,11 +247,7 @@ async def remove_member(
org_id: str,
ws_id: str,
uid: str,
- ctx: Annotated[
- RequestContext,
- Security(requires_team_permission(TeamAction.MANAGE_MEMBERS)),
- ],
+ ctx: Annotated[RequestContext, Security(get_request_context)],
) -> None:
- if ctx.team_id != ws_id:
- raise HTTPException(403, detail="Team context does not match the target team")
+ await _authorize_team_management(ctx, org_id, ws_id)
await team_db.remove_team_member(ws_id, uid)