Skip to content

Open-source AI teammates in Slack, Teams, Discord, Telegram and Mattermost. Self-host it, with any agent harness and any model.

fix: dashboard offers only the room changes the server allows (CHOO-4014) (#1327)

Christian McDermott0e79740dd138
diff --git a/CHANGELOG.md b/CHANGELOG.md
index c2dfe3847..4b1c83042 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -45,6 +45,14 @@ version of their own to them without also giving them a release of their own.
### [Unreleased]
#### Security
+- **Counts and replies no longer name private rooms either.** Beyond the
+ room listings below, a reference, document or package's attached-rooms count
+ took in every room it was attached to, an agent's detail named every room
+ it is in, and removing an item from a package named every room that lost
+ it. Each now names, and counts, only rooms the viewer may read; workspace
+ admins still see every room. Whoever may manage a resource is still told
+ how many rooms they cannot open it is in, without their names, and deleting
+ it warns about those rooms too.
- **A refused request is no longer repeated back.** When the gateway or the
agent API refused a request as invalid, the 422 repeated what was sent: a
password too short to accept, or the whole body, password included, when
@@ -106,6 +114,15 @@ version of their own to them without also giving them a release of their own.
lists, now leave out private rooms the caller cannot read.
#### Added
+- **The gateway says what the caller may change in a room.** Rooms, in the
+ list (`GET /rooms`) and in a room's detail, carry `can_write`,
+ `can_manage` and `can_unlink`. Each room a reference, document or package
+ is attached to carries `can_unlink`, and a room's documents, listed or
+ fetched one at a time, carry `can_remove`. A reference, document or
+ package carries `hidden_rooms_count`: for whoever may manage it, how many
+ of the rooms it is in they may not read. All are decided by the same
+ rules the routes enforce, so a client offers a change only where the
+ server would allow it.
- **An agent controller can send its agents' operations on its socket.**
Every operation a controller's agents call was an HTTP request of its own,
parsed, routed and authenticated with the controller's token, though the
@@ -216,6 +233,16 @@ version of their own to them without also giving them a release of their own.
compares it only when someone signs in.
#### Changed
+- **Unlinking a resource from a room is for those taking part in it.** It
+ took write access to the room, which on a publicly writable room, the
+ default, is everyone's. It is now for the room's owner, people in it (in
+ Switch Console or through a claimed platform account), owners of agents in
+ it, and workspace admins, whether or not they may write to it. The
+ dashboard shows it as an "Unlink" button rather than a bin, since nothing
+ is deleted. Attaching still takes write access.
+- **A room's own documents are deleted by their creator, the room's owner or
+ an admin.** Anyone who could write to the room could delete them. A
+ document an agent made counts as made by the agent's owner.
- **Usage telemetry tells people from bots.** Slack, Discord and Mattermost
posts from an integration (an app, a bot account, a webhook that isn't
Switch's own) were counted as people. The bridge now marks them, and the
@@ -507,6 +534,26 @@ version of their own to them without also giving them a release of their own.
token again; revocation is still checked on every request.
#### Fixed
+- **The dashboard offers only the room changes the server would allow.** On
+ a publicly writable room, the default, anyone could change the Access
+ setting and press Save, only for the server to refuse it. Someone who could
+ only read a room was still offered adding and removing its agents and
+ users, attaching and detaching its resources, linking it to other rooms and
+ deleting its room documents. A document, reference or package's page
+ offered attaching it to, and detaching it from, rooms the viewer could not
+ change. The rooms list offered archiving, and the groups page filing,
+ rooms the viewer could not change; a bulk archive skipped those without
+ saying so. Each of these was refused when tried. Access is now read-only for
+ everyone but the room's owner and admins, and its description says so.
+ Everything else is offered only to those who may write to the room, and
+ only rooms they may write to are offered for attaching. A reader still sees
+ each agent's "Notify on join" setting, but cannot change it. A publicly
+ writable room's other settings stay editable by everyone, as before.
+- **Those taking part in a private room can read its resources.** The room
+ itself could be read by its participants, but its references, documents,
+ packages and linked rooms were refused to anyone but its owner and admins.
+- **Deleting a room document from the room page asks first.** It cannot be
+ undone, and its own page already asked.
- **A client in more than 32,767 rooms starts reading them.** The reads a
client makes as it starts matched its rooms with one parameter each, and
Postgres takes at most 32,767 per statement. Switch's own client is in
diff --git a/console/packages/plugins/src/switch-skill/SKILL.md b/console/packages/plugins/src/switch-skill/SKILL.md
index d1e0ca777..2916c21d1 100644
--- a/console/packages/plugins/src/switch-skill/SKILL.md
+++ b/console/packages/plugins/src/switch-skill/SKILL.md
@@ -441,7 +441,8 @@ none of it is needed to take part in a conversation.
name.
- **`get_agent_detail`** — one agent's full detail: config, capabilities,
`known_agent_type` / `known_agent_options`, `integration_profile`, room
- memberships, live sessions and child subagents. Readable by any agent.
+ memberships, live sessions and child subagents. Readable by any agent; a
+ room your owner cannot read is not named in it.
`addressing` says who may address it: on yourself, the policy and its rules
with the people, agents and rooms they name; on another agent, the policy
alone.
diff --git a/core/switch_core/authz.py b/core/switch_core/authz.py
index 171150048..3494c3433 100644
--- a/core/switch_core/authz.py
+++ b/core/switch_core/authz.py
@@ -182,6 +182,32 @@ def require_manage(principal: Principal, owner_id: str | None) -> None:
raise PermissionError("Not authorized to manage this resource")
+def can_unlink_from_room(principal: Principal, *, takes_part: bool) -> bool:
+ """Whether `principal` may unlink a reference, document or package from a
+ room: those taking part in it and tenant admins. `takes_part` is the room
+ store's `involves`, which needs the database, so the caller works it out.
+ Write access is not enough: on a publicly writable room it is everyone's.
+ Linking still takes write access to the room. Note that whoever may write
+ to a room may also add their own agent to it, and so take part in it.
+ """
+ return principal.is_admin or takes_part
+
+
+def can_delete_room_document(
+ principal: Principal, *, room_owner_id: str | None, document_owner_id: str | None
+) -> bool:
+ """Whether `principal` may delete a room-scoped document: its creator, the
+ room's owner, or a tenant admin. An agent's document is recorded under the
+ agent's owner, so that person counts as its creator.
+ """
+ if principal.is_admin:
+ return True
+ return principal.id is not None and principal.id in (
+ room_owner_id,
+ document_owner_id,
+ )
+
+
def validate_visibility_pair(read_visibility: str, write_visibility: str) -> None:
"""Validate a (read, write) visibility pair, raising ``ValueError`` if bad.
diff --git a/core/switch_core/bridges/agent/operations/definitions.py b/core/switch_core/bridges/agent/operations/definitions.py
index 52357001d..a0edfbbc2 100644
--- a/core/switch_core/bridges/agent/operations/definitions.py
+++ b/core/switch_core/bridges/agent/operations/definitions.py
@@ -2228,6 +2228,7 @@ async def get_agent_detail(agent_id: str) -> dict[str, Any]:
Readable for any agent (not just your own). Use it to inspect another
agent's configuration, capabilities, room memberships, and live sessions.
+ A room your owner cannot read is not named in it.
Args:
agent_id: The target agent's id (from `list_participants` or
diff --git a/core/switch_core/bridges/agent/protocol/agent_core.py b/core/switch_core/bridges/agent/protocol/agent_core.py
index 79eee228f..32fb19cb4 100644
--- a/core/switch_core/bridges/agent/protocol/agent_core.py
+++ b/core/switch_core/bridges/agent/protocol/agent_core.py
@@ -3788,6 +3788,11 @@ class AgentCore:
include_archived=include_archived,
)
+ async def _visible_room_ids(self, session: AsyncSession, agent_id: str) -> set[str]:
+ """Ids of `rooms_visible_to`, archived rooms included."""
+ rooms = await self.rooms_visible_to(session, agent_id, include_archived=True)
+ return {r.id for r in rooms}
+
async def list_room_groups(self, agent_id: str) -> list[dict[str, Any]]:
"""List every room group on the instance, with room counts and paths.
@@ -3976,6 +3981,7 @@ class AgentCore:
return await assemble_agent_detail(
session,
agent=agent,
+ visible_room_ids=await self._visible_room_ids(session, agent_id),
agent_store=self.agent_store,
room_store=self.room_store,
user_store=self.user_store,
@@ -4049,6 +4055,7 @@ class AgentCore:
return await assemble_agent_detail(
session,
agent=refreshed,
+ visible_room_ids=await self._visible_room_ids(session, agent_id),
agent_store=self.agent_store,
room_store=self.room_store,
user_store=self.user_store,
diff --git a/core/switch_core/bridges/agent/protocol/agent_detail.py b/core/switch_core/bridges/agent/protocol/agent_detail.py
index 887f17d31..061489262 100644
--- a/core/switch_core/bridges/agent/protocol/agent_detail.py
+++ b/core/switch_core/bridges/agent/protocol/agent_detail.py
@@ -200,6 +200,7 @@ async def assemble_agent_detail(
session: AsyncSession,
*,
agent: Agent,
+ visible_room_ids: set[str],
agent_store: AgentStore,
room_store: RoomStore,
user_store: UserStore,
@@ -220,9 +221,13 @@ async def assemble_agent_detail(
len(models),
)
+ # Rooms the viewer may not read (outside `visible_room_ids`) are never
+ # named to them: they are left out of the agent's rooms, and a session in
+ # one carries no room name.
rooms = await room_store.get_rooms_for_agent(
session, agent.id, include_archived=True
)
+ rooms = [room for room in rooms if room.id in visible_room_ids]
room_name_by_id = {room.id: room.name for room in rooms}
room_ids = [room.id for room in rooms]
@@ -256,7 +261,8 @@ async def assemble_agent_detail(
]
if room_id is not None and room_id not in room_name_by_id
}
- for other in (await room_store.get_many(session, other_room_ids)).values():
+ shown_others = other_room_ids & visible_room_ids
+ for other in (await room_store.get_many(session, shown_others)).values():
room_name_by_id[other.id] = other.name
now = datetime.now(UTC)
diff --git a/core/switch_core/bridges/resource/service.py b/core/switch_core/bridges/resource/service.py
index d33a9af15..ce60acbd3 100644
--- a/core/switch_core/bridges/resource/service.py
+++ b/core/switch_core/bridges/resource/service.py
@@ -35,6 +35,7 @@ from switch_core.db.stores.package_store import PackageStore
from switch_core.db.stores.reference_store import ReferenceStore
from switch_core.db.stores.reference_type_store import ReferenceTypeStore
from switch_core.db.stores.room_link_store import RoomLinkStore
+from switch_core.db.stores.room_store import AttachedRooms
from switch_core.telemetry import TelemetryService, emit_safely
from switch_core.telemetry.ages import age_days
@@ -703,14 +704,28 @@ class ResourceService:
return await self._references.list_ids_for_room(session, room_id)
async def get_reference_attached_counts(
- self, session: AsyncSession, reference_ids: list[str]
- ) -> dict[str, int]:
- return await self._references.get_attached_counts(session, reference_ids)
+ self,
+ session: AsyncSession,
+ reference_ids: list[str],
+ *,
+ reader_id: str | None,
+ reader_is_admin: bool,
+ ) -> dict[str, AttachedRooms]:
+ return await self._references.get_attached_counts(
+ session, reference_ids, reader_id=reader_id, reader_is_admin=reader_is_admin
+ )
async def list_rooms_for_reference(
- self, session: AsyncSession, reference_id: str
+ self,
+ session: AsyncSession,
+ reference_id: str,
+ *,
+ reader_id: str | None,
+ reader_is_admin: bool,
) -> list[tuple[str, str]]:
- return await self._references.list_rooms_for_reference(session, reference_id)
+ return await self._references.list_rooms_for_reference(
+ session, reference_id, reader_id=reader_id, reader_is_admin=reader_is_admin
+ )
# ── Room links (gateway) ──────────────────────────────────────────────
@@ -974,14 +989,28 @@ class ResourceService:
return await self._documents.list_for_room(session, room_id)
async def get_document_attached_counts(
- self, session: AsyncSession, document_ids: list[str]
- ) -> dict[str, int]:
- return await self._documents.get_attached_counts(session, document_ids)
+ self,
+ session: AsyncSession,
+ document_ids: list[str],
+ *,
+ reader_id: str | None,
+ reader_is_admin: bool,
+ ) -> dict[str, AttachedRooms]:
+ return await self._documents.get_attached_counts(
+ session, document_ids, reader_id=reader_id, reader_is_admin=reader_is_admin
+ )
async def list_rooms_for_document(
- self, session: AsyncSession, document_id: str
+ self,
+ session: AsyncSession,
+ document_id: str,
+ *,
+ reader_id: str | None,
+ reader_is_admin: bool,
) -> list[tuple[str, str]]:
- return await self._documents.list_rooms_for_document(session, document_id)
+ return await self._documents.list_rooms_for_document(
+ session, document_id, reader_id=reader_id, reader_is_admin=reader_is_admin
+ )
# ── Room-scoped documents (agent-created via MCP) ─────────────────────
@@ -1155,8 +1184,8 @@ class ResourceService:
room_id: str,
document_id: str,
) -> None:
- """Gateway escape hatch: a user with access to the room can delete a
- room-scoped document regardless of which agent created it."""
+ """Delete a room-scoped document for a person, whichever agent made
+ it. The gateway decides who may (`authz.can_delete_room_document`)."""
doc = await self._documents.get_room_scoped(session, room_id, document_id)
if doc is None:
raise ValueError(
@@ -1341,9 +1370,16 @@ class ResourceService:
return await self._packages.list_for_room(session, room_id)
async def get_package_attached_counts(
- self, session: AsyncSession, package_ids: list[str]
- ) -> dict[str, int]:
- return await self._packages.get_attached_counts(session, package_ids)
+ self,
+ session: AsyncSession,
+ package_ids: list[str],
+ *,
+ reader_id: str | None,
+ reader_is_admin: bool,
+ ) -> dict[str, AttachedRooms]:
+ return await self._packages.get_attached_counts(
+ session, package_ids, reader_id=reader_id, reader_is_admin=reader_is_admin
+ )
async def get_package_reference_counts(
self, session: AsyncSession, package_ids: list[str]
@@ -1356,9 +1392,16 @@ class ResourceService:
return await self._packages.get_document_counts(session, package_ids)
async def list_rooms_for_package(
- self, session: AsyncSession, package_id: str
+ self,
+ session: AsyncSession,
+ package_id: str,
+ *,
+ reader_id: str | None,
+ reader_is_admin: bool,
) -> list[tuple[str, str]]:
- return await self._packages.list_rooms_for_package(session, package_id)
+ return await self._packages.list_rooms_for_package(
+ session, package_id, reader_id=reader_id, reader_is_admin=reader_is_admin
+ )
# ── Package membership ────────────────────────────────────────────────
diff --git a/core/switch_core/db/stores/document_store.py b/core/switch_core/db/stores/document_store.py
index 76905c574..1386a39a9 100644
--- a/core/switch_core/db/stores/document_store.py
+++ b/core/switch_core/db/stores/document_store.py
@@ -2,6 +2,7 @@ from sqlalchemy import and_, delete, func, insert, or_, select
from sqlalchemy.ext.asyncio import AsyncSession
from switch_core.db.models import Document, Room, room_documents
+from switch_core.db.stores.room_store import AttachedRooms, readable_by
class DocumentStore:
@@ -155,27 +156,48 @@ class DocumentStore:
return result.first() is not None
async def get_attached_counts(
- self, session: AsyncSession, document_ids: list[str]
- ) -> dict[str, int]:
+ self,
+ session: AsyncSession,
+ document_ids: list[str],
+ *,
+ reader_id: str | None,
+ reader_is_admin: bool,
+ ) -> dict[str, AttachedRooms]:
+ """How many rooms each is attached to: every one, and those the reader
+ may read."""
if not document_ids:
return {}
result = await session.execute(
select(
room_documents.c.document_id,
func.count(room_documents.c.room_id),
+ func.count(room_documents.c.room_id).filter(
+ readable_by(reader_id, is_admin=reader_is_admin)
+ ),
)
+ .join(Room, Room.id == room_documents.c.room_id)
.where(room_documents.c.document_id.in_(document_ids))
.group_by(room_documents.c.document_id)
)
- counts = {did: int(c) for did, c in result.all()}
- return {did: counts.get(did, 0) for did in document_ids}
+ counts = {
+ rid: AttachedRooms(every=int(every), readable=int(readable))
+ for rid, every, readable in result.all()
+ }
+ return {rid: counts.get(rid, AttachedRooms(0, 0)) for rid in document_ids}
async def list_rooms_for_document(
- self, session: AsyncSession, document_id: str
+ self,
+ session: AsyncSession,
+ document_id: str,
+ *,
+ reader_id: str | None,
+ reader_is_admin: bool,
) -> list[tuple[str, str]]:
+ """The rooms it is attached to, of those the reader may read."""
result = await session.execute(
select(Room.id, Room.name)
.join(room_documents, Room.id == room_documents.c.room_id)
.where(room_documents.c.document_id == document_id)
+ .where(readable_by(reader_id, is_admin=reader_is_admin))
)
return [(rid, name) for rid, name in result.all()]
diff --git a/core/switch_core/db/stores/package_store.py b/core/switch_core/db/stores/package_store.py
index 50b41a842..75744e206 100644
--- a/core/switch_core/db/stores/package_store.py
+++ b/core/switch_core/db/stores/package_store.py
@@ -10,6 +10,7 @@ from switch_core.db.models import (
room_packages,
room_references,
)
+from switch_core.db.stores.room_store import AttachedRooms, readable_by
class PackageStore:
@@ -124,20 +125,34 @@ class PackageStore:
return result.scalar_one_or_none() is not None
async def get_attached_counts(
- self, session: AsyncSession, package_ids: list[str]
- ) -> dict[str, int]:
+ self,
+ session: AsyncSession,
+ package_ids: list[str],
+ *,
+ reader_id: str | None,
+ reader_is_admin: bool,
+ ) -> dict[str, AttachedRooms]:
+ """How many rooms each is attached to: every one, and those the reader
+ may read."""
if not package_ids:
return {}
result = await session.execute(
select(
room_packages.c.package_id,
func.count(room_packages.c.room_id),
+ func.count(room_packages.c.room_id).filter(
+ readable_by(reader_id, is_admin=reader_is_admin)
+ ),
)
+ .join(Room, Room.id == room_packages.c.room_id)
.where(room_packages.c.package_id.in_(package_ids))
.group_by(room_packages.c.package_id)
)
- counts = {pid: int(c) for pid, c in result.all()}
- return {pid: counts.get(pid, 0) for pid in package_ids}
+ counts = {
+ rid: AttachedRooms(every=int(every), readable=int(readable))
+ for rid, every, readable in result.all()
+ }
+ return {rid: counts.get(rid, AttachedRooms(0, 0)) for rid in package_ids}
async def get_reference_counts(
self, session: AsyncSession, package_ids: list[str]
@@ -172,12 +187,19 @@ class PackageStore:
return {pid: counts.get(pid, 0) for pid in package_ids}
async def list_rooms_for_package(
- self, session: AsyncSession, package_id: str
+ self,
+ session: AsyncSession,
+ package_id: str,
+ *,
+ reader_id: str | None,
+ reader_is_admin: bool,
) -> list[tuple[str, str]]:
+ """The rooms it is attached to, of those the reader may read."""
result = await session.execute(
select(Room.id, Room.name)
.join(room_packages, Room.id == room_packages.c.room_id)
.where(room_packages.c.package_id == package_id)
+ .where(readable_by(reader_id, is_admin=reader_is_admin))
)
return [(rid, name) for rid, name in result.all()]
diff --git a/core/switch_core/db/stores/reference_store.py b/core/switch_core/db/stores/reference_store.py
index a2a891a68..222dd281c 100644
--- a/core/switch_core/db/stores/reference_store.py
+++ b/core/switch_core/db/stores/reference_store.py
@@ -3,6 +3,7 @@ from sqlalchemy.dialects.postgresql import insert as pg_insert
from sqlalchemy.ext.asyncio import AsyncSession
from switch_core.db.models import Reference, Room, User, room_references
+from switch_core.db.stores.room_store import AttachedRooms, readable_by
_LIKE_ESCAPE = "\\"
@@ -188,27 +189,48 @@ class ReferenceStore:
return result.scalar_one_or_none() is not None
async def get_attached_counts(
- self, session: AsyncSession, reference_ids: list[str]
- ) -> dict[str, int]:
+ self,
+ session: AsyncSession,
+ reference_ids: list[str],
+ *,
+ reader_id: str | None,
+ reader_is_admin: bool,
+ ) -> dict[str, AttachedRooms]:
+ """How many rooms each is attached to: every one, and those the reader
+ may read."""
if not reference_ids:
return {}
result = await session.execute(
select(
room_references.c.reference_id,
func.count(room_references.c.room_id),
+ func.count(room_references.c.room_id).filter(
+ readable_by(reader_id, is_admin=reader_is_admin)
+ ),
)
+ .join(Room, Room.id == room_references.c.room_id)
.where(room_references.c.reference_id.in_(reference_ids))
.group_by(room_references.c.reference_id)
)
- counts = {rid: int(c) for rid, c in result.all()}
- return {rid: counts.get(rid, 0) for rid in reference_ids}
+ counts = {
+ rid: AttachedRooms(every=int(every), readable=int(readable))
+ for rid, every, readable in result.all()
+ }
+ return {rid: counts.get(rid, AttachedRooms(0, 0)) for rid in reference_ids}
async def list_rooms_for_reference(
- self, session: AsyncSession, reference_id: str
+ self,
+ session: AsyncSession,
+ reference_id: str,
+ *,
+ reader_id: str | None,
+ reader_is_admin: bool,
) -> list[tuple[str, str]]:
+ """The rooms it is attached to, of those the reader may read."""
result = await session.execute(
select(Room.id, Room.name)
.join(room_references, Room.id == room_references.c.room_id)
.where(room_references.c.reference_id == reference_id)
+ .where(readable_by(reader_id, is_admin=reader_is_admin))
)
return [(rid, name) for rid, name in result.all()]
diff --git a/core/switch_core/db/stores/room_store.py b/core/switch_core/db/stores/room_store.py
index 4561ea01a..365e011cb 100644
--- a/core/switch_core/db/stores/room_store.py
+++ b/core/switch_core/db/stores/room_store.py
@@ -1,6 +1,7 @@
from collections.abc import Collection
from dataclasses import dataclass
from datetime import UTC, datetime
+from typing import NamedTuple
from sqlalchemy import (
ColumnElement,
@@ -9,6 +10,7 @@ from sqlalchemy import (
literal,
or_,
select,
+ true,
update,
)
from sqlalchemy import func as sa_func
@@ -320,14 +322,26 @@ class RoomStore:
"""Return rooms the user may read: publicly readable, ones they take
part in (`involves`), or all if admin. Archived rooms are excluded
unless `include_archived`."""
- stmt = select(Room)
- if not is_admin:
- stmt = stmt.where(or_(Room.read_visibility == "public", involves(user_id)))
+ stmt = select(Room).where(readable_by(user_id, is_admin=is_admin))
if not include_archived:
stmt = stmt.where(Room.archived_at.is_(None))
result = await session.execute(stmt)
return list(result.scalars().all())
+ async def visible_room_ids(
+ self,
+ session: AsyncSession,
+ room_ids: Collection[str],
+ visible: ColumnElement[bool],
+ ) -> set[str]:
+ """Of `room_ids`, the rooms `visible` holds for."""
+ if not room_ids:
+ return set()
+ result = await session.execute(
+ select(Room.id).where(Room.id.in_(room_ids), visible)
+ )
+ return set(result.scalars().all())
+
async def involved_room_ids(
self, session: AsyncSession, user_id: str, room_ids: Collection[str]
) -> set[str]:
@@ -949,6 +963,26 @@ class RoomStore:
return result.rowcount or 0 # type: ignore[attr-defined]
+class AttachedRooms(NamedTuple):
+ """How many rooms a reference, document or package is in: every one, and
+ those a given reader may read (`readable_by`). Counted in one query, so
+ the two agree."""
+
+ every: int
+ readable: int
+
+
+def readable_by(user_id: str | None, *, is_admin: bool) -> ColumnElement[bool]:
+ """True for a `Room` row the user may read: publicly readable, or one they
+ take part in (`involves`). Every room, for a tenant admin; only public ones
+ for a reader with no user (an agent nobody owns), who takes part in none."""
+ if is_admin:
+ return true()
+ if user_id is None:
+ return Room.read_visibility == "public"
+ return or_(Room.read_visibility == "public", involves(user_id))
+
+
def _visible_to_agent(reader_id: str | None, agent_id: str) -> ColumnElement[bool]:
"""True for a `Room` row an agent may see when its owner is not a
workspace admin: public, one the owner takes part in, or one the agent is
@@ -968,8 +1002,9 @@ def _visible_to_agent(reader_id: str | None, agent_id: str) -> ColumnElement[boo
def involves(user_id: str) -> ColumnElement[bool]:
"""True for a `Room` row the user takes part in: they own it, their Switch
Console member client or a platform account they have claimed is in it,
- or an agent they own is. For reading and listing only; it grants no
- write or configuration access."""
+ or an agent they own is. It grants reading and listing, and unlinking
+ resources (`authz.can_unlink_from_room`); no write or configuration
+ access."""
return or_(
Room.owner_id == user_id,
exists().where(
diff --git a/core/switch_core/gateway/agents.py b/core/switch_core/gateway/agents.py
index 5ae1bc87a..555b17ad3 100644
--- a/core/switch_core/gateway/agents.py
+++ b/core/switch_core/gateway/agents.py
@@ -36,7 +36,11 @@ from switch_core.db.models import User, require_tenant_id
from switch_core.db.stores.agent_store import AgentStore
from switch_core.db.stores.room_store import RoomStore
from switch_core.db.stores.user_store import UserStore
-from switch_core.gateway.auth import get_current_user, get_tenant_is_admin
+from switch_core.gateway.auth import (
+ get_current_user,
+ get_tenant_is_admin,
+ readable_room_ids,
+)
from switch_core.gateway.chats import get_chat_service
from switch_core.gateway.dependencies import (
get_agent_store,
@@ -729,6 +733,7 @@ async def update_addressing_policy(
return await assemble_agent_detail(
session,
agent=agent,
+ visible_room_ids=await readable_room_ids(session, room_store, user, is_admin),
agent_store=agent_store,
room_store=room_store,
user_store=user_store,
@@ -748,6 +753,7 @@ async def update_can_manage_agents(
user_store: Annotated[UserStore, Depends(get_user_store)],
protocol: Annotated[AgentCore, Depends(get_protocol)],
user: Annotated[User, Depends(get_current_user)],
+ is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> AgentDetail:
"""Turn the agent's "can manage agents" capability on or off.
@@ -780,6 +786,7 @@ async def update_can_manage_agents(
return await assemble_agent_detail(
session,
agent=agent,
+ visible_room_ids=await readable_room_ids(session, room_store, user, is_admin),
agent_store=agent_store,
room_store=room_store,
user_store=user_store,
@@ -799,7 +806,8 @@ async def get_agent_detail(
room_store: Annotated[RoomStore, Depends(get_room_store)],
user_store: Annotated[UserStore, Depends(get_user_store)],
protocol: Annotated[AgentCore, Depends(get_protocol)],
- _user: Annotated[User, Depends(get_current_user)],
+ user: Annotated[User, Depends(get_current_user)],
+ is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> AgentDetail:
agent = await agent_store.get(session, agent_id)
if agent is None:
@@ -808,6 +816,7 @@ async def get_agent_detail(
return await assemble_agent_detail(
session,
agent=agent,
+ visible_room_ids=await readable_room_ids(session, room_store, user, is_admin),
agent_store=agent_store,
room_store=room_store,
user_store=user_store,
diff --git a/core/switch_core/gateway/auth.py b/core/switch_core/gateway/auth.py
index f4f7c0e97..b6d01a0c0 100644
--- a/core/switch_core/gateway/auth.py
+++ b/core/switch_core/gateway/auth.py
@@ -19,6 +19,7 @@ from switch_core.authz import (
ORGANIZATION_ADMIN_TENANT_ROLE,
Action,
Principal,
+ can_unlink_from_room,
require,
)
from switch_core.config import SwitchConfig
@@ -1196,16 +1197,78 @@ async def require_room_access(
in their workspace, private ones included. See the phase 2 design note on
what that grant covers.
"""
+ return await authorize_room(
+ session, room_store, room_id, Principal(user.id, is_admin), action
+ )
+
+
+async def authorize_room(
+ session: AsyncSession,
+ room_store: RoomStore,
+ room_id: str,
+ principal: Principal,
+ action: Action,
+) -> Room:
+ """`require_room_access` for a caller who already holds a `Principal`: the
+ one place a room's access rule is applied, for every gateway route."""
room = await room_store.get(session, room_id)
if room is None:
raise HTTPException(status_code=404, detail="Room not found")
try:
- require(Principal(user.id, is_admin), action, room)
+ require(principal, action, room)
except PermissionError as e:
- raise HTTPException(status_code=403, detail=str(e)) from e
+ # Whoever takes part in a room may read it, as its listing shows them.
+ if action != "read" or not await takes_part_in_room(
+ session, room_store, room.id, principal.id
+ ):
+ raise HTTPException(status_code=403, detail=str(e)) from e
+ return room
+
+
+async def require_room_unlink(
+ session: AsyncSession,
+ room_store: RoomStore,
+ room_id: str,
+ user: User,
+ is_admin: bool,
+) -> Room:
+ """Load a room and authorize unlinking a reference, document or package
+ from it (`authz.can_unlink_from_room`): raise HTTP 403 unless `user`
+ takes part in it or is a tenant admin. Both may read it, so there is no
+ separate read check."""
+ room = await room_store.get(session, room_id)
+ if room is None:
+ raise HTTPException(status_code=404, detail="Room not found")
+ await ensure_may_unlink(session, room_store, room, Principal(user.id, is_admin))
return room
+async def ensure_may_unlink(
+ session: AsyncSession, room_store: RoomStore, room: Room, principal: Principal
+) -> None:
+ """Raise HTTP 403 unless `principal` may unlink from `room`."""
+ # An admin may whether or not they take part, so is spared the query.
+ takes_part = not principal.is_admin and await takes_part_in_room(
+ session, room_store, room.id, principal.id
+ )
+ if not can_unlink_from_room(principal, takes_part=takes_part):
+ raise HTTPException(
+ status_code=403,
+ detail="Only those taking part in the room and admins can unlink from it",
+ )
+
+
+async def takes_part_in_room(
+ session: AsyncSession, room_store: RoomStore, room_id: str, user_id: str | None
+) -> bool:
+ """Whether the user owns the room, is in it (in Switch Console or through a
+ platform account they claimed), or owns an agent in it. A caller with no
+ user (an agent nobody owns) takes part in nothing."""
+ if user_id is None:
+ return False
+ return bool(await room_store.involved_room_ids(session, user_id, [room_id]))
+
+
async def readable_room_ids(
session: AsyncSession, room_store: RoomStore, user: User, is_admin: bool
) -> set[str]:
diff --git a/core/switch_core/gateway/documents.py b/core/switch_core/gateway/documents.py
index 159ecec24..aee3764d2 100644
--- a/core/switch_core/gateway/documents.py
+++ b/core/switch_core/gateway/documents.py
@@ -5,16 +5,22 @@ from typing import Annotated
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.ext.asyncio import AsyncSession
+from switch_core.authz import (
+ Principal,
+ can_delete_room_document,
+ can_unlink_from_room,
+)
from switch_core.bridges.resource.service import ResourceService
-from switch_core.db.models import Document, User
+from switch_core.db.models import Document, Room, User
from switch_core.db.stores.agent_store import AgentStore
from switch_core.db.stores.room_store import RoomStore
from switch_core.db.stores.user_store import UserStore
from switch_core.gateway.auth import (
+ ensure_may_unlink,
get_current_user,
get_tenant_is_admin,
- readable_room_ids,
require_room_access,
+ takes_part_in_room,
)
from switch_core.gateway.dependencies import (
get_agent_store,
@@ -23,6 +29,7 @@ from switch_core.gateway.dependencies import (
get_session,
get_user_store,
)
+from switch_core.gateway.resource_rooms import resource_rooms, room_counts
from switch_core.gateway.schemas import (
DocumentCreateRequest,
DocumentDeleteResponse,
@@ -30,6 +37,8 @@ from switch_core.gateway.schemas import (
DocumentSummary,
DocumentUpdateRequest,
ResourceRoom,
+ RoomDocumentDetail,
+ RoomDocumentSummary,
)
router = APIRouter()
@@ -40,6 +49,7 @@ def _to_detail(
*,
owner_name: str | None = None,
attached_rooms_count: int = 0,
+ hidden_rooms_count: int,
packages: list[str] | None = None,
created_by_agent_name: str | None = None,
) -> DocumentDetail:
@@ -54,6 +64,7 @@ def _to_detail(
instructions=doc.instructions,
content=doc.content,
attached_rooms_count=attached_rooms_count,
+ hidden_rooms_count=hidden_rooms_count,
packages=packages or [],
scope="room" if doc.room_id is not None else "global",
room_id=doc.room_id,
@@ -68,6 +79,7 @@ def _to_summary(
*,
owner_name: str | None = None,
attached_rooms_count: int = 0,
+ hidden_rooms_count: int,
packages: list[str] | None = None,
created_by_agent_name: str | None = None,
) -> DocumentSummary:
@@ -81,6 +93,7 @@ def _to_summary(
description=doc.description,
instructions=doc.instructions,
attached_rooms_count=attached_rooms_count,
+ hidden_rooms_count=hidden_rooms_count,
packages=packages or [],
scope="room" if doc.room_id is not None else "global",
room_id=doc.room_id,
@@ -90,17 +103,30 @@ def _to_summary(
)
+def _can_remove(
+ principal: Principal, room: Room, doc: Document, *, takes_part: bool
+) -> bool:
+ """Whether `principal` may remove `doc` from `room`: delete it if it is
+ room-scoped, unlink it if it is attached."""
+ if doc.room_id is not None:
+ return can_delete_room_document(
+ principal, room_owner_id=room.owner_id, document_owner_id=doc.owner_id
+ )
+ return can_unlink_from_room(principal, takes_part=takes_part)
+
+
async def _enrich_summaries(
session: AsyncSession,
docs: list[Document],
resource_service: ResourceService,
user_store: UserStore,
agent_store: AgentStore,
+ reader: Principal,
) -> list[DocumentSummary]:
if not docs:
return []
- counts = await resource_service.get_document_attached_counts(
- session, [d.id for d in docs]
+ counts = await room_counts(
+ session, docs, reader, resource_service.get_document_attached_counts
)
pkg_map = await resource_service.get_packages_for_documents(
session, [d.id for d in docs]
@@ -121,7 +147,8 @@ async def _enrich_summaries(
_to_summary(
d,
owner_name=owners.get(d.owner_id) if d.owner_id else None,
- attached_rooms_count=counts.get(d.id, 0),
+ attached_rooms_count=counts[d.id].attached,
+ hidden_rooms_count=counts[d.id].hidden,
packages=pkg_map.get(d.id, []),
created_by_agent_name=(
agent_names.get(d.created_by_agent_id)
@@ -139,8 +166,11 @@ async def _enrich_detail(
resource_service: ResourceService,
user_store: UserStore,
agent_store: AgentStore,
+ reader: Principal,
) -> DocumentDetail:
- counts = await resource_service.get_document_attached_counts(session, [doc.id])
+ counts = await room_counts(
+ session, [doc], reader, resource_service.get_document_attached_counts
+ )
pkg_map = await resource_service.get_packages_for_documents(session, [doc.id])
owner = await user_store.get(session, doc.owner_id) if doc.owner_id else None
agent = (
@@ -151,7 +181,8 @@ async def _enrich_detail(
return _to_detail(
doc,
owner_name=owner.name if owner else None,
- attached_rooms_count=counts.get(doc.id, 0),
+ attached_rooms_count=counts[doc.id].attached,
+ hidden_rooms_count=counts[doc.id].hidden,
packages=pkg_map.get(doc.id, []),
created_by_agent_name=agent.name if agent else None,
)
@@ -164,10 +195,16 @@ async def list_documents(
user_store: Annotated[UserStore, Depends(get_user_store)],
agent_store: Annotated[AgentStore, Depends(get_agent_store)],
user: Annotated[User, Depends(get_current_user)],
+ is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> list[DocumentSummary]:
docs = await resource_service.list_documents_for_user(session, user.id)
return await _enrich_summaries(
- session, docs, resource_service, user_store, agent_store
+ session,
+ docs,
+ resource_service,
+ user_store,
+ agent_store,
+ Principal(user.id, is_admin),
)
@@ -179,6 +216,7 @@ async def create_document(
user_store: Annotated[UserStore, Depends(get_user_store)],
agent_store: Annotated[AgentStore, Depends(get_agent_store)],
user: Annotated[User, Depends(get_current_user)],
+ is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> DocumentDetail:
try:
doc = await resource_service.create_document(
@@ -194,7 +232,14 @@ async def create_document(
except ValueError as e:
raise HTTPException(status_code=400, detail=str(e)) from e
await session.commit()
- return await _enrich_detail(session, doc, resource_service, user_store, agent_store)
+ return await _enrich_detail(
+ session,
+ doc,
+ resource_service,
+ user_store,
+ agent_store,
+ Principal(user.id, is_admin),
+ )
@router.get("/documents/{document_id}")
@@ -215,7 +260,14 @@ async def get_document(
raise HTTPException(status_code=404, detail=str(e)) from e
except PermissionError as e:
raise HTTPException(status_code=403, detail=str(e)) from e
- return await _enrich_detail(session, doc, resource_service, user_store, agent_store)
+ return await _enrich_detail(
+ session,
+ doc,
+ resource_service,
+ user_store,
+ agent_store,
+ Principal(user.id, is_admin),
+ )
@router.patch("/documents/{document_id}")
@@ -247,7 +299,14 @@ async def patch_document(
except PermissionError as e:
raise HTTPException(status_code=403, detail=str(e)) from e
await session.commit()
- return await _enrich_detail(session, doc, resource_service, user_store, agent_store)
+ return await _enrich_detail(
+ session,
+ doc,
+ resource_service,
+ user_store,
+ agent_store,
+ Principal(user.id, is_admin),
+ )
@router.delete("/documents/{document_id}")
@@ -297,13 +356,12 @@ async def list_rooms_for_document(
raise HTTPException(status_code=404, detail=str(e)) from e
except PermissionError as e:
raise HTTPException(status_code=403, detail=str(e)) from e
- rows = await resource_service.list_rooms_for_document(session, document_id)
- readable = await readable_room_ids(session, room_store, user, is_admin)
- return [
- ResourceRoom(room_id=rid, room_name=name)
- for rid, name in rows
- if rid in readable
- ]
+ rooms = await resource_service.list_rooms_for_document(
+ session, document_id, reader_id=user.id, reader_is_admin=is_admin
+ )
+ return await resource_rooms(
+ session, room_store, rooms, Principal(user.id, is_admin)
+ )
@router.get("/rooms/{room_id}/documents")
@@ -316,12 +374,23 @@ async def list_room_documents(
room_store: Annotated[RoomStore, Depends(get_room_store)],
user: Annotated[User, Depends(get_current_user)],
is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
-) -> list[DocumentSummary]:
- await require_room_access(session, room_store, room_id, user, "read", is_admin)
+) -> list[RoomDocumentSummary]:
+ room = await require_room_access(
+ session, room_store, room_id, user, "read", is_admin
+ )
+ takes_part = await takes_part_in_room(session, room_store, room.id, user.id)
+ principal = Principal(user.id, is_admin)
docs = await resource_service.list_room_documents(session, room_id)
- return await _enrich_summaries(
- session, docs, resource_service, user_store, agent_store
+ summaries = await _enrich_summaries(
+ session, docs, resource_service, user_store, agent_store, principal
)
+ return [
+ RoomDocumentSummary(
+ **summary.model_dump(),
+ can_remove=_can_remove(principal, room, doc, takes_part=takes_part),
+ )
+ for summary, doc in zip(summaries, docs, strict=True)
+ ]
@router.post("/rooms/{room_id}/documents/{document_id}", status_code=201)
@@ -353,7 +422,14 @@ async def attach_document_to_room(
doc = await resource_service.get_document_for_user(
session, document_id, user.id, is_admin=is_admin
)
- return await _enrich_detail(session, doc, resource_service, user_store, agent_store)
+ return await _enrich_detail(
+ session,
+ doc,
+ resource_service,
+ user_store,
+ agent_store,
+ Principal(user.id, is_admin),
+ )
@router.delete("/rooms/{room_id}/documents/{document_id}", status_code=204)
@@ -366,17 +442,30 @@ async def detach_document_from_room(
user: Annotated[User, Depends(get_current_user)],
is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> None:
- """For globally-owned docs: detach from the room. For room-scoped docs:
- hard-delete them entirely (since they live only in this room)."""
- await require_room_access(session, room_store, room_id, user, "write", is_admin)
+ """For globally-owned docs: unlink from the room, which those taking part
+ in it and admins may do. For room-scoped docs: hard-delete them entirely
+ (since they live only in this room), which their creator, the room's owner
+ and admins may do."""
+ room = await require_room_access(
+ session, room_store, room_id, user, "read", is_admin
+ )
+ principal = Principal(user.id, is_admin)
doc = await resource_service.get_room_scoped_document_or_none(
session, room_id, document_id
)
if doc is not None:
+ if not can_delete_room_document(
+ principal, room_owner_id=room.owner_id, document_owner_id=doc.owner_id
+ ):
+ raise HTTPException(
+ status_code=403,
+ detail="Only the document's creator, the room's owner and admins can delete it",
+ )
await resource_service.delete_room_document_by_user(
session, room_id=room_id, document_id=document_id
)
else:
+ await ensure_may_unlink(session, room_store, room, principal)
await resource_service.detach_document_from_room(session, room_id, document_id)
await session.commit()
@@ -392,15 +481,25 @@ async def get_room_document(
room_store: Annotated[RoomStore, Depends(get_room_store)],
user: Annotated[User, Depends(get_current_user)],
is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
-) -> DocumentDetail:
+) -> RoomDocumentDetail:
"""Fetch a document by id within the context of a room. Accepts both
room-scoped documents (read-only) and globally-attached documents. Room
read access is required and, once granted, implies access to its docs."""
- await require_room_access(session, room_store, room_id, user, "read", is_admin)
+ room = await require_room_access(
+ session, room_store, room_id, user, "read", is_admin
+ )
docs = await resource_service.list_room_documents(session, room_id)
doc = next((d for d in docs if d.id == document_id), None)
if doc is None:
raise HTTPException(
status_code=404, detail=f"Document {document_id} not in room {room_id}"
)
- return await _enrich_detail(session, doc, resource_service, user_store, agent_store)
+ principal = Principal(user.id, is_admin)
+ detail = await _enrich_detail(
+ session, doc, resource_service, user_store, agent_store, principal
+ )
+ takes_part = await takes_part_in_room(session, room_store, room.id, user.id)
+ return RoomDocumentDetail(
+ **detail.model_dump(),
+ can_remove=_can_remove(principal, room, doc, takes_part=takes_part),
+ )
diff --git a/core/switch_core/gateway/packages.py b/core/switch_core/gateway/packages.py
index 5e8f0d4e5..16a719c87 100644
--- a/core/switch_core/gateway/packages.py
+++ b/core/switch_core/gateway/packages.py
@@ -5,16 +5,17 @@ from typing import Annotated
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.ext.asyncio import AsyncSession
+from switch_core.authz import Principal
from switch_core.bridges.resource.service import ResourceService
from switch_core.db.models import Package, User
from switch_core.db.stores.agent_store import AgentStore
-from switch_core.db.stores.room_store import RoomStore
+from switch_core.db.stores.room_store import RoomStore, readable_by
from switch_core.db.stores.user_store import UserStore
from switch_core.gateway.auth import (
get_current_user,
get_tenant_is_admin,
- readable_room_ids,
require_room_access,
+ require_room_unlink,
)
from switch_core.gateway.dependencies import (
get_agent_store,
@@ -25,6 +26,7 @@ from switch_core.gateway.dependencies import (
)
from switch_core.gateway.documents import _enrich_summaries as enrich_doc_summaries
from switch_core.gateway.references import _enrich as enrich_refs
+from switch_core.gateway.resource_rooms import resource_rooms, room_counts
from switch_core.gateway.schemas import (
DocumentSummary,
PackageCreateRequest,
@@ -46,6 +48,7 @@ def _to_detail(
references_count: int = 0,
documents_count: int = 0,
attached_rooms_count: int = 0,
+ hidden_rooms_count: int,
) -> PackageDetail:
return PackageDetail(
id=pkg.id,
@@ -59,6 +62,7 @@ def _to_detail(
references_count=references_count,
documents_count=documents_count,
attached_rooms_count=attached_rooms_count,
+ hidden_rooms_count=hidden_rooms_count,
created_at=str(pkg.created_at),
)
@@ -68,11 +72,14 @@ async def _enrich(
pkgs: list[Package],
resource_service: ResourceService,
user_store: UserStore,
+ reader: Principal,
) -> list[PackageDetail]:
if not pkgs:
return []
ids = [p.id for p in pkgs]
- room_counts = await resource_service.get_package_attached_counts(session, ids)
+ rooms = await room_counts(
+ session, pkgs, reader, resource_service.get_package_attached_counts
+ )
ref_counts = await resource_service.get_package_reference_counts(session, ids)
doc_counts = await resource_service.get_package_document_counts(session, ids)
owner_ids = list({p.owner_id for p in pkgs})
@@ -87,7 +94,8 @@ async def _enrich(
owner_name=owners.get(p.owner_id),
references_count=ref_counts.get(p.id, 0),
documents_count=doc_counts.get(p.id, 0),
- attached_rooms_count=room_counts.get(p.id, 0),
+ attached_rooms_count=rooms[p.id].attached,
+ hidden_rooms_count=rooms[p.id].hidden,
)
for p in pkgs
]
@@ -98,8 +106,9 @@ async def _enrich_one(
pkg: Package,
resource_service: ResourceService,
user_store: UserStore,
+ reader: Principal,
) -> PackageDetail:
- results = await _enrich(session, [pkg], resource_service, user_store)
+ results = await _enrich(session, [pkg], resource_service, user_store, reader)
return results[0]
@@ -109,9 +118,12 @@ async def list_packages(
resource_service: Annotated[ResourceService, Depends(get_resource_service)],
user_store: Annotated[UserStore, Depends(get_user_store)],
user: Annotated[User, Depends(get_current_user)],
+ is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> list[PackageDetail]:
pkgs = await resource_service.list_packages_for_user(session, user.id)
- return await _enrich(session, pkgs, resource_service, user_store)
+ return await _enrich(
+ session, pkgs, resource_service, user_store, Principal(user.id, is_admin)
+ )
@router.post("/packages", status_code=201)
@@ -121,6 +133,7 @@ async def create_package(
resource_service: Annotated[ResourceService, Depends(get_resource_service)],
user_store: Annotated[UserStore, Depends(get_user_store)],
user: Annotated[User, Depends(get_current_user)],
+ is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> PackageDetail:
try:
pkg = await resource_service.create_package(
@@ -135,7 +148,9 @@ async def create_package(
except ValueError as e:
raise HTTPException(status_code=400, detail=str(e)) from e
await session.commit()
- return await _enrich_one(session, pkg, resource_service, user_store)
+ return await _enrich_one(
+ session, pkg, resource_service, user_store, Principal(user.id, is_admin)
+ )
@router.get("/packages/{package_id}")
@@ -158,7 +173,9 @@ async def get_package(
raise HTTPException(status_code=404, detail=str(e)) from e
except PermissionError as e:
raise HTTPException(status_code=403, detail=str(e)) from e
- return await _enrich_one(session, pkg, resource_service, user_store)
+ return await _enrich_one(
+ session, pkg, resource_service, user_store, Principal(user.id, is_admin)
+ )
@router.patch("/packages/{package_id}")
@@ -188,7 +205,9 @@ async def patch_package(
except PermissionError as e:
raise HTTPException(status_code=403, detail=str(e)) from e
await session.commit()
- return await _enrich_one(session, pkg, resource_service, user_store)
+ return await _enrich_one(
+ session, pkg, resource_service, user_store, Principal(user.id, is_admin)
+ )
@router.delete("/packages/{package_id}")
@@ -234,13 +253,12 @@ async def list_rooms_for_package(
raise HTTPException(status_code=404, detail=str(e)) from e
except PermissionError as e:
raise HTTPException(status_code=403, detail=str(e)) from e
- rows = await resource_service.list_rooms_for_package(session, package_id)
- readable = await readable_room_ids(session, room_store, user, is_admin)
- return [
- ResourceRoom(room_id=rid, room_name=name)
- for rid, name in rows
- if rid in readable
- ]
+ rooms = await resource_service.list_rooms_for_package(
+ session, package_id, reader_id=user.id, reader_is_admin=is_admin
+ )
+ return await resource_rooms(
+ session, room_store, rooms, Principal(user.id, is_admin)
+ )
# ── Membership ────────────────────────────────────────────────────────────
@@ -267,7 +285,9 @@ async def list_package_references(
except PermissionError as e:
raise HTTPException(status_code=403, detail=str(e)) from e
refs = await resource_service.list_package_references(session, package_id)
- return await enrich_refs(session, refs, resource_service, user_store)
+ return await enrich_refs(
+ session, refs, resource_service, user_store, Principal(user.id, is_admin)
+ )
@router.post("/packages/{package_id}/references/{reference_id}", status_code=201)
@@ -300,6 +320,7 @@ async def remove_reference_from_package(
reference_id: str,
session: Annotated[AsyncSession, Depends(get_session)],
resource_service: Annotated[ResourceService, Depends(get_resource_service)],
+ room_store: Annotated[RoomStore, Depends(get_room_store)],
user: Annotated[User, Depends(get_current_user)],
is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> PackageMemberRemoveResponse:
@@ -316,11 +337,8 @@ async def remove_reference_from_package(
except PermissionError as e:
raise HTTPException(status_code=403, detail=str(e)) from e
await session.commit()
- return PackageMemberRemoveResponse(
- package_id=package_id,
- member_id=reference_id,
- affected_room_ids=[rid for rid, _ in affected],
- affected_room_names=[name for _, name in affected],
+ return await _member_removed(
+ session, room_store, package_id, reference_id, affected, user, is_admin
)
@@ -347,7 +365,12 @@ async def list_package_documents(
raise HTTPException(status_code=403, detail=str(e)) from e
docs = await resource_service.list_package_documents(session, package_id)
return await enrich_doc_summaries(
- session, docs, resource_service, user_store, agent_store
+ session,
+ docs,
+ resource_service,
+ user_store,
+ agent_store,
+ Principal(user.id, is_admin),
)
@@ -381,6 +404,7 @@ async def remove_document_from_package(
document_id: str,
session: Annotated[AsyncSession, Depends(get_session)],
resource_service: Annotated[ResourceService, Depends(get_resource_service)],
+ room_store: Annotated[RoomStore, Depends(get_room_store)],
user: Annotated[User, Depends(get_current_user)],
is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> PackageMemberRemoveResponse:
@@ -397,11 +421,8 @@ async def remove_document_from_package(
except PermissionError as e:
raise HTTPException(status_code=403, detail=str(e)) from e
await session.commit()
- return PackageMemberRemoveResponse(
- package_id=package_id,
- member_id=document_id,
- affected_room_ids=[rid for rid, _ in affected],
- affected_room_names=[name for _, name in affected],
+ return await _member_removed(
+ session, room_store, package_id, document_id, affected, user, is_admin
)
@@ -420,7 +441,9 @@ async def list_room_packages(
) -> list[PackageDetail]:
await require_room_access(session, room_store, room_id, user, "read", is_admin)
pkgs = await resource_service.list_room_packages(session, room_id)
- return await _enrich(session, pkgs, resource_service, user_store)
+ return await _enrich(
+ session, pkgs, resource_service, user_store, Principal(user.id, is_admin)
+ )
@router.post("/rooms/{room_id}/packages/{package_id}", status_code=201)
@@ -454,7 +477,9 @@ async def attach_package_to_room(
user.id,
is_admin=is_admin,
)
- return await _enrich_one(session, pkg, resource_service, user_store)
+ return await _enrich_one(
+ session, pkg, resource_service, user_store, Principal(user.id, is_admin)
+ )
@router.delete("/rooms/{room_id}/packages/{package_id}", status_code=204)
@@ -467,6 +492,31 @@ async def detach_package_from_room(
user: Annotated[User, Depends(get_current_user)],
is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> None:
- await require_room_access(session, room_store, room_id, user, "write", is_admin)
+ await require_room_unlink(session, room_store, room_id, user, is_admin)
await resource_service.detach_package_from_room(session, room_id, package_id)
await session.commit()
+
+
+async def _member_removed(
+ session: AsyncSession,
+ room_store: RoomStore,
+ package_id: str,
+ member_id: str,
+ affected: list[tuple[str, str]],
+ user: User,
+ is_admin: bool,
+) -> PackageMemberRemoveResponse:
+ """Name the affected rooms the caller may read, and count the rest."""
+ readable = await room_store.visible_room_ids(
+ session,
+ [rid for rid, _ in affected],
+ readable_by(user.id, is_admin=is_admin),
+ )
+ shown = [(rid, name) for rid, name in affected if rid in readable]
+ return PackageMemberRemoveResponse(
+ package_id=package_id,
+ member_id=member_id,
+ affected_room_ids=[rid for rid, _ in shown],
+ affected_room_names=[name for _, name in shown],
+ hidden_affected_rooms_count=len(affected) - len(shown),
+ )
diff --git a/core/switch_core/gateway/references.py b/core/switch_core/gateway/references.py
index 179716238..095e230c1 100644
--- a/core/switch_core/gateway/references.py
+++ b/core/switch_core/gateway/references.py
@@ -5,6 +5,7 @@ from typing import Annotated
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.ext.asyncio import AsyncSession
+from switch_core.authz import Principal
from switch_core.bridges.resource.registry import ReferenceValue, is_builtin_type
from switch_core.bridges.resource.service import (
ReferenceTypeInUseError,
@@ -18,8 +19,8 @@ from switch_core.db.stores.user_store import UserStore
from switch_core.gateway.auth import (
get_current_user,
get_tenant_is_admin,
- readable_room_ids,
require_room_access,
+ require_room_unlink,
)
from switch_core.gateway.dependencies import (
get_resource_service,
@@ -27,6 +28,7 @@ from switch_core.gateway.dependencies import (
get_session,
get_user_store,
)
+from switch_core.gateway.resource_rooms import resource_rooms, room_counts
from switch_core.gateway.schemas import (
ReferenceCreateRequest,
ReferenceDeleteResponse,
@@ -49,6 +51,7 @@ def _to_detail(
owner_name: str | None = None,
type_display_name: str | None = None,
attached_rooms_count: int = 0,
+ hidden_rooms_count: int,
packages: list[str] | None = None,
) -> ReferenceDetail:
return ReferenceDetail(
@@ -63,6 +66,7 @@ def _to_detail(
instructions=ref.instructions,
value=ref.value,
attached_rooms_count=attached_rooms_count,
+ hidden_rooms_count=hidden_rooms_count,
packages=packages or [],
created_at=str(ref.created_at),
type_display_name=type_display_name,
@@ -74,11 +78,12 @@ async def _enrich(
refs: list[Reference],
resource_service: ResourceService,
user_store: UserStore,
+ reader: Principal,
) -> list[ReferenceDetail]:
if not refs:
return []
- counts = await resource_service.get_reference_attached_counts(
- session, [r.id for r in refs]
+ counts = await room_counts(
+ session, refs, reader, resource_service.get_reference_attached_counts
)
pkg_map = await resource_service.get_packages_for_references(
session, [r.id for r in refs]
@@ -97,7 +102,8 @@ async def _enrich(
r,
owner_name=owners.get(r.owner_id),
type_display_name=type_names.get(r.type),
- attached_rooms_count=counts.get(r.id, 0),
+ attached_rooms_count=counts[r.id].attached,
+ hidden_rooms_count=counts[r.id].hidden,
packages=pkg_map.get(r.id, []),
)
for r in refs
@@ -109,8 +115,9 @@ async def _enrich_one(
ref: Reference,
resource_service: ResourceService,
user_store: UserStore,
+ reader: Principal,
) -> ReferenceDetail:
- results = await _enrich(session, [ref], resource_service, user_store)
+ results = await _enrich(session, [ref], resource_service, user_store, reader)
return results[0]
@@ -293,9 +300,12 @@ async def list_references(
resource_service: Annotated[ResourceService, Depends(get_resource_service)],
user_store: Annotated[UserStore, Depends(get_user_store)],
user: Annotated[User, Depends(get_current_user)],
+ is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> list[ReferenceDetail]:
refs = await resource_service.list_references_for_user(session, user.id)
- return await _enrich(session, refs, resource_service, user_store)
+ return await _enrich(
+ session, refs, resource_service, user_store, Principal(user.id, is_admin)
+ )
@router.post("/references", status_code=201)
@@ -323,7 +333,9 @@ async def create_reference(
except ValueError as e:
raise HTTPException(status_code=400, detail=str(e)) from e
await session.commit()
- return await _enrich_one(session, ref, resource_service, user_store)
+ return await _enrich_one(
+ session, ref, resource_service, user_store, Principal(user.id, is_admin)
+ )
@router.get("/references/{reference_id}")
@@ -346,7 +358,9 @@ async def get_reference(
raise HTTPException(status_code=404, detail=str(e)) from e
except PermissionError as e:
raise HTTPException(status_code=403, detail=str(e)) from e
- return await _enrich_one(session, ref, resource_service, user_store)
+ return await _enrich_one(
+ session, ref, resource_service, user_store, Principal(user.id, is_admin)
+ )
@router.patch("/references/{reference_id}")
@@ -377,7 +391,9 @@ async def patch_reference(
except PermissionError as e:
raise HTTPException(status_code=403, detail=str(e)) from e
await session.commit()
- return await _enrich_one(session, ref, resource_service, user_store)
+ return await _enrich_one(
+ session, ref, resource_service, user_store, Principal(user.id, is_admin)
+ )
@router.delete("/references/{reference_id}")
@@ -430,13 +446,12 @@ async def list_rooms_for_reference(
raise HTTPException(status_code=404, detail=str(e)) from e
except PermissionError as e:
raise HTTPException(status_code=403, detail=str(e)) from e
- rows = await resource_service.list_rooms_for_reference(session, reference_id)
- readable = await readable_room_ids(session, room_store, user, is_admin)
- return [
- ResourceRoom(room_id=rid, room_name=name)
- for rid, name in rows
- if rid in readable
- ]
+ rooms = await resource_service.list_rooms_for_reference(
+ session, reference_id, reader_id=user.id, reader_is_admin=is_admin
+ )
+ return await resource_rooms(
+ session, room_store, rooms, Principal(user.id, is_admin)
+ )
@router.get("/rooms/{room_id}/references")
@@ -451,7 +466,9 @@ async def list_room_references(
) -> list[ReferenceDetail]:
await require_room_access(session, room_store, room_id, user, "read", is_admin)
refs = await resource_service.list_room_references(session, room_id)
- return await _enrich(session, refs, resource_service, user_store)
+ return await _enrich(
+ session, refs, resource_service, user_store, Principal(user.id, is_admin)
+ )
@router.post("/rooms/{room_id}/references/{reference_id}", status_code=201)
@@ -482,7 +499,9 @@ async def attach_reference_to_room(
ref = await resource_service.get_reference_for_user(
session, reference_id, user.id, is_admin=is_admin
)
- return await _enrich_one(session, ref, resource_service, user_store)
+ return await _enrich_one(
+ session, ref, resource_service, user_store, Principal(user.id, is_admin)
+ )
@router.delete("/rooms/{room_id}/references/{reference_id}", status_code=204)
@@ -495,6 +514,6 @@ async def detach_reference_from_room(
user: Annotated[User, Depends(get_current_user)],
is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> None:
- await require_room_access(session, room_store, room_id, user, "write", is_admin)
+ await require_room_unlink(session, room_store, room_id, user, is_admin)
await resource_service.detach_reference_from_room(session, room_id, reference_id)
await session.commit()
diff --git a/core/switch_core/gateway/resource_rooms.py b/core/switch_core/gateway/resource_rooms.py
new file mode 100644
index 000000000..e0c25f7d0
--- /dev/null
+++ b/core/switch_core/gateway/resource_rooms.py
@@ -0,0 +1,93 @@
+"""The rooms a reference, document or package is in, as told to the person
+looking at it.
+
+A room the viewer may not read is never named to them. Whoever may manage the
+resource (its owner, or a tenant admin) is still told how many such rooms it
+is in, so they can see how widely it is used and what deleting it touches.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Sequence
+from dataclasses import dataclass
+from typing import Protocol
+
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from switch_core.authz import Authorizable, Principal, can, can_unlink_from_room
+from switch_core.db.stores.room_store import AttachedRooms, RoomStore
+from switch_core.gateway.schemas import ResourceRoom
+
+
+class _Resource(Authorizable, Protocol):
+ @property
+ def id(self) -> str: ...
+
+
+class _CountAttached(Protocol):
+ """`ResourceService.get_{reference,document,package}_attached_counts`."""
+
+ def __call__(
+ self,
+ session: AsyncSession,
+ ids: list[str],
+ /,
+ *,
+ reader_id: str | None,
+ reader_is_admin: bool,
+ ) -> Awaitable[dict[str, AttachedRooms]]: ...
+
+
+@dataclass(frozen=True)
+class RoomCounts:
+ # The rooms the viewer is told the resource is in.
+ attached: int
+ # Of those, how many the viewer may not read. Never more than zero for
+ # someone who may not manage the resource, since those rooms are not
+ # counted for them at all.
+ hidden: int
+
+
+async def room_counts(
+ session: AsyncSession,
+ resources: Sequence[_Resource],
+ reader: Principal,
+ count: _CountAttached,
+) -> dict[str, RoomCounts]:
+ attached = await count(
+ session,
+ [r.id for r in resources],
+ reader_id=reader.id,
+ reader_is_admin=reader.is_admin,
+ )
+ counts: dict[str, RoomCounts] = {}
+ for r in resources:
+ rooms = attached[r.id]
+ if can(reader, "delete", r):
+ counts[r.id] = RoomCounts(rooms.every, rooms.every - rooms.readable)
+ else:
+ counts[r.id] = RoomCounts(rooms.readable, 0)
+ return counts
+
+
+async def resource_rooms(
+ session: AsyncSession,
+ room_store: RoomStore,
+ rooms: list[tuple[str, str]],
+ reader: Principal,
+) -> list[ResourceRoom]:
+ """`rooms` (id, name), already limited to those `reader` may read, each
+ saying whether `reader` may unlink the resource from it."""
+ taking_part: set[str] = set()
+ if not reader.is_admin and reader.id is not None:
+ taking_part = await room_store.involved_room_ids(
+ session, reader.id, [rid for rid, _ in rooms]
+ )
+ return [
+ ResourceRoom(
+ room_id=rid,
+ room_name=name,
+ can_unlink=can_unlink_from_room(reader, takes_part=rid in taking_part),
+ )
+ for rid, name in rooms
+ ]
diff --git a/core/switch_core/gateway/rooms.py b/core/switch_core/gateway/rooms.py
index 07f102526..dba305ec7 100644
--- a/core/switch_core/gateway/rooms.py
+++ b/core/switch_core/gateway/rooms.py
@@ -10,7 +10,12 @@ from pydantic import BaseModel, ConfigDict, Field
from sqlalchemy.ext.asyncio import AsyncSession
from switch_core.agent_templates import plan_template
-from switch_core.authz import Action, Principal, can, require, require_manage
+from switch_core.authz import (
+ Action,
+ Principal,
+ can,
+ can_unlink_from_room,
+)
from switch_core.bridges.agent.operations.agent_management import management_port
from switch_core.bridges.agent.protocol.agent_core import AgentCore
from switch_core.bridges.collaboration.models import (
@@ -28,7 +33,12 @@ from switch_core.db.stores.room_store import LINKED_CHANNEL_NAME_KEY, RoomStore
from switch_core.db.stores.template_store import TemplateStore
from switch_core.db.stores.user_store import UserStore
from switch_core.feature_flags import AGENT_MANAGEMENT, SWITCH_BUDDY
-from switch_core.gateway.auth import get_current_user, get_tenant_is_admin
+from switch_core.gateway.auth import (
+ authorize_room,
+ get_current_user,
+ get_tenant_is_admin,
+ takes_part_in_room,
+)
from switch_core.gateway.dependencies import (
current_telemetry,
get_bridge_store,
@@ -92,43 +102,14 @@ logger = logging.getLogger(__name__)
router = APIRouter()
-async def _require_room(
- session: AsyncSession,
- room_store: RoomStore,
- room_id: str,
- user: User,
- action: Action,
- is_admin: bool,
-) -> Room:
- """Load a room (404 if missing) and authorize `action` for `user`,
- raising HTTP 403 if denied."""
- room = await room_store.get(session, room_id)
- if room is None:
- raise HTTPException(status_code=404, detail="Room not found")
- try:
- require(
- Principal(user.id, is_admin),
- action,
- room,
- )
- except PermissionError as e:
- # Whoever takes part in a room may read it, as its listing shows them.
- if action != "read" or not await room_store.involved_room_ids(
- session, user.id, [room.id]
- ):
- raise HTTPException(status_code=403, detail=str(e)) from e
- return room
-
-
async def _require_room_released(
session: AsyncSession,
room_store: RoomStore,
room_id: str,
- user: User,
+ principal: Principal,
action: Action,
- is_admin: bool,
) -> Room:
- """`_require_room`, then end the read's transaction.
+ """`authorize_room`, then end the read's transaction.
For a route that goes on to call `RoomService` or `RoomYamlService`, which
open sessions of their own and may call Matrix or a messaging platform.
@@ -137,7 +118,7 @@ async def _require_room_released(
request that is waiting for one more. The room stays readable after the
commit (`expire_on_commit=False`).
"""
- room = await _require_room(session, room_store, room_id, user, action, is_admin)
+ room = await authorize_room(session, room_store, room_id, principal, action)
await session.commit()
return room
@@ -181,6 +162,7 @@ async def _build_room_detail(
bridge_store: CollaborationBridgeStore,
external_user_store: ExternalUserStore,
protocol: AgentCore,
+ principal: Principal,
) -> RoomDetail:
agent_ids = await room_store.get_agent_ids(session, room.id)
client_ids = await room_store.get_client_ids(session, room.id)
@@ -214,6 +196,7 @@ async def _build_room_detail(
roles = await _list_room_role_details(session, room.id, protocol)
join_event_listeners = await room_store.get_join_event_listeners(session, room.id)
+ takes_part = await takes_part_in_room(session, room_store, room.id, principal.id)
# Not held across the deeplink, which can ask the platform on a cache miss.
await session.commit()
external_channel_url = await _external_channel_url(room)
@@ -256,6 +239,9 @@ async def _build_room_detail(
if room.external_channel_id
else None
),
+ can_write=can(principal, "write", room),
+ can_manage=can(principal, "delete", room),
+ can_unlink=can_unlink_from_room(principal, takes_part=takes_part),
)
@@ -361,6 +347,7 @@ async def list_rooms(
# Not held across the deeplinks, which can ask the platform on a cache miss.
await session.commit()
+ principal = Principal(user.id, is_admin)
summaries = []
for room in rooms:
connected_names = sorted(
@@ -397,6 +384,11 @@ async def list_rooms(
archived=room.archived_at is not None,
viewer_is_member=room.id in involved,
is_console_chat="chat_operation_id" in (room.metadata_ or {}),
+ can_write=can(principal, "write", room),
+ can_manage=can(principal, "delete", room),
+ can_unlink=can_unlink_from_room(
+ principal, takes_part=room.id in involved
+ ),
)
)
@@ -413,6 +405,7 @@ async def create_room(
external_user_store: Annotated[ExternalUserStore, Depends(get_external_user_store)],
protocol: Annotated[AgentCore, Depends(get_protocol)],
user: Annotated[User, Depends(get_current_user)],
+ is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> RoomDetail:
_validate_create(req)
config = RoomCreateConfig(
@@ -449,7 +442,13 @@ async def create_room(
if fresh is None:
raise HTTPException(status_code=500, detail="Room missing after create")
return await _build_room_detail(
- session, fresh, room_store, bridge_store, external_user_store, protocol
+ session,
+ fresh,
+ room_store,
+ bridge_store,
+ external_user_store,
+ protocol,
+ Principal(user.id, is_admin),
)
@@ -867,7 +866,8 @@ async def export_room_yaml(
) -> Response:
"""Export a room to YAML in the same surface ``/rooms/from-yaml`` accepts.
Each section can be dropped via its boolean toggle (default included)."""
- await _require_room_released(session, room_store, room_id, user, "read", is_admin)
+ principal = Principal(user.id, is_admin)
+ await _require_room_released(session, room_store, room_id, principal, "read")
yaml_text = await rooms_yaml.export(
room_id,
agents=agents,
@@ -891,9 +891,16 @@ async def get_room(
user: Annotated[User, Depends(get_current_user)],
is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> RoomDetail:
- room = await _require_room(session, room_store, room_id, user, "read", is_admin)
+ principal = Principal(user.id, is_admin)
+ room = await authorize_room(session, room_store, room_id, principal, "read")
return await _build_room_detail(
- session, room, room_store, bridge_store, external_user_store, protocol
+ session,
+ room,
+ room_store,
+ bridge_store,
+ external_user_store,
+ protocol,
+ principal,
)
@@ -910,18 +917,20 @@ async def patch_room(
user: Annotated[User, Depends(get_current_user)],
is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> RoomDetail:
+ principal = Principal(user.id, is_admin)
target = await _require_room_released(
- session, room_store, room_id, user, "write", is_admin
+ session, room_store, room_id, principal, "write"
)
# Changing a room's access permission (read/write visibility) is reserved
# for the room's owner and tenant admins — plain write access (which a
# publicly-writable room grants to everyone) is not enough. Otherwise any
- # user could re-permission any room and lock out its owner.
- if req.read_visibility is not None or req.write_visibility is not None:
- try:
- require_manage(Principal(user.id, is_admin), target.owner_id)
- except PermissionError as e:
- raise HTTPException(status_code=403, detail=str(e)) from e
+ # user could re-permission any room and lock out its owner. It is the rule
+ # for deleting the room, asked the same way so `can_manage` cannot drift.
+ changes_access = req.read_visibility is not None or req.write_visibility is not None
+ if changes_access and not can(principal, "delete", target):
+ raise HTTPException(
+ status_code=403, detail="Not authorized to change this room's access"
+ )
try:
await room_service.update_room(
room_id,
@@ -942,7 +951,13 @@ async def patch_room(
# as it was read for the access check.
await session.refresh(room)
return await _build_room_detail(
- session, room, room_store, bridge_store, external_user_store, protocol
+ session,
+ room,
+ room_store,
+ bridge_store,
+ external_user_store,
+ protocol,
+ principal,
)
@@ -955,7 +970,8 @@ async def list_room_roles(
user: Annotated[User, Depends(get_current_user)],
is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> list[RoomRoleDetail]:
- await _require_room(session, room_store, room_id, user, "read", is_admin)
+ principal = Principal(user.id, is_admin)
+ await authorize_room(session, room_store, room_id, principal, "read")
return await _list_room_role_details(session, room_id, protocol)
@@ -969,7 +985,8 @@ async def create_room_role(
user: Annotated[User, Depends(get_current_user)],
is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> list[RoomRoleDetail]:
- await _require_room(session, room_store, room_id, user, "write", is_admin)
+ principal = Principal(user.id, is_admin)
+ await authorize_room(session, room_store, room_id, principal, "write")
try:
await protocol.room_role_store.define_role(
session, room_id, req.name, req.instructions, req.exclusive
@@ -998,7 +1015,8 @@ async def patch_room_role(
user: Annotated[User, Depends(get_current_user)],
is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> list[RoomRoleDetail]:
- await _require_room(session, room_store, room_id, user, "write", is_admin)
+ principal = Principal(user.id, is_admin)
+ await authorize_room(session, room_store, room_id, principal, "write")
try:
await protocol.room_role_store.edit_role(
session, room_id, name, req.instructions, req.exclusive
@@ -1019,7 +1037,8 @@ async def delete_room_role(
user: Annotated[User, Depends(get_current_user)],
is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> list[RoomRoleDetail]:
- await _require_room(session, room_store, room_id, user, "write", is_admin)
+ principal = Principal(user.id, is_admin)
+ await authorize_room(session, room_store, room_id, principal, "write")
try:
await protocol.room_role_store.delete_role(session, room_id, name)
emit_safely(current_telemetry(), "room_role_deleted", {})
@@ -1042,7 +1061,8 @@ async def put_room_group(
is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> RoomDetail:
"""Assign the room to a group, or make it standalone (`group_id=null`)."""
- await _require_room(session, room_store, room_id, user, "write", is_admin)
+ principal = Principal(user.id, is_admin)
+ await authorize_room(session, room_store, room_id, principal, "write")
try:
await room_store.set_group(session, room_id, req.group_id)
except ValueError as e:
@@ -1055,7 +1075,13 @@ async def put_room_group(
if room is None:
raise HTTPException(status_code=404, detail="Room not found")
return await _build_room_detail(
- session, room, room_store, bridge_store, external_user_store, protocol
+ session,
+ room,
+ room_store,
+ bridge_store,
+ external_user_store,
+ protocol,
+ principal,
)
@@ -1072,7 +1098,8 @@ async def put_protection(
user: Annotated[User, Depends(get_current_user)],
is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> RoomDetail:
- await _require_room_released(session, room_store, room_id, user, "write", is_admin)
+ principal = Principal(user.id, is_admin)
+ await _require_room_released(session, room_store, room_id, principal, "write")
try:
await room_service.update_protection_config(room_id, req.protection_config)
except ValueError:
@@ -1082,7 +1109,13 @@ async def put_protection(
if room is None:
raise HTTPException(status_code=404, detail="Room not found")
return await _build_room_detail(
- session, room, room_store, bridge_store, external_user_store, protocol
+ session,
+ room,
+ room_store,
+ bridge_store,
+ external_user_store,
+ protocol,
+ principal,
)
@@ -1099,7 +1132,8 @@ async def put_observe(
user: Annotated[User, Depends(get_current_user)],
is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> RoomDetail:
- await _require_room_released(session, room_store, room_id, user, "write", is_admin)
+ principal = Principal(user.id, is_admin)
+ await _require_room_released(session, room_store, room_id, principal, "write")
try:
await room_service.update_observe_config(room_id, req.observe_config)
except ValueError:
@@ -1109,7 +1143,13 @@ async def put_observe(
if room is None:
raise HTTPException(status_code=404, detail="Room not found")
return await _build_room_detail(
- session, room, room_store, bridge_store, external_user_store, protocol
+ session,
+ room,
+ room_store,
+ bridge_store,
+ external_user_store,
+ protocol,
+ principal,
)
@@ -1126,7 +1166,8 @@ async def post_room_agents(
user: Annotated[User, Depends(get_current_user)],
is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> RoomDetail:
- await _require_room_released(session, room_store, room_id, user, "write", is_admin)
+ principal = Principal(user.id, is_admin)
+ await _require_room_released(session, room_store, room_id, principal, "write")
try:
await room_service.add_agents_to_room(
room_id,
@@ -1141,7 +1182,13 @@ async def post_room_agents(
if room is None:
raise HTTPException(status_code=404, detail="Room not found")
return await _build_room_detail(
- session, room, room_store, bridge_store, external_user_store, protocol
+ session,
+ room,
+ room_store,
+ bridge_store,
+ external_user_store,
+ protocol,
+ principal,
)
@@ -1159,7 +1206,8 @@ async def patch_room_agent(
user: Annotated[User, Depends(get_current_user)],
is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> RoomDetail:
- await _require_room_released(session, room_store, room_id, user, "write", is_admin)
+ principal = Principal(user.id, is_admin)
+ await _require_room_released(session, room_store, room_id, principal, "write")
try:
await room_service.set_join_event_listeners(
room_id, {agent_id: req.receives_join_events}
@@ -1170,7 +1218,13 @@ async def patch_room_agent(
if room is None:
raise HTTPException(status_code=404, detail="Room not found")
return await _build_room_detail(
- session, room, room_store, bridge_store, external_user_store, protocol
+ session,
+ room,
+ room_store,
+ bridge_store,
+ external_user_store,
+ protocol,
+ principal,
)
@@ -1187,7 +1241,8 @@ async def delete_room_agent(
user: Annotated[User, Depends(get_current_user)],
is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> RoomDetail:
- await _require_room_released(session, room_store, room_id, user, "write", is_admin)
+ principal = Principal(user.id, is_admin)
+ await _require_room_released(session, room_store, room_id, principal, "write")
try:
await room_service.remove_agents_from_room(room_id, [agent_id])
except ValueError as e:
@@ -1197,7 +1252,13 @@ async def delete_room_agent(
if room is None:
raise HTTPException(status_code=404, detail="Room not found")
return await _build_room_detail(
- session, room, room_store, bridge_store, external_user_store, protocol
+ session,
+ room,
+ room_store,
+ bridge_store,
+ external_user_store,
+ protocol,
+ principal,
)
@@ -1214,7 +1275,8 @@ async def post_room_users(
user: Annotated[User, Depends(get_current_user)],
is_admin: Annotated[bool, Depends(get_tenant_is_admin)],
) -> RoomDetail:
- await _require_room_released(session, room_store, room_id, user, "write", is_admin)
+ principal = Principal(user.id, is_admin)
+ await _require_room_released(session, room_store, room_id, principal, "write")
try:
await room_service.add_users_to_room(room_id, req.user_names)
except ValueError as e:
@@ -1224,7 +1286,13 @@ async def post_room_users(
if room is None:
raise HTTPException(status_code=404, detail="Room not found")
return await _build_room_detail(
- session, room, room_store, bridge_store, external_user_store, protocol
+ session,
+ room,
+ room_store,
+ bridge_store,
+ external_user_store,
+ protocol,
+ principal,
)
@@ -1240,7 +1308,8 @@ async def _set_archived(
user: User,
is_admin: bool,
) -> RoomDetail:
- await _require_room_released(session, room_store, room_id, user, "write", is_admin)
+ principal = Principal(user.id, is_admin)
+ await _require_room_released(session, room_store, room_id, principal, "write")
try:
await room_service.set_room_archived(room_id, archived)
except ValueError:
@@ -1249,7 +1318,13 @@ async def _set_archived(
if room is None:
raise HTTPException(status_code=404, detail="Room not found")
return await _build_room_detail(
- session, room, room_store, bridge_store, external_user_store, protocol
+ session,
+ room,
+ room_store,
+ bridge_store,
+ external_user_store,
+ protocol,
+ principal,
)
@@ -1268,7 +1343,8 @@ async def sync_room_name(
"""Name the room after its linked channel (`linked_channel_name`), as the
bridge names its own rooms, so it follows the channel's renames from now
on. The room's owner or an admin only."""
- room = await _require_room(session, room_store, room_id, user, "delete", is_admin)
+ principal = Principal(user.id, is_admin)
+ room = await authorize_room(session, room_store, room_id, principal, "delete")
channel_name = (room.metadata_ or {}).get(LINKED_CHANNEL_NAME_KEY)
bridge = await bridge_store.get(session, room.bridge_id) if room.bridge_id else None
if not room.external_channel_id or bridge is None or not channel_name:
@@ -1283,7 +1359,13 @@ async def sync_room_name(
)
await session.refresh(room)
return await _build_room_detail(
- session, room, room_store, bridge_store, external_user_store, protocol
+ session,
+ room,
+ room_store,
+ bridge_store,
+ external_user_store,
+ protocol,
+ principal,
)
@@ -1355,7 +1437,8 @@ async def delete_room(
# they keep using.
retire_channel: Annotated[bool, Query()] = False,
) -> RoomDeleteResponse:
- await _require_room_released(session, room_store, room_id, user, "delete", is_admin)
+ principal = Principal(user.id, is_admin)
+ await _require_room_released(session, room_store, room_id, principal, "delete")
try:
channel = await room_service.delete_room(room_id, retire_channel=retire_channel)
except ValueError:
diff --git a/core/switch_core/gateway/schemas.py b/core/switch_core/gateway/schemas.py
index 9ba4d74eb..440d4cf4f 100644
--- a/core/switch_core/gateway/schemas.py
+++ b/core/switch_core/gateway/schemas.py
@@ -90,6 +90,15 @@ class RoomSummary(BaseModel):
viewer_is_member: bool = False
# A Switch Console chat (made through the chats API): only its members can open it.
is_console_chat: bool = False
+ # What the caller may do with it, so a client offers a change only where
+ # the server would allow it. `can_write` covers its settings, roles,
+ # participants, links and attaching resources; `can_manage` (owner or
+ # tenant admin) covers its access, deleting it and taking the platform
+ # channel's name; `can_unlink` (taking part in it, or tenant admin) covers
+ # unlinking a reference, document or package from it.
+ can_write: bool
+ can_manage: bool
+ can_unlink: bool
class RoomDetail(RoomSummary):
@@ -1404,6 +1413,10 @@ class ReferenceDetail(BaseModel):
instructions: str
value: dict[str, Any]
attached_rooms_count: int = 0
+ # Of `attached_rooms_count`, rooms the caller may not read, which are
+ # never named to them. Counted only for whoever may manage the resource
+ # (`gateway/resource_rooms.py`); for anyone else those rooms are left out.
+ hidden_rooms_count: int = 0
packages: list[str] = []
created_at: str
# Resolved server-side, unfiltered by the type's visibility: the caller can
@@ -1501,6 +1514,9 @@ class ReferenceTypeDeleteResponse(BaseModel):
class ResourceRoom(BaseModel):
room_id: str
room_name: str
+ # Whether the caller may unlink the resource from this room: they take
+ # part in it, or are a tenant admin.
+ can_unlink: bool
# ── Linked rooms ───────────────────────────────────────────────────────────
@@ -1599,6 +1615,10 @@ class DocumentDetail(BaseModel):
instructions: str
content: str
attached_rooms_count: int = 0
+ # Of `attached_rooms_count`, rooms the caller may not read, which are
+ # never named to them. Counted only for whoever may manage the resource
+ # (`gateway/resource_rooms.py`); for anyone else those rooms are left out.
+ hidden_rooms_count: int = 0
packages: list[str] = []
scope: str = "global" # "global" | "room"
room_id: str | None = None
@@ -1607,6 +1627,17 @@ class DocumentDetail(BaseModel):
created_at: str
+# Whether the caller may remove a document from a room it is in: delete it if
+# it is room-scoped (its creator, the room's owner, a tenant admin), unlink it
+# if it is attached (those taking part in the room, a tenant admin).
+
+
+class RoomDocumentDetail(DocumentDetail):
+ """A document as seen from a room it is in."""
+
+ can_remove: bool
+
+
class DocumentSummary(BaseModel):
id: str
owner_id: str | None = None
@@ -1617,6 +1648,10 @@ class DocumentSummary(BaseModel):
description: str
instructions: str
attached_rooms_count: int = 0
+ # Of `attached_rooms_count`, rooms the caller may not read, which are
+ # never named to them. Counted only for whoever may manage the resource
+ # (`gateway/resource_rooms.py`); for anyone else those rooms are left out.
+ hidden_rooms_count: int = 0
packages: list[str] = []
scope: str = "global"
room_id: str | None = None
@@ -1625,6 +1660,12 @@ class DocumentSummary(BaseModel):
created_at: str
+class RoomDocumentSummary(DocumentSummary):
+ """A document as listed in a room it is in."""
+
+ can_remove: bool
+
+
class DocumentCreateRequest(BaseModel):
read_visibility: str = "private"
write_visibility: str = "private"
@@ -1664,6 +1705,10 @@ class PackageDetail(BaseModel):
references_count: int = 0
documents_count: int = 0
attached_rooms_count: int = 0
+ # Of `attached_rooms_count`, rooms the caller may not read, which are
+ # never named to them. Counted only for whoever may manage the resource
+ # (`gateway/resource_rooms.py`); for anyone else those rooms are left out.
+ hidden_rooms_count: int = 0
created_at: str
@@ -1691,8 +1736,12 @@ class PackageDeleteResponse(BaseModel):
class PackageMemberRemoveResponse(BaseModel):
package_id: str
member_id: str
+ # The rooms that lost sight of the member, of those the caller may read.
affected_room_ids: list[str]
affected_room_names: list[str]
+ # How many more lost sight of it among rooms the caller may not read,
+ # which are never named to them.
+ hidden_affected_rooms_count: int
# ── Templates ─────────────────────────────────────────────────────────────────
diff --git a/core/tests/switch_core/bridges/agent/protocol/test_agent_detail_mcp_tools.py b/core/tests/switch_core/bridges/agent/protocol/test_agent_detail_mcp_tools.py
index b99edffb4..600caa8ec 100644
--- a/core/tests/switch_core/bridges/agent/protocol/test_agent_detail_mcp_tools.py
+++ b/core/tests/switch_core/bridges/agent/protocol/test_agent_detail_mcp_tools.py
@@ -191,10 +191,11 @@ class TestGetAgentDetail:
async with session_factory() as session:
owner = await _make_user(session, "owner")
agent = await _make_agent(session, "target", owner_id=owner.id)
+ caller = await _make_agent(session, "caller", owner_id=owner.id)
await session.commit()
- agent_id = agent.id
+ agent_id, caller_id = agent.id, caller.id
- detail = await svc.get_agent_detail("caller", agent_id)
+ detail = await svc.get_agent_detail(caller_id, agent_id)
assert detail.name == "target"
assert detail.agent_type == "session_addressable"
assert detail.known_agent_type == "claude-code"
diff --git a/core/tests/switch_core/gateway/test_agent_can_manage_agents_route.py b/core/tests/switch_core/gateway/test_agent_can_manage_agents_route.py
index 163e9f7fb..c50d55d1f 100644
--- a/core/tests/switch_core/gateway/test_agent_can_manage_agents_route.py
+++ b/core/tests/switch_core/gateway/test_agent_can_manage_agents_route.py
@@ -42,6 +42,7 @@ async def _set(
connections=AgentConnectionRegistry(),
),
user,
+ False,
)
diff --git a/core/tests/switch_core/gateway/test_reference_types_routes.py b/core/tests/switch_core/gateway/test_reference_types_routes.py
index 58f81fb54..7780ebc02 100644
--- a/core/tests/switch_core/gateway/test_reference_types_routes.py
+++ b/core/tests/switch_core/gateway/test_reference_types_routes.py
@@ -491,7 +491,9 @@ class TestTypeDisplayName:
),
)
- listed = await list_references(session, svc, _USER_STORE, alice)
+ listed = await list_references(
+ session, svc, _USER_STORE, alice, await _is_admin(session, alice)
+ )
assert [r.type for r in listed] == ["never_registered"]
assert listed[0].type_display_name is None
diff --git a/core/tests/switch_core/gateway/test_room_create_platform_error.py b/core/tests/switch_core/gateway/test_room_create_platform_error.py
index 2f12c9064..4a1374506 100644
--- a/core/tests/switch_core/gateway/test_room_create_platform_error.py
+++ b/core/tests/switch_core/gateway/test_room_create_platform_error.py
@@ -61,6 +61,7 @@ async def _call(exc: Exception) -> HTTPException:
external_user_store=None, # type: ignore[arg-type]
protocol=None, # type: ignore[arg-type]
user=type("U", (), {"id": "u1"})(), # type: ignore[arg-type]
+ is_admin=False,
)
return excinfo.value
@@ -98,4 +99,5 @@ async def test_an_ordinary_bug_is_not_dressed_up_as_a_platform_refusal() -> None
external_user_store=None, # type: ignore[arg-type]
protocol=None, # type: ignore[arg-type]
user=type("U", (), {"id": "u1"})(), # type: ignore[arg-type]
+ is_admin=False,
)
diff --git a/core/tests/switch_core/gateway/test_room_detail_permissions.py b/core/tests/switch_core/gateway/test_room_detail_permissions.py
new file mode 100644
index 000000000..9b332035d
--- /dev/null
+++ b/core/tests/switch_core/gateway/test_room_detail_permissions.py
@@ -0,0 +1,165 @@
+"""A room's detail says what the caller may do with it (`can_write`,
+`can_manage`), by the same rules the routes enforce, so the dashboard offers a
+change only where the server would allow it. The route coroutine is called
+directly against real Postgres, as in `test_room_participant_read`."""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+from typing import Any
+
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from switch_core.db.models import Room, User, room_agents
+from switch_core.db.stores.agent_store import AgentStore
+from switch_core.db.stores.room_role_store import RoomRoleStore
+from switch_core.db.stores.room_store import RoomStore
+from switch_core.gateway import rooms as rooms_module
+from switch_core.gateway.schemas import RoomUpdateRequest
+from tests.switch_core.gateway.agent_route_harness import add_agent
+
+_ROOM_STORE = RoomStore()
+
+
+class _Protocol:
+ """The parts of `AgentCore` a room's detail reads: no agent is live."""
+
+ room_role_store = RoomRoleStore()
+ agent_store = AgentStore()
+ connections = SimpleNamespace(live_connection_ids=lambda: [])
+
+ async def get_agent_statuses_by_ids_in_session(
+ self, session: AsyncSession, room_id: str, agent_ids: list[str]
+ ) -> dict[str, object]:
+ return {}
+
+
+class _RoomService:
+ """Applies `update_room` on a session of its own, as `RoomService` does."""
+
+ def __init__(self, factory: async_sessionmaker[AsyncSession]) -> None:
+ self._factory = factory
+
+ async def update_room(self, room_id: str, **changes: Any) -> None:
+ async with self._factory() as session:
+ room = await session.get(Room, room_id)
+ assert room is not None
+ for field, value in changes.items():
+ if value is not None:
+ setattr(room, field, value)
+ await session.commit()
+
+
+async def _user(session: AsyncSession, name: str) -> User:
+ user = User(name=name, email=f"{name}@example.com", role="user")
+ session.add(user)
+ await session.flush()
+ return user
+
+
+async def _room(
+ session: AsyncSession,
+ name: str,
+ owner: User,
+ write_visibility: str,
+ read_visibility: str = "public",
+) -> Room:
+ room = Room(
+ transport_room_id=f"!{name}:test",
+ name=name,
+ description="",
+ owner_id=owner.id,
+ read_visibility=read_visibility,
+ write_visibility=write_visibility,
+ )
+ session.add(room)
+ await session.flush()
+ return room
+
+
+async def _permissions(
+ session: AsyncSession, room: Room, user: User, is_admin: bool
+) -> tuple[bool, bool]:
+ detail = await rooms_module.get_room(
+ room.id,
+ session,
+ _ROOM_STORE,
+ None, # type: ignore[arg-type]
+ None, # type: ignore[arg-type]
+ _Protocol(), # type: ignore[arg-type]
+ user,
+ is_admin,
+ )
+ return detail.can_write, detail.can_manage
+
+
+async def test_room_detail_reports_what_the_caller_may_do(
+ session_factory: async_sessionmaker[AsyncSession],
+) -> None:
+ async with session_factory() as session:
+ owner = await _user(session, "owner")
+ admin = await _user(session, "admin")
+ member = await _user(session, "member")
+ public = await _room(session, "public", owner, write_visibility="public")
+ read_only = await _room(session, "read-only", owner, write_visibility="private")
+ await session.commit()
+
+ # Public write lets anyone edit the room, but its access and deleting
+ # it stay with the owner and admins.
+ assert await _permissions(session, public, owner, False) == (True, True)
+ assert await _permissions(session, public, admin, True) == (True, True)
+ assert await _permissions(session, public, member, False) == (True, False)
+
+ assert await _permissions(session, read_only, owner, False) == (True, True)
+ assert await _permissions(session, read_only, admin, True) == (True, True)
+ assert await _permissions(session, read_only, member, False) == (False, False)
+
+
+async def test_taking_part_in_a_private_room_grants_reading_it_only(
+ session_factory: async_sessionmaker[AsyncSession],
+) -> None:
+ async with session_factory() as session:
+ owner = await _user(session, "owner")
+ agent_owner = await _user(session, "agent-owner")
+ private = await _room(
+ session,
+ "private",
+ owner,
+ write_visibility="private",
+ read_visibility="private",
+ )
+ agent = await add_agent(session, name="their-agent", owner_id=agent_owner.id)
+ await session.execute(
+ room_agents.insert().values(room_id=private.id, agent_id=agent.id)
+ )
+ await session.commit()
+
+ # They may read it (see `test_room_participant_read`), and that is all.
+ flags = await _permissions(session, private, agent_owner, False)
+ assert flags == (False, False)
+
+
+async def test_a_change_answers_with_what_its_caller_may_do(
+ session_factory: async_sessionmaker[AsyncSession],
+) -> None:
+ async with session_factory() as session:
+ owner = await _user(session, "owner")
+ member = await _user(session, "member")
+ public = await _room(session, "public", owner, write_visibility="public")
+ await session.commit()
+
+ detail = await rooms_module.patch_room(
+ public.id,
+ RoomUpdateRequest(name="renamed"),
+ session,
+ _RoomService(session_factory), # type: ignore[arg-type]
+ _ROOM_STORE,
+ None, # type: ignore[arg-type]
+ None, # type: ignore[arg-type]
+ _Protocol(), # type: ignore[arg-type]
+ member,
+ False,
+ )
+
+ assert detail.name == "renamed"
+ assert (detail.can_write, detail.can_manage) == (True, False)
diff --git a/core/tests/switch_core/gateway/test_room_resource_permissions.py b/core/tests/switch_core/gateway/test_room_resource_permissions.py
new file mode 100644
index 000000000..1a070a7fb
--- /dev/null
+++ b/core/tests/switch_core/gateway/test_room_resource_permissions.py
@@ -0,0 +1,605 @@
+"""Who sees which rooms a resource is in, and who may unlink it or delete a
+room's own documents.
+
+- A resource's rooms, and its attached-rooms count, take in only rooms the
+ caller may read. So do a room's links and the room graph. A tenant admin
+ sees every one. Whoever may manage a resource is still told how many rooms
+ they cannot read it is in, though never their names.
+- Unlinking a reference, document or package from a room is for those taking
+ part in the room and tenant admins. Write access is not enough: on a
+ publicly writable room it is everyone's.
+- A room-scoped document is deleted by its creator (an agent's document is
+ recorded under the agent's owner), the room's owner, or a tenant admin.
+- Whoever takes part in a private room may read its resources.
+
+Each flag the dashboard reads says the same as the route that enforces it.
+The route coroutines are called directly against real Postgres, as in
+`test_room_resource_read_authz`.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from types import SimpleNamespace
+
+import pytest
+from fastapi import HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from switch_core.bridges.agent.protocol.agent_connections import AgentConnectionRegistry
+from switch_core.bridges.resource.service import ResourceService
+from switch_core.db.models import Document, Room, User, room_agents
+from switch_core.db.stores.agent_session_store import AgentSessionStore
+from switch_core.db.stores.agent_store import AgentStore
+from switch_core.db.stores.collaboration_bridge_store import CollaborationBridgeStore
+from switch_core.db.stores.document_store import DocumentStore
+from switch_core.db.stores.external_user_store import ExternalUserStore
+from switch_core.db.stores.package_store import PackageStore
+from switch_core.db.stores.reference_store import ReferenceStore
+from switch_core.db.stores.reference_type_store import ReferenceTypeStore
+from switch_core.db.stores.room_group_store import RoomGroupStore
+from switch_core.db.stores.room_link_store import RoomLinkStore
+from switch_core.db.stores.room_role_store import RoomRoleStore
+from switch_core.db.stores.room_store import RoomStore
+from switch_core.db.stores.user_store import UserStore
+from switch_core.gateway.agents import get_agent_detail
+from switch_core.gateway.documents import (
+ detach_document_from_room,
+ get_room_document,
+ list_documents,
+ list_room_documents,
+ list_rooms_for_document,
+)
+from switch_core.gateway.packages import (
+ detach_package_from_room,
+ remove_reference_from_package,
+)
+from switch_core.gateway.references import (
+ detach_reference_from_room,
+ list_references,
+ list_rooms_for_reference,
+)
+from switch_core.gateway.room_links import (
+ create_linked_room,
+ get_room_link_graph,
+ list_inbound_linked_rooms,
+ list_linked_rooms,
+)
+from switch_core.gateway.rooms import list_rooms
+from switch_core.gateway.schemas import LinkedRoomCreateRequest
+from tests.switch_core.gateway.agent_route_harness import add_agent
+
+_ROOM_STORE = RoomStore()
+_USER_STORE = UserStore()
+_AGENT_STORE = AgentStore()
+
+
+def _svc(session_factory: async_sessionmaker[AsyncSession]) -> ResourceService:
+ return ResourceService(
+ reference_store=ReferenceStore(),
+ reference_type_store=ReferenceTypeStore(),
+ document_store=DocumentStore(),
+ package_store=PackageStore(),
+ room_link_store=RoomLinkStore(),
+ session_factory=session_factory,
+ )
+
+
+async def _user(session: AsyncSession, name: str) -> User:
+ user = User(name=name, email=f"{name}@example.com", role="user")
+ session.add(user)
+ await session.flush()
+ return user
+
+
+async def _room(
+ session: AsyncSession, name: str, owner: User, *, read: str, write: str
+) -> Room:
+ room = Room(
+ transport_room_id=f"!{name}:test",
+ name=name,
+ description="",
+ owner_id=owner.id,
+ read_visibility=read,
+ write_visibility=write,
+ )
+ session.add(room)
+ await session.flush()
+ return room
+
+
+@dataclass
+class _World:
+ """`owner` owns every room. `member` takes part in `theirs` through an
+ agent they own, and in nothing else; `stranger` takes part in nothing.
+
+ - `public`: publicly writable, so `member` and `stranger` may write to it.
+ - `theirs`: private, but `member` takes part in it, so may read it.
+ - `hidden`: private, and only `owner` takes part in it.
+ """
+
+ owner: User
+ member: User
+ stranger: User
+ public: Room
+ theirs: Room
+ hidden: Room
+ member_agent_id: str
+
+
+async def _world(session: AsyncSession) -> _World:
+ owner = await _user(session, "owner")
+ member = await _user(session, "member")
+ stranger = await _user(session, "stranger")
+ public = await _room(session, "public", owner, read="public", write="public")
+ theirs = await _room(session, "theirs", owner, read="private", write="private")
+ hidden = await _room(session, "hidden", owner, read="private", write="private")
+ agent = await add_agent(session, name="member-agent", owner_id=member.id)
+ await session.execute(
+ room_agents.insert().values(room_id=theirs.id, agent_id=agent.id)
+ )
+ return _World(owner, member, stranger, public, theirs, hidden, agent.id)
+
+
+async def _shared_document(
+ session: AsyncSession, svc: ResourceService, world: _World
+) -> Document:
+ """A public document `owner` attached to all three rooms."""
+ doc = await svc.create_document(
+ session,
+ owner_id=world.owner.id,
+ read_visibility="public",
+ write_visibility="private",
+ name="spec",
+ description="",
+ instructions="",
+ content="",
+ )
+ for room in (world.public, world.theirs, world.hidden):
+ await svc.attach_document_to_room(
+ session, room.id, doc.id, user_id=world.owner.id
+ )
+ return doc
+
+
+async def _rooms_of(
+ session: AsyncSession, svc: ResourceService, doc: Document, user: User, admin: bool
+) -> dict[str, bool]:
+ rooms = await list_rooms_for_document(
+ doc.id, session, svc, _ROOM_STORE, user, admin
+ )
+ return {r.room_name: r.can_unlink for r in rooms}
+
+
+async def _count_of(
+ session: AsyncSession, svc: ResourceService, doc: Document, user: User, admin: bool
+) -> int:
+ docs = await list_documents(session, svc, _USER_STORE, _AGENT_STORE, user, admin)
+ return next(d.attached_rooms_count for d in docs if d.id == doc.id)
+
+
+async def _detach(
+ session: AsyncSession,
+ svc: ResourceService,
+ room: Room,
+ doc_id: str,
+ user: User,
+ admin: bool,
+) -> None:
+ await detach_document_from_room(
+ room.id, doc_id, session, svc, _ROOM_STORE, user, admin
+ )
+
+
+async def test_a_resource_lists_only_the_rooms_its_viewer_may_read(
+ session_factory: async_sessionmaker[AsyncSession],
+) -> None:
+ svc = _svc(session_factory)
+ async with session_factory() as session:
+ world = await _world(session)
+ doc = await _shared_document(session, svc, world)
+ await session.commit()
+
+ # `member` reads `public` and `theirs`; `hidden` is left out, count too.
+ assert await _rooms_of(session, svc, doc, world.member, False) == {
+ "public": False,
+ "theirs": True,
+ }
+ assert await _count_of(session, svc, doc, world.member, False) == 2
+ assert await _rooms_of(session, svc, doc, world.stranger, False) == {
+ "public": False
+ }
+ assert await _count_of(session, svc, doc, world.stranger, False) == 1
+ # A tenant admin sees, and may unlink from, every room.
+ assert await _rooms_of(session, svc, doc, world.stranger, True) == {
+ "public": True,
+ "theirs": True,
+ "hidden": True,
+ }
+ assert await _count_of(session, svc, doc, world.stranger, True) == 3
+
+
+async def test_unlinking_is_for_those_taking_part_in_the_room_and_admins(
+ session_factory: async_sessionmaker[AsyncSession],
+) -> None:
+ svc = _svc(session_factory)
+ async with session_factory() as session:
+ world = await _world(session)
+ doc = await _shared_document(session, svc, world)
+ pkg = await svc.create_package(
+ session,
+ owner_id=world.owner.id,
+ read_visibility="public",
+ write_visibility="private",
+ name="kit",
+ description="",
+ instructions="",
+ )
+ await svc.attach_package_to_room(
+ session, world.public.id, pkg.id, user_id=world.owner.id
+ )
+ await session.commit()
+
+ summaries = await list_rooms(
+ session,
+ _ROOM_STORE,
+ RoomGroupStore(),
+ CollaborationBridgeStore(),
+ ExternalUserStore(),
+ _USER_STORE,
+ world.member,
+ False,
+ )
+ assert {r.name: (r.can_write, r.can_unlink) for r in summaries} == {
+ "public": (True, False),
+ "theirs": (False, True),
+ }
+
+ # May write to `public`, but takes part in it no more than anyone does.
+ with pytest.raises(HTTPException) as refused:
+ await _detach(session, svc, world.public, doc.id, world.member, False)
+ assert refused.value.status_code == 403
+ with pytest.raises(HTTPException) as refused:
+ await detach_package_from_room(
+ world.public.id, pkg.id, session, svc, _ROOM_STORE, world.member, False
+ )
+ assert refused.value.status_code == 403
+
+ # Takes part in `theirs` without write access to it, and may unlink.
+ await _detach(session, svc, world.theirs, doc.id, world.member, False)
+ # So may an admin, from a room they are not in.
+ await _detach(session, svc, world.hidden, doc.id, world.stranger, True)
+
+ assert await _rooms_of(session, svc, doc, world.owner, False) == {
+ "public": True
+ }
+
+
+async def test_a_room_document_is_deleted_by_its_creator_the_room_owner_or_an_admin(
+ session_factory: async_sessionmaker[AsyncSession],
+) -> None:
+ svc = _svc(session_factory)
+ async with session_factory() as session:
+ world = await _world(session)
+ notes = []
+ for name in ("by-creator", "by-owner", "by-admin"):
+ # Made by `member`'s agent, so recorded under `member`.
+ doc = await svc.create_room_document(
+ session,
+ room_id=world.public.id,
+ agent_id=world.member_agent_id,
+ owner_id=world.member.id,
+ name=name,
+ description="",
+ instructions="",
+ content="",
+ )
+ notes.append(doc)
+ await session.commit()
+ by_creator, by_owner, by_admin = notes
+
+ async def can_remove(doc: Document, user: User, admin: bool) -> bool:
+ listed = await list_room_documents(
+ world.public.id,
+ session,
+ svc,
+ _USER_STORE,
+ _AGENT_STORE,
+ _ROOM_STORE,
+ user,
+ admin,
+ )
+ detail = await get_room_document(
+ world.public.id,
+ doc.id,
+ session,
+ svc,
+ _USER_STORE,
+ _AGENT_STORE,
+ _ROOM_STORE,
+ user,
+ admin,
+ )
+ from_list = next(d.can_remove for d in listed if d.id == doc.id)
+ assert from_list == detail.can_remove
+ return detail.can_remove
+
+ # `stranger` may write to the room, and so change the document, but
+ # did not make it and does not own the room.
+ assert await can_remove(by_creator, world.stranger, False) is False
+ with pytest.raises(HTTPException) as refused:
+ await _detach(
+ session, svc, world.public, by_creator.id, world.stranger, False
+ )
+ assert refused.value.status_code == 403
+
+ assert await can_remove(by_creator, world.member, False) is True
+ await _detach(session, svc, world.public, by_creator.id, world.member, False)
+ assert await can_remove(by_owner, world.owner, False) is True
+ await _detach(session, svc, world.public, by_owner.id, world.owner, False)
+ assert await can_remove(by_admin, world.stranger, True) is True
+ await _detach(session, svc, world.public, by_admin.id, world.stranger, True)
+
+
+async def test_those_taking_part_in_a_private_room_read_its_resources(
+ session_factory: async_sessionmaker[AsyncSession],
+) -> None:
+ svc = _svc(session_factory)
+ async with session_factory() as session:
+ world = await _world(session)
+ doc = await _shared_document(session, svc, world)
+ await session.commit()
+
+ async def listed(room: Room, user: User) -> list[str]:
+ docs = await list_room_documents(
+ room.id,
+ session,
+ svc,
+ _USER_STORE,
+ _AGENT_STORE,
+ _ROOM_STORE,
+ user,
+ False,
+ )
+ return [d.id for d in docs]
+
+ assert await listed(world.theirs, world.member) == [doc.id]
+ with pytest.raises(HTTPException) as refused:
+ await listed(world.hidden, world.member)
+ assert refused.value.status_code == 403
+
+
+async def test_a_reference_follows_the_same_rules(
+ session_factory: async_sessionmaker[AsyncSession],
+) -> None:
+ svc = _svc(session_factory)
+ async with session_factory() as session:
+ world = await _world(session)
+ ref = await svc.create_reference(
+ session,
+ owner_id=world.owner.id,
+ is_admin=False,
+ read_visibility="public",
+ write_visibility="private",
+ type="github",
+ name="repo",
+ description="",
+ instructions="",
+ value={"urls": ["https://github.com/example/repo"]},
+ )
+ for room in (world.public, world.theirs, world.hidden):
+ await svc.attach_reference_to_room(
+ session, room.id, ref.id, user_id=world.owner.id
+ )
+ await session.commit()
+
+ rooms = await list_rooms_for_reference(
+ ref.id, session, svc, _ROOM_STORE, world.member, False
+ )
+ assert {r.room_name: r.can_unlink for r in rooms} == {
+ "public": False,
+ "theirs": True,
+ }
+ listed = await list_references(session, svc, _USER_STORE, world.member, False)
+ assert next(r.attached_rooms_count for r in listed if r.id == ref.id) == 2
+
+ with pytest.raises(HTTPException) as refused:
+ await detach_reference_from_room(
+ world.public.id, ref.id, session, svc, _ROOM_STORE, world.member, False
+ )
+ assert refused.value.status_code == 403
+ await detach_reference_from_room(
+ world.theirs.id, ref.id, session, svc, _ROOM_STORE, world.member, False
+ )
+
+
+async def test_links_and_the_room_graph_name_only_rooms_the_viewer_may_read(
+ session_factory: async_sessionmaker[AsyncSession],
+) -> None:
+ svc = _svc(session_factory)
+ async with session_factory() as session:
+ world = await _world(session)
+ for source, target in (
+ (world.public, world.hidden),
+ (world.hidden, world.public),
+ ):
+ await svc.attach_linked_room(
+ session, source_room_id=source.id, target_room_id=target.id, label="see"
+ )
+ await svc.attach_linked_room(
+ session,
+ source_room_id=world.public.id,
+ target_room_id=world.theirs.id,
+ label="see",
+ )
+ await session.commit()
+
+ outbound = await list_linked_rooms(
+ world.public.id, session, svc, _ROOM_STORE, world.member, False
+ )
+ assert [link.target_room_name for link in outbound] == ["theirs"]
+ inbound = await list_inbound_linked_rooms(
+ world.public.id, session, svc, _ROOM_STORE, world.member, False
+ )
+ assert inbound == []
+
+ graph = await get_room_link_graph(
+ session, svc, _ROOM_STORE, world.member, False
+ )
+ assert {room.name for room in graph.rooms} == {"public", "theirs"}
+ assert [(link.source_room_id, link.target_room_id) for link in graph.links] == [
+ (world.public.id, world.theirs.id)
+ ]
+
+ admin_graph = await get_room_link_graph(
+ session, svc, _ROOM_STORE, world.stranger, True
+ )
+ assert {room.name for room in admin_graph.rooms} == {
+ "public",
+ "theirs",
+ "hidden",
+ }
+ assert len(admin_graph.links) == 3
+
+
+async def test_a_resource_owner_is_told_how_many_private_rooms_use_it(
+ session_factory: async_sessionmaker[AsyncSession],
+) -> None:
+ svc = _svc(session_factory)
+ async with session_factory() as session:
+ world = await _world(session)
+ # `member` owns the document; `owner` puts it in a room only they read.
+ doc = await svc.create_document(
+ session,
+ owner_id=world.member.id,
+ read_visibility="public",
+ write_visibility="private",
+ name="theirs-to-share",
+ description="",
+ instructions="",
+ content="",
+ )
+ await svc.attach_document_to_room(
+ session, world.hidden.id, doc.id, user_id=world.owner.id
+ )
+ await session.commit()
+
+ async def counts(user: User, admin: bool) -> tuple[int, int]:
+ docs = await list_documents(
+ session, svc, _USER_STORE, _AGENT_STORE, user, admin
+ )
+ listed = next(d for d in docs if d.id == doc.id)
+ return listed.attached_rooms_count, listed.hidden_rooms_count
+
+ # The room stays unnamed to its owner, but they know it is there.
+ assert await _rooms_of(session, svc, doc, world.member, False) == {}
+ assert await counts(world.member, False) == (1, 1)
+ # Anyone else who may not read the room is not told of it at all.
+ assert await counts(world.stranger, False) == (0, 0)
+ # An admin reads every room, so none is hidden from them.
+ assert await counts(world.stranger, True) == (1, 0)
+
+
+async def test_a_link_reply_names_only_a_room_its_maker_may_read(
+ session_factory: async_sessionmaker[AsyncSession],
+) -> None:
+ svc = _svc(session_factory)
+ async with session_factory() as session:
+ world = await _world(session)
+ await session.commit()
+
+ async def link(target: Room) -> str:
+ created = await create_linked_room(
+ world.public.id,
+ LinkedRoomCreateRequest(target_room_id=target.id, label="see"),
+ session,
+ svc,
+ _ROOM_STORE,
+ world.member,
+ False,
+ )
+ return created.target_room_name
+
+ # `member` may write to `public`, but not read `hidden`.
+ with pytest.raises(HTTPException) as refused:
+ await link(world.hidden)
+ assert refused.value.status_code == 403
+ assert await link(world.theirs) == "theirs"
+
+
+async def test_an_agents_detail_names_only_rooms_its_viewer_may_read(
+ session_factory: async_sessionmaker[AsyncSession],
+) -> None:
+ protocol = SimpleNamespace(
+ agent_session_store=AgentSessionStore(),
+ room_role_store=RoomRoleStore(),
+ connections=AgentConnectionRegistry(),
+ )
+ async with session_factory() as session:
+ world = await _world(session)
+ await session.execute(
+ room_agents.insert().values(
+ room_id=world.public.id, agent_id=world.member_agent_id
+ )
+ )
+ await session.commit()
+
+ async def rooms_seen_by(user: User, admin: bool) -> set[str]:
+ detail = await get_agent_detail(
+ world.member_agent_id,
+ session,
+ _AGENT_STORE,
+ _ROOM_STORE,
+ _USER_STORE,
+ protocol, # type: ignore[arg-type]
+ user,
+ admin,
+ )
+ return {room.room_name for room in detail.rooms}
+
+ assert await rooms_seen_by(world.member, False) == {"public", "theirs"}
+ assert await rooms_seen_by(world.stranger, False) == {"public"}
+ assert await rooms_seen_by(world.stranger, True) == {"public", "theirs"}
+
+
+async def test_removing_from_a_package_names_only_readable_rooms(
+ session_factory: async_sessionmaker[AsyncSession],
+) -> None:
+ svc = _svc(session_factory)
+ async with session_factory() as session:
+ world = await _world(session)
+ ref = await svc.create_reference(
+ session,
+ owner_id=world.owner.id,
+ is_admin=False,
+ read_visibility="public",
+ write_visibility="public",
+ type="github",
+ name="repo",
+ description="",
+ instructions="",
+ value={"urls": ["https://github.com/example/repo"]},
+ )
+ pkg = await svc.create_package(
+ session,
+ owner_id=world.owner.id,
+ read_visibility="public",
+ write_visibility="public",
+ name="kit",
+ description="",
+ instructions="",
+ )
+ await svc.add_reference_to_package(
+ session, pkg.id, ref.id, user_id=world.owner.id, is_admin=False
+ )
+ for room in (world.public, world.hidden):
+ await svc.attach_package_to_room(
+ session, room.id, pkg.id, user_id=world.owner.id
+ )
+ await session.commit()
+
+ removed = await remove_reference_from_package(
+ pkg.id, ref.id, session, svc, _ROOM_STORE, world.stranger, False
+ )
+ assert removed.affected_room_names == ["public"]
+ assert removed.hidden_affected_rooms_count == 1
diff --git a/core/tests/switch_core/management/test_stream.py b/core/tests/switch_core/management/test_stream.py
index bc215e3af..ebab7b055 100644
--- a/core/tests/switch_core/management/test_stream.py
+++ b/core/tests/switch_core/management/test_stream.py
@@ -672,9 +672,13 @@ class TestTheConnection:
async with harness.session_factory() as session:
agent = await AgentStore().get(session, agent_id)
assert agent is not None
+ rooms = await RoomStore().get_rooms_for_agent(
+ session, agent_id, include_archived=True
+ )
detail = await assemble_agent_detail(
session,
agent=agent,
+ visible_room_ids={room.id for room in rooms},
agent_store=AgentStore(),
room_store=RoomStore(),
user_store=UserStore(),
diff --git a/core/tests/switch_core/test_authz.py b/core/tests/switch_core/test_authz.py
index d89b99da8..80e782a05 100644
--- a/core/tests/switch_core/test_authz.py
+++ b/core/tests/switch_core/test_authz.py
@@ -8,7 +8,9 @@ from switch_core.authz import (
Principal,
administers_tenant,
can,
+ can_delete_room_document,
can_manage,
+ can_unlink_from_room,
owns_tenant,
require,
require_manage,
@@ -189,6 +191,41 @@ class TestOwnsTenant:
assert not owns_tenant(is_operator=False, tenant_role=None)
+class TestCanUnlinkFromRoom:
+ def test_those_taking_part_and_admins_may(self) -> None:
+ assert can_unlink_from_room(ALICE, takes_part=True)
+ assert can_unlink_from_room(ADMIN, takes_part=False)
+
+ def test_anyone_else_may_not(self) -> None:
+ assert not can_unlink_from_room(ALICE, takes_part=False)
+ assert not can_unlink_from_room(ANON, takes_part=False)
+
+
+class TestCanDeleteRoomDocument:
+ def test_its_creator_the_room_owner_and_an_admin_may(self) -> None:
+ assert can_delete_room_document(
+ ALICE, room_owner_id="u-bob", document_owner_id="u-alice"
+ )
+ assert can_delete_room_document(
+ ALICE, room_owner_id="u-alice", document_owner_id="u-bob"
+ )
+ assert can_delete_room_document(
+ ADMIN, room_owner_id="u-bob", document_owner_id="u-carol"
+ )
+
+ def test_anyone_else_may_not(self) -> None:
+ assert not can_delete_room_document(
+ ALICE, room_owner_id="u-bob", document_owner_id="u-carol"
+ )
+
+ def test_a_missing_owner_matches_nobody(self) -> None:
+ # The None-guard is load-bearing, as in `can`: an unowned document
+ # in an unowned room is not "owned" by a principal with no id.
+ assert not can_delete_room_document(
+ ANON, room_owner_id=None, document_owner_id=None
+ )
+
+
class TestValidateVisibilityPair:
@pytest.mark.parametrize(
"read,write",
diff --git a/gateway/src/components/AccessControls.tsx b/gateway/src/components/AccessControls.tsx
index 2e7d4114c..15131b12a 100644
--- a/gateway/src/components/AccessControls.tsx
+++ b/gateway/src/components/AccessControls.tsx
@@ -30,6 +30,9 @@ interface AccessSelectProps {
/** Helper text per level, where the shared wording does not fit the
* resource (a template is used, not attached). */
helpers?: Partial<Record<AccessLevel, string>>;
+ /** Option labels per level, where the shared ones do not fit (a private
+ * room is seen by those taking part in it, not "only me"). */
+ optionLabels?: Partial<Record<AccessLevel, string>>;
sx?: SxProps<Theme>;
}
@@ -41,6 +44,7 @@ export function AccessSelect({
disabled,
label = "Access",
helpers,
+ optionLabels,
sx,
}: AccessSelectProps) {
return (
@@ -55,7 +59,7 @@ export function AccessSelect({
>
{ACCESS_LEVELS.map((lvl) => (
<MenuItem key={lvl} value={lvl}>
- {ACCESS_META[lvl].optionLabel}
+ {optionLabels?.[lvl] ?? ACCESS_META[lvl].optionLabel}
</MenuItem>
))}
</TextField>
diff --git a/gateway/src/components/DataTable.tsx b/gateway/src/components/DataTable.tsx
index b90f7acb6..159e5668a 100644
--- a/gateway/src/components/DataTable.tsx
+++ b/gateway/src/components/DataTable.tsx
@@ -17,6 +17,9 @@ interface DataTableProps<T extends { id: string | number }> {
fillHeight?: boolean;
pageSize?: number;
checkboxSelection?: boolean;
+ // Rows that may be ticked, when not every one may (the viewer cannot act
+ // on the rest).
+ isRowSelectable?: (row: T) => boolean;
onRowSelectionModelChange?: (ids: GridRowId[]) => void;
onRowClick?: (params: GridRowParams<T>) => void;
sx?: SxProps<Theme>;
@@ -73,6 +76,7 @@ export default function DataTable<T extends { id: string | number }>({
fillHeight = false,
pageSize = 25,
checkboxSelection = false,
+ isRowSelectable,
onRowSelectionModelChange,
onRowClick,
sx,
@@ -88,6 +92,9 @@ export default function DataTable<T extends { id: string | number }>({
pageSizeOptions={[10, 25, 50]}
pagination
checkboxSelection={checkboxSelection}
+ isRowSelectable={
+ isRowSelectable ? (params: GridRowParams<T>) => isRowSelectable(params.row) : undefined
+ }
onRowSelectionModelChange={
onRowSelectionModelChange
? (model: GridRowSelectionModel) => onRowSelectionModelChange([...model.ids])
diff --git a/gateway/src/data/api.ts b/gateway/src/data/api.ts
index 05852c502..1f703a233 100644
--- a/gateway/src/data/api.ts
+++ b/gateway/src/data/api.ts
@@ -35,6 +35,14 @@ export interface RoomSummary {
write_visibility: "public" | "private";
created_at: string;
archived: boolean;
+ // What the viewer may do, as the server decides it. `can_write` covers the
+ // room's settings, roles, participants, links and attaching resources;
+ // `can_manage` (owner or workspace admin) covers its access and deleting it;
+ // `can_unlink` (taking part in it, or workspace admin) covers unlinking a
+ // reference, document or package from it.
+ can_write: boolean;
+ can_manage: boolean;
+ can_unlink: boolean;
}
export interface AgentSummary {
@@ -1532,6 +1540,9 @@ export interface ReferenceDetail {
instructions: string;
value: Record<string, unknown>;
attached_rooms_count: number;
+ // Of those, rooms the viewer may not read, which are never named to them.
+ // Counted only for whoever may manage the resource; zero for anyone else.
+ hidden_rooms_count: number;
packages: string[];
created_at: string;
// Resolved server-side and unfiltered by the type's visibility. Null when
@@ -1568,6 +1579,9 @@ export interface DocumentSummary {
description: string;
instructions: string;
attached_rooms_count: number;
+ // Of those, rooms the viewer may not read, which are never named to them.
+ // Counted only for whoever may manage the resource; zero for anyone else.
+ hidden_rooms_count: number;
packages: string[];
scope: "global" | "room";
room_id: string | null;
@@ -1580,6 +1594,20 @@ export interface DocumentDetail extends DocumentSummary {
content: string;
}
+// Whether the viewer may remove a document from a room it is in: delete it if
+// it is room-scoped (its creator, the room's owner, a workspace admin), unlink
+// it if it is attached (those taking part in the room, a workspace admin).
+
+/** A document as listed in a room it is in. */
+export interface RoomDocumentSummary extends DocumentSummary {
+ can_remove: boolean;
+}
+
+/** A document as seen from a room it is in. */
+export interface RoomDocumentDetail extends DocumentDetail {
+ can_remove: boolean;
+}
+
export interface DocumentCreateInput {
read_visibility: "public" | "private";
write_visibility: "public" | "private";
@@ -1601,6 +1629,9 @@ export interface DocumentUpdateInput {
export interface ResourceRoom {
room_id: string;
room_name: string;
+ // Whether the viewer may unlink the resource from this room: they take part
+ // in it, or are a workspace admin.
+ can_unlink: boolean;
}
export interface ResourceDeleteResult {
@@ -1855,15 +1886,15 @@ export async function fetchDocumentRooms(id: string): Promise<ResourceRoom[] | n
export async function fetchRoomDocuments(
roomId: string,
-): Promise<DocumentSummary[] | null> {
- return fetchJson<DocumentSummary[]>(`/rooms/${roomId}/documents`);
+): Promise<RoomDocumentSummary[] | null> {
+ return fetchJson<RoomDocumentSummary[]>(`/rooms/${roomId}/documents`);
}
export async function fetchRoomDocument(
roomId: string,
documentId: string,
-): Promise<DocumentDetail | null> {
- return fetchJson<DocumentDetail>(`/rooms/${roomId}/documents/${documentId}`);
+): Promise<RoomDocumentDetail | null> {
+ return fetchJson<RoomDocumentDetail>(`/rooms/${roomId}/documents/${documentId}`);
}
export async function attachDocumentToRoom(
@@ -1904,6 +1935,9 @@ export interface PackageDetail {
references_count: number;
documents_count: number;
attached_rooms_count: number;
+ // Of those, rooms the viewer may not read, which are never named to them.
+ // Counted only for whoever may manage the resource; zero for anyone else.
+ hidden_rooms_count: number;
created_at: string;
}
@@ -1926,8 +1960,11 @@ export interface PackageUpdateInput {
export interface PackageMemberRemoveResult {
package_id: string;
member_id: string;
+ // The rooms that lost sight of the member, of those the viewer may read.
affected_room_ids: string[];
affected_room_names: string[];
+ // How many more did among rooms the viewer may not read, never named.
+ hidden_affected_rooms_count: number;
}
export async function fetchPackages(): Promise<PackageDetail[] | null> {
diff --git a/gateway/src/data/hooks.ts b/gateway/src/data/hooks.ts
index 02e090241..79cbf0706 100644
--- a/gateway/src/data/hooks.ts
+++ b/gateway/src/data/hooks.ts
@@ -13,7 +13,6 @@ import {
type BridgeDetail,
type BridgeTypeInfo,
type ExternalUserSummary,
- type DocumentDetail,
type DocumentSummary,
type InboundLinkedRoomDetail,
type InstallablePlatforms,
@@ -28,6 +27,8 @@ import {
type ReferenceTypeInfo,
type ResourceRoom,
type RoomDetail,
+ type RoomDocumentDetail,
+ type RoomDocumentSummary,
type RoomGroupDetail,
type RoomSummary,
type TemplateSummary,
@@ -290,7 +291,7 @@ export function useRoomReferences(
export function useRoomDocuments(
roomId: string | undefined,
-): UseQueryResult<DocumentSummary[]> {
+): UseQueryResult<RoomDocumentSummary[]> {
const fetcher = useCallback(
() => (roomId ? fetchRoomDocuments(roomId) : Promise.resolve(null)),
[roomId],
@@ -301,7 +302,7 @@ export function useRoomDocuments(
export function useRoomDocument(
roomId: string | undefined,
documentId: string | undefined,
-): UseQueryResult<DocumentDetail> {
+): UseQueryResult<RoomDocumentDetail> {
const fetcher = useCallback(
() =>
roomId && documentId
diff --git a/gateway/src/pages/resources/DeleteResourceDialog.test.tsx b/gateway/src/pages/resources/DeleteResourceDialog.test.tsx
new file mode 100644
index 000000000..4cec50664
--- /dev/null
+++ b/gateway/src/pages/resources/DeleteResourceDialog.test.tsx
@@ -0,0 +1,47 @@
+import { cleanup, render, screen } from "@testing-library/react";
+import { afterEach, beforeEach, describe, it, vi } from "vitest";
+import * as hooks from "../../data/hooks";
+import DeleteResourceDialog from "./DeleteResourceDialog";
+
+vi.mock("../../data/hooks", () => ({
+ useDocumentRooms: vi.fn(),
+ usePackageRooms: vi.fn(),
+ useReferenceRooms: vi.fn(),
+}));
+
+function returns<T>(data: T) {
+ return { data, loading: false, error: null, refetch: vi.fn() };
+}
+
+describe("DeleteResourceDialog", () => {
+ beforeEach(() => {
+ vi.mocked(hooks.useDocumentRooms).mockReturnValue(
+ returns([{ room_id: "r1", room_name: "planning", can_unlink: true }]),
+ );
+ vi.mocked(hooks.useReferenceRooms).mockReturnValue(returns(null));
+ vi.mocked(hooks.usePackageRooms).mockReturnValue(returns(null));
+ });
+
+ afterEach(() => {
+ cleanup();
+ vi.clearAllMocks();
+ });
+
+ it("counts every room the delete removes it from, private ones unnamed", () => {
+ render(
+ <DeleteResourceDialog
+ open
+ kind="document"
+ resourceId="d1"
+ resourceLabel="Spec"
+ hiddenRoomsCount={2}
+ onClose={vi.fn()}
+ onDeleted={vi.fn()}
+ />,
+ );
+
+ screen.getByText(/This will detach from 3 rooms/);
+ screen.getByText("planning");
+ screen.getByText("2 private rooms you can't open");
+ });
+});
diff --git a/gateway/src/pages/resources/DeleteResourceDialog.tsx b/gateway/src/pages/resources/DeleteResourceDialog.tsx
index d1d01f7fd..f3bce7064 100644
--- a/gateway/src/pages/resources/DeleteResourceDialog.tsx
+++ b/gateway/src/pages/resources/DeleteResourceDialog.tsx
@@ -22,12 +22,16 @@ import {
usePackageRooms,
useReferenceRooms,
} from "../../data/hooks";
+import { privateRoomsLabel } from "./privateRooms";
interface Props {
open: boolean;
kind: "reference" | "document" | "package";
resourceId: string;
resourceLabel: string;
+ // Rooms it is in that the viewer may not read: unnamed, but the delete
+ // still removes it from them.
+ hiddenRoomsCount: number;
onClose: () => void;
onDeleted: () => void;
}
@@ -37,6 +41,7 @@ export default function DeleteResourceDialog({
kind,
resourceId,
resourceLabel,
+ hiddenRoomsCount,
onClose,
onDeleted,
}: Props) {
@@ -82,14 +87,21 @@ export default function DeleteResourceDialog({
</DialogContentText>
{loading ? (
<CircularProgress size={20} />
- ) : rooms && rooms.length > 0 ? (
+ ) : (rooms ?? []).length + hiddenRoomsCount > 0 ? (
<Alert severity="warning">
- This will detach from {rooms.length} room
- {rooms.length === 1 ? "" : "s"}:
+ This will detach from {(rooms ?? []).length + hiddenRoomsCount} room
+ {(rooms ?? []).length + hiddenRoomsCount === 1 ? "" : "s"}:
<Stack direction="row" flexWrap="wrap" gap={0.5} sx={{ mt: 1 }}>
- {rooms.map((r) => (
+ {(rooms ?? []).map((r) => (
<Chip key={r.room_id} size="small" label={r.room_name} />
))}
+ {hiddenRoomsCount > 0 && (
+ <Chip
+ size="small"
+ variant="outlined"
+ label={privateRoomsLabel(hiddenRoomsCount)}
+ />
+ )}
</Stack>
</Alert>
) : null}
diff --git a/gateway/src/pages/resources/DocumentDetailPage.tsx b/gateway/src/pages/resources/DocumentDetailPage.tsx
index 759b7412e..c9117d313 100644
--- a/gateway/src/pages/resources/DocumentDetailPage.tsx
+++ b/gateway/src/pages/resources/DocumentDetailPage.tsx
@@ -105,7 +105,11 @@ export default function DocumentDetailPage() {
<Divider />
<InPackagesSection packageIds={doc.packages ?? []} />
<Divider />
- <ResourceAttachmentsSection kind="document" resourceId={id} />
+ <ResourceAttachmentsSection
+ kind="document"
+ resourceId={id}
+ hiddenRoomsCount={doc.hidden_rooms_count}
+ />
{canMutate && (
<>
<Divider />
@@ -119,6 +123,7 @@ export default function DocumentDetailPage() {
kind="document"
resourceId={id}
resourceLabel={doc.name || id}
+ hiddenRoomsCount={doc.hidden_rooms_count}
onClose={() => setDeleteOpen(false)}
onDeleted={() => navigate("/resources?tab=documents")}
/>
diff --git a/gateway/src/pages/resources/PackageDetailPage.tsx b/gateway/src/pages/resources/PackageDetailPage.tsx
index 78b326713..009704e57 100644
--- a/gateway/src/pages/resources/PackageDetailPage.tsx
+++ b/gateway/src/pages/resources/PackageDetailPage.tsx
@@ -104,7 +104,11 @@ export default function PackageDetailPage() {
<Divider />
<PackageMembersSection packageId={id} canMutate={canMutate} />
<Divider />
- <ResourceAttachmentsSection kind="package" resourceId={id} />
+ <ResourceAttachmentsSection
+ kind="package"
+ resourceId={id}
+ hiddenRoomsCount={pkg.hidden_rooms_count}
+ />
{canMutate && (
<>
<Divider />
@@ -118,6 +122,7 @@ export default function PackageDetailPage() {
kind="package"
resourceId={id}
resourceLabel={pkg.name || id}
+ hiddenRoomsCount={pkg.hidden_rooms_count}
onClose={() => setDeleteOpen(false)}
onDeleted={() => navigate("/resources?tab=packages")}
/>
diff --git a/gateway/src/pages/resources/PackageMembersSection.test.tsx b/gateway/src/pages/resources/PackageMembersSection.test.tsx
new file mode 100644
index 000000000..a93bfaac4
--- /dev/null
+++ b/gateway/src/pages/resources/PackageMembersSection.test.tsx
@@ -0,0 +1,58 @@
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, beforeEach, describe, it, vi } from "vitest";
+import * as api from "../../data/api";
+import * as hooks from "../../data/hooks";
+import PackageMembersSection from "./PackageMembersSection";
+
+vi.mock("react-router", () => ({
+ useNavigate: () => vi.fn(),
+}));
+
+vi.mock("../../data/hooks", () => ({
+ useDocuments: vi.fn(),
+ usePackageDocuments: vi.fn(),
+ usePackageReferences: vi.fn(),
+ useReferences: vi.fn(),
+}));
+
+vi.mock("../../data/api", async (importOriginal) => {
+ const actual = await importOriginal<typeof import("../../data/api")>();
+ return { ...actual, removeReferenceFromPackage: vi.fn() };
+});
+
+function returns<T>(data: T) {
+ return { data, loading: false, error: null, refetch: vi.fn() };
+}
+
+describe("PackageMembersSection", () => {
+ beforeEach(() => {
+ vi.mocked(hooks.usePackageReferences).mockReturnValue(
+ returns([{ id: "ref1", name: "Runbook", type: "github", type_display_name: "GitHub" }]) as never,
+ );
+ vi.mocked(hooks.usePackageDocuments).mockReturnValue(returns([]) as never);
+ vi.mocked(hooks.useReferences).mockReturnValue(returns([]) as never);
+ vi.mocked(hooks.useDocuments).mockReturnValue(returns([]) as never);
+ });
+
+ afterEach(() => {
+ cleanup();
+ vi.clearAllMocks();
+ });
+
+ it("counts rooms that lost sight of a member, naming only readable ones", async () => {
+ vi.mocked(api.removeReferenceFromPackage).mockResolvedValue({
+ package_id: "p1",
+ member_id: "ref1",
+ affected_room_ids: ["r1"],
+ affected_room_names: ["planning"],
+ hidden_affected_rooms_count: 1,
+ });
+ render(<PackageMembersSection packageId="p1" canMutate />);
+
+ fireEvent.click(screen.getByRole("button", { name: "Remove Runbook from package" }));
+
+ await screen.findByText(
+ "Removed. 2 room(s) lost visibility: planning, 1 private room you can't open",
+ );
+ });
+});
diff --git a/gateway/src/pages/resources/PackageMembersSection.tsx b/gateway/src/pages/resources/PackageMembersSection.tsx
index e0b7f5af9..c3792ddab 100644
--- a/gateway/src/pages/resources/PackageMembersSection.tsx
+++ b/gateway/src/pages/resources/PackageMembersSection.tsx
@@ -19,6 +19,7 @@ import {
addReferenceToPackage,
removeDocumentFromPackage,
removeReferenceFromPackage,
+ type PackageMemberRemoveResult,
} from "../../data/api";
import {
useDocuments,
@@ -26,6 +27,7 @@ import {
usePackageReferences,
useReferences,
} from "../../data/hooks";
+import { privateRoomsLabel } from "./privateRooms";
interface Props {
packageId: string;
@@ -114,11 +116,8 @@ export default function PackageMembersSection({ packageId, canMutate }: Props) {
setRemoveWarning(null);
try {
const result = await removeReferenceFromPackage(packageId, refId);
- if (result.affected_room_names.length > 0) {
- setRemoveWarning(
- `Removed. ${result.affected_room_names.length} room(s) lost visibility: ${result.affected_room_names.join(", ")}`,
- );
- }
+ const warning = lostVisibilityWarning(result);
+ if (warning) setRemoveWarning(warning);
refetchRefs();
} catch (e) {
setError(e instanceof Error ? e.message : "Failed to remove reference");
@@ -133,11 +132,8 @@ export default function PackageMembersSection({ packageId, canMutate }: Props) {
setRemoveWarning(null);
try {
const result = await removeDocumentFromPackage(packageId, docId);
- if (result.affected_room_names.length > 0) {
- setRemoveWarning(
- `Removed. ${result.affected_room_names.length} room(s) lost visibility: ${result.affected_room_names.join(", ")}`,
- );
- }
+ const warning = lostVisibilityWarning(result);
+ if (warning) setRemoveWarning(warning);
refetchDocs();
} catch (e) {
setError(e instanceof Error ? e.message : "Failed to remove document");
@@ -200,6 +196,7 @@ export default function PackageMembersSection({ packageId, canMutate }: Props) {
handleRemoveRef(r.id);
}}
disabled={busy}
+ aria-label={`Remove ${r.name || "(unnamed)"} from package`}
>
<DeleteOutline fontSize="small" />
</IconButton>
@@ -259,6 +256,7 @@ export default function PackageMembersSection({ packageId, canMutate }: Props) {
handleRemoveDoc(d.id);
}}
disabled={busy}
+ aria-label={`Remove ${d.name || "(unnamed)"} from package`}
>
<DeleteOutline fontSize="small" />
</IconButton>
@@ -299,3 +297,12 @@ export default function PackageMembersSection({ packageId, canMutate }: Props) {
</Stack>
);
}
+
+// Rooms the viewer may not read are counted, never named.
+function lostVisibilityWarning(result: PackageMemberRemoveResult): string | null {
+ const named = result.affected_room_names;
+ const hidden = result.hidden_affected_rooms_count;
+ if (named.length + hidden === 0) return null;
+ const rooms = [...named, ...(hidden > 0 ? [privateRoomsLabel(hidden)] : [])];
+ return `Removed. ${named.length + hidden} room(s) lost visibility: ${rooms.join(", ")}`;
+}
diff --git a/gateway/src/pages/resources/ReferenceDetailPage.tsx b/gateway/src/pages/resources/ReferenceDetailPage.tsx
index 9a74b5eb4..643c38599 100644
--- a/gateway/src/pages/resources/ReferenceDetailPage.tsx
+++ b/gateway/src/pages/resources/ReferenceDetailPage.tsx
@@ -116,7 +116,11 @@ export default function ReferenceDetailPage() {
<Divider />
<InPackagesSection packageIds={ref.packages ?? []} />
<Divider />
- <ResourceAttachmentsSection kind="reference" resourceId={id} />
+ <ResourceAttachmentsSection
+ kind="reference"
+ resourceId={id}
+ hiddenRoomsCount={ref.hidden_rooms_count}
+ />
{canMutate && (
<>
<Divider />
@@ -130,6 +134,7 @@ export default function ReferenceDetailPage() {
kind="reference"
resourceId={id}
resourceLabel={ref.name || id}
+ hiddenRoomsCount={ref.hidden_rooms_count}
onClose={() => setDeleteOpen(false)}
onDeleted={() => navigate("/resources?tab=references")}
/>
diff --git a/gateway/src/pages/resources/ResourceAttachmentsSection.test.tsx b/gateway/src/pages/resources/ResourceAttachmentsSection.test.tsx
new file mode 100644
index 000000000..c594ac06c
--- /dev/null
+++ b/gateway/src/pages/resources/ResourceAttachmentsSection.test.tsx
@@ -0,0 +1,80 @@
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { RoomSummary } from "../../data/api";
+import * as hooks from "../../data/hooks";
+import ResourceAttachmentsSection from "./ResourceAttachmentsSection";
+
+vi.mock("../../data/hooks", () => ({
+ useDocumentRooms: vi.fn(),
+ usePackageRooms: vi.fn(),
+ useReferenceRooms: vi.fn(),
+ useRooms: vi.fn(),
+}));
+
+function returns<T>(data: T) {
+ return { data, loading: false, error: null, refetch: vi.fn() };
+}
+
+function room(id: string, name: string, canWrite: boolean) {
+ return { id, name, description: "", can_write: canWrite } as RoomSummary;
+}
+
+describe("ResourceAttachmentsSection", () => {
+ beforeEach(() => {
+ vi.mocked(hooks.useDocumentRooms).mockReturnValue(
+ returns([
+ { room_id: "r1", room_name: "planning", can_unlink: true },
+ { room_id: "r2", room_name: "leadership", can_unlink: false },
+ ]),
+ );
+ vi.mocked(hooks.useReferenceRooms).mockReturnValue(returns(null));
+ vi.mocked(hooks.usePackageRooms).mockReturnValue(returns(null));
+ vi.mocked(hooks.useRooms).mockReturnValue(
+ returns([
+ room("r1", "planning", true),
+ room("r2", "leadership", false),
+ room("r3", "retro", true),
+ room("r4", "announcements", false),
+ ]),
+ );
+ });
+
+ afterEach(() => {
+ cleanup();
+ vi.clearAllMocks();
+ });
+
+ it("offers unlinking only from rooms the viewer takes part in", () => {
+ render(<ResourceAttachmentsSection kind="document" resourceId="d1" hiddenRoomsCount={0} />);
+
+ screen.getByText("leadership");
+ screen.getByRole("button", { name: "Unlink from planning" });
+ expect(screen.queryByRole("button", { name: "Unlink from leadership" })).toBeNull();
+ });
+
+ it("offers attaching only to rooms the viewer may write to, loading them on open", async () => {
+ render(<ResourceAttachmentsSection kind="document" resourceId="d1" hiddenRoomsCount={0} />);
+ expect(hooks.useRooms).not.toHaveBeenCalled();
+
+ fireEvent.click(screen.getByRole("button", { name: "Attach to room" }));
+
+ await screen.findByText("retro");
+ expect(screen.queryByText("announcements")).toBeNull();
+ // Already attached, so not offered again.
+ expect(screen.getAllByText("planning")).toHaveLength(1);
+ });
+
+ it("tells whoever manages it how many rooms it is in that they cannot open", () => {
+ render(<ResourceAttachmentsSection kind="document" resourceId="d1" hiddenRoomsCount={2} />);
+
+ screen.getByText("Also in 2 private rooms you can't open.");
+ });
+
+ it("does not claim it is in no rooms when every room it is in is private", () => {
+ vi.mocked(hooks.useDocumentRooms).mockReturnValue(returns([]));
+ render(<ResourceAttachmentsSection kind="document" resourceId="d1" hiddenRoomsCount={1} />);
+
+ screen.getByText("In 1 private room you can't open.");
+ expect(screen.queryByText("Not attached to any rooms yet.")).toBeNull();
+ });
+});
diff --git a/gateway/src/pages/resources/ResourceAttachmentsSection.tsx b/gateway/src/pages/resources/ResourceAttachmentsSection.tsx
index a0fa8e659..3103eb140 100644
--- a/gateway/src/pages/resources/ResourceAttachmentsSection.tsx
+++ b/gateway/src/pages/resources/ResourceAttachmentsSection.tsx
@@ -1,10 +1,8 @@
import AddIcon from "@mui/icons-material/Add";
-import DeleteOutline from "@mui/icons-material/DeleteOutline";
import {
Alert,
Button,
CircularProgress,
- IconButton,
Stack,
Typography,
} from "@mui/material";
@@ -26,19 +24,25 @@ import {
useReferenceRooms,
useRooms,
} from "../../data/hooks";
+import { privateRoomsLabel } from "./privateRooms";
interface Props {
kind: "reference" | "document" | "package";
resourceId: string;
+ // Rooms it is in that the viewer may not read, which are never named.
+ hiddenRoomsCount: number;
}
-export default function ResourceAttachmentsSection({ kind, resourceId }: Props) {
+export default function ResourceAttachmentsSection({
+ kind,
+ resourceId,
+ hiddenRoomsCount,
+}: Props) {
const refRooms = useReferenceRooms(kind === "reference" ? resourceId : undefined);
const docRooms = useDocumentRooms(kind === "document" ? resourceId : undefined);
const pkgRooms = usePackageRooms(kind === "package" ? resourceId : undefined);
const { data: attached, loading, error, refetch } =
kind === "reference" ? refRooms : kind === "document" ? docRooms : pkgRooms;
- const { data: allRooms, loading: allLoading } = useRooms();
const [pickerOpen, setPickerOpen] = useState(false);
const [error_, setError] = useState<string | null>(null);
const [busy, setBusy] = useState(false);
@@ -47,18 +51,6 @@ export default function ResourceAttachmentsSection({ kind, resourceId }: Props)
() => new Set((attached ?? []).map((r) => r.room_id)),
[attached],
);
- const options = useMemo<PickerOption[]>(
- () =>
- (allRooms ?? [])
- .filter((r) => !attachedIds.has(r.id))
- .map((r) => ({
- id: r.id,
- primary: r.name,
- secondary: r.description || undefined,
- search: `${r.name} ${r.description ?? ""}`.toLowerCase(),
- })),
- [allRooms, attachedIds],
- );
const handleAttach = async (roomIds: string[]) => {
setBusy(true);
@@ -108,7 +100,7 @@ export default function ResourceAttachmentsSection({ kind, resourceId }: Props)
{error_ && <Alert severity="error">{error_}</Alert>}
{loading ? (
<CircularProgress size={20} />
- ) : (attached ?? []).length === 0 ? (
+ ) : (attached ?? []).length === 0 && hiddenRoomsCount === 0 ? (
<Typography variant="body2" color="text.secondary">
Not attached to any rooms yet.
</Typography>
@@ -130,15 +122,24 @@ export default function ResourceAttachmentsSection({ kind, resourceId }: Props)
<Typography variant="body2" sx={{ flexGrow: 1 }}>
{r.room_name}
</Typography>
- <IconButton
- size="small"
- onClick={() => handleDetach(r.room_id)}
- disabled={busy}
- >
- <DeleteOutline fontSize="small" />
- </IconButton>
+ {r.can_unlink && (
+ <Button
+ size="small"
+ onClick={() => handleDetach(r.room_id)}
+ disabled={busy}
+ aria-label={`Unlink from ${r.room_name}`}
+ >
+ Unlink
+ </Button>
+ )}
</Stack>
))}
+ {hiddenRoomsCount > 0 && (
+ <Typography variant="body2" color="text.secondary" sx={{ px: 1, py: 0.5 }}>
+ {(attached ?? []).length > 0 ? "Also in" : "In"}{" "}
+ {privateRoomsLabel(hiddenRoomsCount)}.
+ </Typography>
+ )}
</Stack>
)}
<Button
@@ -150,16 +151,51 @@ export default function ResourceAttachmentsSection({ kind, resourceId }: Props)
>
Attach to room
</Button>
- <SearchablePickerDialog
- open={pickerOpen}
- title="Attach to rooms"
- searchPlaceholder="Search rooms…"
- submitLabel="Attach"
- options={options}
- loading={allLoading}
- onClose={() => setPickerOpen(false)}
- onSubmit={handleAttach}
- />
+ {pickerOpen && (
+ <RoomPicker
+ attachedIds={attachedIds}
+ onClose={() => setPickerOpen(false)}
+ onSubmit={handleAttach}
+ />
+ )}
</Stack>
);
}
+
+// Mounted only while open, so the room list loads only when someone attaches.
+// It offers the rooms the viewer may write to: attaching needs that.
+function RoomPicker({
+ attachedIds,
+ onClose,
+ onSubmit,
+}: {
+ attachedIds: Set<string>;
+ onClose: () => void;
+ onSubmit: (roomIds: string[]) => Promise<void>;
+}) {
+ const { data: rooms, loading } = useRooms();
+ const options = useMemo<PickerOption[]>(
+ () =>
+ (rooms ?? [])
+ .filter((r) => r.can_write && !attachedIds.has(r.id))
+ .map((r) => ({
+ id: r.id,
+ primary: r.name,
+ secondary: r.description || undefined,
+ search: `${r.name} ${r.description ?? ""}`.toLowerCase(),
+ })),
+ [rooms, attachedIds],
+ );
+ return (
+ <SearchablePickerDialog
+ open
+ title="Attach to rooms"
+ searchPlaceholder="Search rooms…"
+ submitLabel="Attach"
+ options={options}
+ loading={loading}
+ onClose={onClose}
+ onSubmit={onSubmit}
+ />
+ );
+}
diff --git a/gateway/src/pages/resources/privateRooms.ts b/gateway/src/pages/resources/privateRooms.ts
new file mode 100644
index 000000000..39a20cf08
--- /dev/null
+++ b/gateway/src/pages/resources/privateRooms.ts
@@ -0,0 +1,5 @@
+/** How the rooms a resource is in that the viewer may not read are shown to
+ * whoever manages it: counted, never named. */
+export function privateRoomsLabel(count: number): string {
+ return `${count} private room${count === 1 ? "" : "s"} you can't open`;
+}
diff --git a/gateway/src/pages/rooms/GroupsPage.test.tsx b/gateway/src/pages/rooms/GroupsPage.test.tsx
index 277472fa5..daefdadae 100644
--- a/gateway/src/pages/rooms/GroupsPage.test.tsx
+++ b/gateway/src/pages/rooms/GroupsPage.test.tsx
@@ -1,7 +1,7 @@
-import { cleanup, render, screen } from "@testing-library/react";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
import { MemoryRouter } from "react-router";
import { afterEach, describe, expect, it, vi } from "vitest";
-import type { RoomGroupDetail } from "../../data/api";
+import type { RoomGroupDetail, RoomSummary } from "../../data/api";
import { useAuth } from "../../data/AuthContext";
import * as hooks from "../../data/hooks";
import type { UseQueryResult } from "../../data/hooks";
@@ -45,10 +45,14 @@ const group: RoomGroupDetail = {
created_at: "2026-01-01",
};
-function renderAs(isAdmin: boolean) {
+function room(id: string, name: string, groupId: string | null, canWrite: boolean) {
+ return { id, name, group_id: groupId, group_name: null, can_write: canWrite } as unknown as RoomSummary;
+}
+
+function renderAs(isAdmin: boolean, rooms: RoomSummary[] = []) {
vi.mocked(useAuth).mockReturnValue(authState(isAdmin));
vi.mocked(hooks.useRoomGroups).mockReturnValue(queryResult([group]));
- vi.mocked(hooks.useRooms).mockReturnValue(queryResult([]));
+ vi.mocked(hooks.useRooms).mockReturnValue(queryResult(rooms));
render(
<MemoryRouter>
<GroupsPage />
@@ -73,4 +77,21 @@ describe("GroupsPage", () => {
expect(screen.queryByLabelText("Edit Customers")).toBeNull();
expect(screen.queryByLabelText("Delete Customers")).toBeNull();
});
+
+ it("files and unfiles only rooms the viewer may write to", async () => {
+ renderAs(false, [
+ room("r1", "planning", "g1", true),
+ room("r2", "leadership", "g1", false),
+ room("r3", "retro", null, true),
+ room("r4", "board", null, false),
+ ]);
+ fireEvent.click(screen.getByText("Customers"));
+
+ screen.getByRole("button", { name: "Remove planning from group" });
+ expect(screen.queryByRole("button", { name: "Remove leadership from group" })).toBeNull();
+
+ fireEvent.click(screen.getByRole("button", { name: "Add rooms" }));
+ await screen.findByText("retro");
+ expect(screen.queryByText("board")).toBeNull();
+ });
});
diff --git a/gateway/src/pages/rooms/GroupsPage.tsx b/gateway/src/pages/rooms/GroupsPage.tsx
index d7fc39724..f93aef22f 100644
--- a/gateway/src/pages/rooms/GroupsPage.tsx
+++ b/gateway/src/pages/rooms/GroupsPage.tsx
@@ -323,11 +323,12 @@ function MembershipPanel({
[rooms, selectedId, isStandalone],
);
- // Rooms eligible to add: everything not already directly in this group.
+ // Rooms eligible to add: those the viewer may change (filing a room takes
+ // write access to it) that are not already directly in this group.
const addableOptions = useMemo<PickerOption[]>(
() =>
rooms
- .filter((r) => r.group_id !== selectedId)
+ .filter((r) => r.can_write && r.group_id !== selectedId)
.map((r) => ({
id: r.id,
primary: r.name,
@@ -428,7 +429,7 @@ function MembershipPanel({
<Typography variant="body2" sx={{ flexGrow: 1 }} noWrap>
{room.name}
</Typography>
- {!isStandalone && (
+ {!isStandalone && room.can_write && (
<IconButton
size="small"
onClick={() => handleRemove(room.id)}
diff --git a/gateway/src/pages/rooms/RoomCreateFormBody.tsx b/gateway/src/pages/rooms/RoomCreateFormBody.tsx
index fb57eb7ab..0c8549afd 100644
--- a/gateway/src/pages/rooms/RoomCreateFormBody.tsx
+++ b/gateway/src/pages/rooms/RoomCreateFormBody.tsx
@@ -31,6 +31,7 @@ import { AccessSelect } from "../../components/AccessControls";
import { type AccessLevel, fromAccessLevel } from "../../data/visibility";
import { useAgents, useBridges, useBridgeUsers, useRoomGroups } from "../../data/hooks";
import { flattenTree } from "./groupTree";
+import { ROOM_ACCESS_HELPERS, ROOM_ACCESS_OPTION_LABELS } from "./roomAccess";
type ChannelSource = "existing" | "new";
@@ -249,7 +250,13 @@ export default function RoomCreateFormBody() {
helperText="Surfaced to agents on connect. Use this to set the room's purpose, rules, or expected outputs."
/>
- <AccessSelect value={access} onChange={setAccess} disabled={submitting} />
+ <AccessSelect
+ value={access}
+ onChange={setAccess}
+ disabled={submitting}
+ helpers={ROOM_ACCESS_HELPERS}
+ optionLabels={ROOM_ACCESS_OPTION_LABELS}
+ />
{(groups ?? []).length > 0 && (
<TextField
diff --git a/gateway/src/pages/rooms/RoomDetailPage.test.tsx b/gateway/src/pages/rooms/RoomDetailPage.test.tsx
new file mode 100644
index 000000000..da0f5faa0
--- /dev/null
+++ b/gateway/src/pages/rooms/RoomDetailPage.test.tsx
@@ -0,0 +1,209 @@
+import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { AgentSummary, RoomDetail } from "../../data/api";
+import * as api from "../../data/api";
+import * as hooks from "../../data/hooks";
+import RoomDetailPage from "./RoomDetailPage";
+
+vi.mock("react-router", () => ({
+ useNavigate: () => vi.fn(),
+ useParams: () => ({ roomId: "r1" }),
+}));
+
+vi.mock("../../data/hooks", () => ({
+ useAgents: vi.fn(),
+ useBridgeUsers: vi.fn(),
+ useRoom: vi.fn(),
+ useRoomGroups: vi.fn(),
+}));
+
+vi.mock("../../data/api", async (importOriginal) => {
+ const actual = await importOriginal<typeof import("../../data/api")>();
+ return { ...actual, updateRoom: vi.fn() };
+});
+
+vi.mock("./RoomGraphView", () => ({ default: () => null }));
+vi.mock("./ExportRoomYamlDialog", () => ({ default: () => null }));
+// Their own tests cover what they do with it; here, only that they are told.
+vi.mock("./RoomLinkedRoomsSection", () => ({
+ default: ({ canWrite }: { canWrite: boolean }) => (
+ <div data-testid="linked-rooms" data-can-write={String(canWrite)} />
+ ),
+}));
+vi.mock("./RoomResourcesSection", () => ({
+ default: ({ canWrite, canUnlink }: { canWrite: boolean; canUnlink: boolean }) => (
+ <div
+ data-testid="resources"
+ data-can-write={String(canWrite)}
+ data-can-unlink={String(canUnlink)}
+ />
+ ),
+}));
+
+// Public read & write is the default for a new room, so any workspace member
+// can edit it. What the viewer may do comes from the server.
+const room = {
+ id: "r1",
+ name: "planning",
+ description: "Sprint planning",
+ channel_type: null,
+ admin_mode: false,
+ agent_count: 1,
+ connected_user_count: 0,
+ connected_user_names: [],
+ bridge_id: "b1",
+ bridge_display_name: "Slack",
+ group_id: null,
+ group_name: null,
+ owner_id: "owner",
+ owner_name: "ada",
+ read_visibility: "public",
+ write_visibility: "public",
+ created_at: "2026-10-01T00:00:00Z",
+ archived: false,
+ transport_room_id: "!r1:example.test",
+ matrix_room_id: "!r1:example.test",
+ external_channel_id: null,
+ instructions: null,
+ protection_config: null,
+ observe_config: null,
+ agent_ids: ["a1"],
+ agent_statuses: {},
+ roles: [],
+ join_event_listeners: [],
+ archived_at: null,
+ can_write: true,
+ can_manage: false,
+ can_unlink: false,
+} as RoomDetail;
+
+const agent = { id: "a1", name: "planner", parent_agent_id: null } as AgentSummary;
+
+function viewAs(can: { can_write: boolean; can_manage: boolean; can_unlink: boolean }) {
+ vi.mocked(hooks.useRoom).mockReturnValue({
+ data: { ...room, ...can },
+ loading: false,
+ error: null,
+ refetch: vi.fn(),
+ });
+ render(<RoomDetailPage />);
+}
+
+function accessSelect() {
+ return screen.getByRole("combobox", { name: /^Access/ });
+}
+
+function nameField() {
+ return screen.getByRole<HTMLInputElement>("textbox", { name: "Name" });
+}
+
+function joinEventsSwitch() {
+ return screen.getByRole<HTMLInputElement>("switch", {
+ name: "Notify planner when someone joins",
+ });
+}
+
+describe("RoomDetailPage permissions", () => {
+ beforeEach(() => {
+ vi.mocked(hooks.useRoomGroups).mockReturnValue({
+ data: [],
+ loading: false,
+ error: null,
+ refetch: vi.fn(),
+ });
+ vi.mocked(hooks.useAgents).mockReturnValue({
+ data: [agent],
+ loading: false,
+ error: null,
+ refetch: vi.fn(),
+ });
+ vi.mocked(hooks.useBridgeUsers).mockReturnValue({
+ data: [],
+ loading: false,
+ error: null,
+ refetch: vi.fn(),
+ });
+ vi.mocked(api.updateRoom).mockResolvedValue(room);
+ });
+
+ afterEach(() => {
+ cleanup();
+ vi.clearAllMocks();
+ });
+
+ it("lets someone who may write but not manage edit everything but access", async () => {
+ viewAs({ can_write: true, can_manage: false, can_unlink: false });
+
+ expect(accessSelect().getAttribute("aria-disabled")).toBe("true");
+ const describedBy = accessSelect().getAttribute("aria-describedby");
+ expect(document.getElementById(describedBy!)?.textContent).toContain(
+ "Only its owner and admins can change its access.",
+ );
+ expect(screen.queryByRole("button", { name: "Delete room" })).toBeNull();
+ screen.getByRole("button", { name: "Add agent" });
+ screen.getByRole("button", { name: "Remove planner" });
+ screen.getByRole("button", { name: "Add user" });
+ expect(joinEventsSwitch().disabled).toBe(false);
+ expect(screen.getByTestId("resources").dataset.canWrite).toBe("true");
+ expect(screen.getByTestId("linked-rooms").dataset.canWrite).toBe("true");
+
+ fireEvent.change(nameField(), { target: { value: "retro" } });
+ fireEvent.click(screen.getByRole("button", { name: "Save" }));
+
+ await waitFor(() => expect(api.updateRoom).toHaveBeenCalledTimes(1));
+ const [, sent] = vi.mocked(api.updateRoom).mock.calls[0];
+ expect(sent.name).toBe("retro");
+ expect(sent).not.toHaveProperty("read_visibility");
+ expect(sent).not.toHaveProperty("write_visibility");
+ });
+
+ it("lets someone who may manage the room change its access and delete it", async () => {
+ viewAs({ can_write: true, can_manage: true, can_unlink: false });
+
+ expect(accessSelect().getAttribute("aria-disabled")).toBeNull();
+ screen.getByRole("button", { name: "Delete room" });
+
+ fireEvent.mouseDown(accessSelect());
+ fireEvent.click(await screen.findByRole("option", { name: "Private" }));
+ fireEvent.click(screen.getByRole("button", { name: "Save" }));
+
+ await waitFor(() => expect(api.updateRoom).toHaveBeenCalledTimes(1));
+ expect(vi.mocked(api.updateRoom).mock.calls[0][1]).toMatchObject({
+ read_visibility: "private",
+ write_visibility: "private",
+ });
+ });
+
+ it("loads the platform's users only when someone adds one", async () => {
+ viewAs({ can_write: true, can_manage: false, can_unlink: false });
+ expect(hooks.useBridgeUsers).not.toHaveBeenCalled();
+
+ fireEvent.click(screen.getByRole("button", { name: "Add user" }));
+
+ await screen.findByRole("dialog", { name: "Add users" });
+ expect(hooks.useBridgeUsers).toHaveBeenCalledWith("b1");
+ });
+
+ it("offers a reader nothing to change", () => {
+ viewAs({ can_write: false, can_manage: false, can_unlink: false });
+
+ screen.getByText(/You don't have write access to this room/);
+ expect(accessSelect().getAttribute("aria-disabled")).toBe("true");
+ expect(nameField().disabled).toBe(true);
+ expect(screen.queryByRole("button", { name: "Delete room" })).toBeNull();
+ expect(screen.queryByRole("button", { name: "Add agent" })).toBeNull();
+ expect(screen.queryByRole("button", { name: "Remove planner" })).toBeNull();
+ expect(screen.queryByRole("button", { name: "Add user" })).toBeNull();
+ // The setting still shows; it just cannot be changed.
+ expect(joinEventsSwitch().disabled).toBe(true);
+ expect(screen.getByTestId("resources").dataset.canWrite).toBe("false");
+ expect(screen.getByTestId("linked-rooms").dataset.canWrite).toBe("false");
+ });
+
+ it("lets someone taking part in a room they cannot edit unlink its resources", () => {
+ viewAs({ can_write: false, can_manage: false, can_unlink: true });
+
+ expect(screen.getByTestId("resources").dataset.canWrite).toBe("false");
+ expect(screen.getByTestId("resources").dataset.canUnlink).toBe("true");
+ });
+});
diff --git a/gateway/src/pages/rooms/RoomDetailPage.tsx b/gateway/src/pages/rooms/RoomDetailPage.tsx
index 5877c7172..d78357244 100644
--- a/gateway/src/pages/rooms/RoomDetailPage.tsx
+++ b/gateway/src/pages/rooms/RoomDetailPage.tsx
@@ -48,7 +48,6 @@ import {
updateRoomRole,
} from "../../data/api";
import { useAgents, useBridgeUsers, useRoom, useRoomGroups } from "../../data/hooks";
-import { useAuth } from "../../data/AuthContext";
import { AccessChip, AccessSelect } from "../../components/AccessControls";
import { type AccessLevel, fromAccessLevel, toAccessLevel } from "../../data/visibility";
import {
@@ -63,11 +62,11 @@ import RoomGraphView from "./RoomGraphView";
import RoomLinkedRoomsSection from "./RoomLinkedRoomsSection";
import RoomResourcesSection from "./RoomResourcesSection";
import ExportRoomYamlDialog from "./ExportRoomYamlDialog";
+import { ROOM_ACCESS_HELPERS, ROOM_ACCESS_OPTION_LABELS } from "./roomAccess";
export default function RoomDetailPage() {
const { roomId } = useParams<{ roomId: string }>();
const navigate = useNavigate();
- const { user, canAdminTenant } = useAuth();
const { data: room, loading, error, refetch } = useRoom(roomId);
const [exportOpen, setExportOpen] = useState(false);
@@ -92,15 +91,8 @@ export default function RoomDetailPage() {
);
}
- // Room write access: owner, admin, or a publicly-writable room.
- const canWrite =
- !!user &&
- (user.id === room.owner_id ||
- canAdminTenant ||
- room.write_visibility === "public");
- // Delete is stricter — owner or admin only, never via public write.
- const canDelete =
- !!user && (user.id === room.owner_id || canAdminTenant);
+ const canWrite = room.can_write;
+ const canManage = room.can_manage;
return (
<Box>
@@ -135,14 +127,19 @@ export default function RoomDetailPage() {
<EditableFieldsSection
room={room}
canWrite={canWrite}
+ canManage={canManage}
onSaved={refetch}
/>
<Divider />
- <ParticipantsSection room={room} onChanged={refetch} />
+ <ParticipantsSection room={room} canWrite={canWrite} onChanged={refetch} />
<Divider />
- <RoomResourcesSection roomId={room.id} />
+ <RoomResourcesSection
+ roomId={room.id}
+ canWrite={canWrite}
+ canUnlink={room.can_unlink}
+ />
<Divider />
- <RoomLinkedRoomsSection roomId={room.id} />
+ <RoomLinkedRoomsSection roomId={room.id} canWrite={canWrite} />
<Divider />
<RoomGraphView roomId={room.id} />
{room.bridge_id && (
@@ -157,7 +154,7 @@ export default function RoomDetailPage() {
<ArchiveSection room={room} onChanged={refetch} />
</>
)}
- {canDelete && (
+ {canManage && (
<>
<Divider />
<DangerSection room={room} onDeleted={() => navigate("/rooms")} />
@@ -599,10 +596,12 @@ function RoleRow({
function EditableFieldsSection({
room,
canWrite,
+ canManage,
onSaved,
}: {
room: RoomDetail;
canWrite: boolean;
+ canManage: boolean;
onSaved: () => void;
}) {
const [name, setName] = useState(room.name);
@@ -637,7 +636,7 @@ function EditableFieldsSection({
!isBridged && description !== room.description ? description : undefined,
instructions:
instructions !== (room.instructions ?? "") ? instructions : undefined,
- ...(access !== toAccessLevel(room) ? fromAccessLevel(access) : {}),
+ ...(canManage && access !== toAccessLevel(room) ? fromAccessLevel(access) : {}),
});
onSaved();
} catch (err) {
@@ -645,7 +644,7 @@ function EditableFieldsSection({
} finally {
setSaving(false);
}
- }, [room, name, description, instructions, access, isBridged, onSaved]);
+ }, [room, name, description, instructions, access, isBridged, canManage, onSaved]);
return (
<Stack spacing={2}>
@@ -691,7 +690,9 @@ function EditableFieldsSection({
<AccessSelect
value={access}
onChange={setAccess}
- disabled={!canWrite || saving}
+ disabled={!canManage || saving}
+ helpers={ROOM_ACCESS_HELPERS}
+ optionLabels={ROOM_ACCESS_OPTION_LABELS}
sx={{ maxWidth: 360 }}
/>
<Box>
@@ -712,15 +713,14 @@ function EditableFieldsSection({
function ParticipantsSection({
room,
+ canWrite,
onChanged,
}: {
room: RoomDetail;
+ canWrite: boolean;
onChanged: () => void;
}) {
const { data: allAgents, loading: agentsLoading } = useAgents();
- const { data: bridgeUsers, loading: bridgeUsersLoading } = useBridgeUsers(
- room.bridge_id ?? undefined,
- );
const [addUserOpen, setAddUserOpen] = useState(false);
const [addAgentOpen, setAddAgentOpen] = useState(false);
const [error, setError] = useState<string | null>(null);
@@ -807,19 +807,6 @@ function ParticipantsSection({
[room.id, onChanged],
);
- const addableUserOptions = useMemo<PickerOption[]>(
- () =>
- (bridgeUsers ?? [])
- .filter((u) => !room.connected_user_names.includes(u.external_username))
- .map((u) => ({
- id: u.external_username,
- primary: u.external_username,
- secondary: u.external_user_id,
- search: `${u.external_username} ${u.external_user_id}`.toLowerCase(),
- })),
- [bridgeUsers, room.connected_user_names],
- );
-
const handleAddUsers = useCallback(
async (names: string[]) => {
setWorking(true);
@@ -859,10 +846,12 @@ function ParticipantsSection({
status={room.agent_statuses[id]}
receivesJoinEvents={room.join_event_listeners.includes(id)}
onToggleJoinEvents={
- working ? undefined : (next) => handleToggleJoinEvents(id, next)
+ !canWrite || working
+ ? undefined
+ : (next) => handleToggleJoinEvents(id, next)
}
onRemove={
- isFixedMembership || working
+ !canWrite || isFixedMembership || working
? undefined
: () => handleRemoveAgent(id)
}
@@ -874,7 +863,7 @@ function ParticipantsSection({
</Typography>
)}
</Stack>
- {!isFixedMembership && (
+ {canWrite && !isFixedMembership && (
<>
<Button
size="small"
@@ -921,31 +910,73 @@ function ParticipantsSection({
</Typography>
)}
</Stack>
- <Button
- size="small"
- variant="outlined"
- startIcon={<AddIcon />}
- onClick={() => setAddUserOpen(true)}
- sx={{ alignSelf: "flex-start" }}
- >
- Add user
- </Button>
- <SearchablePickerDialog
- open={addUserOpen}
- title="Add users"
- searchPlaceholder="Search users…"
- submitLabel="Add"
- options={addableUserOptions}
- loading={bridgeUsersLoading}
- onClose={() => setAddUserOpen(false)}
- onSubmit={handleAddUsers}
- />
+ {canWrite && (
+ <>
+ <Button
+ size="small"
+ variant="outlined"
+ startIcon={<AddIcon />}
+ onClick={() => setAddUserOpen(true)}
+ sx={{ alignSelf: "flex-start" }}
+ >
+ Add user
+ </Button>
+ {addUserOpen && (
+ <BridgeUserPicker
+ bridgeId={room.bridge_id}
+ connectedNames={room.connected_user_names}
+ onClose={() => setAddUserOpen(false)}
+ onSubmit={handleAddUsers}
+ />
+ )}
+ </>
+ )}
</Box>
)}
</Stack>
);
}
+// Mounted only while open, so the platform's user directory loads only when
+// someone adds a user.
+function BridgeUserPicker({
+ bridgeId,
+ connectedNames,
+ onClose,
+ onSubmit,
+}: {
+ bridgeId: string;
+ connectedNames: string[];
+ onClose: () => void;
+ onSubmit: (names: string[]) => Promise<void>;
+}) {
+ const { data: bridgeUsers, loading } = useBridgeUsers(bridgeId);
+ const options = useMemo<PickerOption[]>(
+ () =>
+ (bridgeUsers ?? [])
+ .filter((u) => !connectedNames.includes(u.external_username))
+ .map((u) => ({
+ id: u.external_username,
+ primary: u.external_username,
+ secondary: u.external_user_id,
+ search: `${u.external_username} ${u.external_user_id}`.toLowerCase(),
+ })),
+ [bridgeUsers, connectedNames],
+ );
+ return (
+ <SearchablePickerDialog
+ open
+ title="Add users"
+ searchPlaceholder="Search users…"
+ submitLabel="Add"
+ options={options}
+ loading={loading}
+ onClose={onClose}
+ onSubmit={onSubmit}
+ />
+ );
+}
+
// ── Agent row ────────────────────────────────────────────────────────────────
const STATUS_META: Record<
@@ -985,7 +1016,8 @@ function AgentRow({
agentId: string;
name: string;
status: string | undefined;
- receivesJoinEvents?: boolean;
+ receivesJoinEvents: boolean;
+ // Absent while the switch cannot be changed; it still shows the setting.
onToggleJoinEvents?: (next: boolean) => void;
onRemove?: () => void;
}) {
@@ -1027,33 +1059,32 @@ function AgentRow({
<Typography variant="caption" color="text.secondary">
{meta.label}
</Typography>
- {onToggleJoinEvents && (
- <Tooltip title="When on, this agent is notified when someone joins the room (room_join events) — useful for a welcome/onboarding agent. Does not affect the agent's presence or status.">
- <FormControlLabel
- onClick={(e) => e.stopPropagation()}
- labelPlacement="start"
- sx={{ mr: 0, ml: 0 }}
- control={
- <Switch
- size="small"
- checked={!!receivesJoinEvents}
- onChange={(e) => onToggleJoinEvents(e.target.checked)}
- inputProps={{ "aria-label": `Notify ${name} when someone joins` }}
+ <Tooltip title="When on, this agent is notified when someone joins the room (room_join events) — useful for a welcome/onboarding agent. Does not affect the agent's presence or status.">
+ <FormControlLabel
+ onClick={(e) => e.stopPropagation()}
+ labelPlacement="start"
+ sx={{ mr: 0, ml: 0 }}
+ control={
+ <Switch
+ size="small"
+ checked={receivesJoinEvents}
+ disabled={!onToggleJoinEvents}
+ onChange={(e) => onToggleJoinEvents?.(e.target.checked)}
+ slotProps={{ input: { "aria-label": `Notify ${name} when someone joins` } }}
+ />
+ }
+ label={
+ <Stack direction="row" spacing={0.5} alignItems="center">
+ <NotificationsActiveOutlined
+ sx={{ fontSize: 15, color: "text.secondary" }}
/>
- }
- label={
- <Stack direction="row" spacing={0.5} alignItems="center">
- <NotificationsActiveOutlined
- sx={{ fontSize: 15, color: "text.secondary" }}
- />
- <Typography variant="caption" color="text.secondary">
- Notify on join
- </Typography>
- </Stack>
- }
- />
- </Tooltip>
- )}
+ <Typography variant="caption" color="text.secondary">
+ Notify on join
+ </Typography>
+ </Stack>
+ }
+ />
+ </Tooltip>
{onRemove && (
<IconButton
size="small"
diff --git a/gateway/src/pages/rooms/RoomLinkedRoomsSection.test.tsx b/gateway/src/pages/rooms/RoomLinkedRoomsSection.test.tsx
new file mode 100644
index 000000000..2b9313984
--- /dev/null
+++ b/gateway/src/pages/rooms/RoomLinkedRoomsSection.test.tsx
@@ -0,0 +1,88 @@
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import type { RoomSummary } from "../../data/api";
+import * as api from "../../data/api";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import * as hooks from "../../data/hooks";
+import RoomLinkedRoomsSection from "./RoomLinkedRoomsSection";
+
+vi.mock("react-router", () => ({
+ useNavigate: () => vi.fn(),
+}));
+
+vi.mock("../../data/hooks", () => ({
+ useLinkedRooms: vi.fn(),
+ useRooms: vi.fn(),
+}));
+
+vi.mock("../../data/api", async (importOriginal) => {
+ const actual = await importOriginal<typeof import("../../data/api")>();
+ return { ...actual, attachLinkedRoom: vi.fn() };
+});
+
+describe("RoomLinkedRoomsSection", () => {
+ beforeEach(() => {
+ vi.mocked(hooks.useLinkedRooms).mockReturnValue({
+ data: [
+ { target_room_id: "r2", target_room_name: "ops", target_room_description: "", label: "support" },
+ ],
+ loading: false,
+ error: null,
+ refetch: vi.fn(),
+ });
+ vi.mocked(hooks.useRooms).mockReturnValue({
+ data: [],
+ loading: false,
+ error: null,
+ refetch: vi.fn(),
+ });
+ });
+
+ afterEach(() => {
+ cleanup();
+ vi.clearAllMocks();
+ });
+
+ it("offers linking and unlinking to someone who may write to the room", () => {
+ render(<RoomLinkedRoomsSection roomId="r1" canWrite />);
+
+ screen.getByRole("button", { name: "Add linked room" });
+ screen.getByRole("button", { name: "Remove link to ops" });
+ });
+
+ it("loads the rooms to link to only when the dialog opens", async () => {
+ render(<RoomLinkedRoomsSection roomId="r1" canWrite />);
+
+ expect(hooks.useRooms).not.toHaveBeenCalled();
+ fireEvent.click(screen.getByRole("button", { name: "Add linked room" }));
+
+ await screen.findByRole("dialog");
+ expect(hooks.useRooms).toHaveBeenCalled();
+ });
+
+ it("stays open while a link is being saved, so a failure is not lost", async () => {
+ vi.mocked(hooks.useRooms).mockReturnValue({
+ data: [{ id: "r3", name: "retro", description: "" } as RoomSummary],
+ loading: false,
+ error: null,
+ refetch: vi.fn(),
+ });
+ vi.mocked(api.attachLinkedRoom).mockReturnValue(new Promise(() => {}));
+ render(<RoomLinkedRoomsSection roomId="r1" canWrite />);
+
+ fireEvent.click(screen.getByRole("button", { name: "Add linked room" }));
+ fireEvent.click(await screen.findByText("retro"));
+ fireEvent.change(screen.getByLabelText("Label"), { target: { value: "follows" } });
+ fireEvent.click(screen.getByRole("button", { name: "Add" }));
+ fireEvent.keyDown(screen.getByRole("dialog"), { key: "Escape" });
+
+ screen.getByRole("dialog");
+ });
+
+ it("lists the links, with nothing to change, to a reader", () => {
+ render(<RoomLinkedRoomsSection roomId="r1" canWrite={false} />);
+
+ screen.getByText("ops");
+ expect(screen.queryByRole("button", { name: "Add linked room" })).toBeNull();
+ expect(screen.queryByRole("button", { name: "Remove link to ops" })).toBeNull();
+ });
+});
diff --git a/gateway/src/pages/rooms/RoomLinkedRoomsSection.tsx b/gateway/src/pages/rooms/RoomLinkedRoomsSection.tsx
index a7475bf86..799882caa 100644
--- a/gateway/src/pages/rooms/RoomLinkedRoomsSection.tsx
+++ b/gateway/src/pages/rooms/RoomLinkedRoomsSection.tsx
@@ -25,9 +25,10 @@ import { useLinkedRooms, useRooms } from "../../data/hooks";
interface Props {
roomId: string;
+ canWrite: boolean;
}
-export default function RoomLinkedRoomsSection({ roomId }: Props) {
+export default function RoomLinkedRoomsSection({ roomId, canWrite }: Props) {
const { data: linked, loading, refetch } = useLinkedRooms(roomId);
const [dialogOpen, setDialogOpen] = useState(false);
const [error, setError] = useState<string | null>(null);
@@ -92,51 +93,58 @@ export default function RoomLinkedRoomsSection({ roomId }: Props) {
</Typography>
)}
</Stack>
- <IconButton
- size="small"
- disabled={busy}
- onClick={(e) => {
- e.stopPropagation();
- handleDetach(link.target_room_id);
- }}
- >
- <DeleteOutline fontSize="small" />
- </IconButton>
+ {canWrite && (
+ <IconButton
+ size="small"
+ disabled={busy}
+ onClick={(e) => {
+ e.stopPropagation();
+ handleDetach(link.target_room_id);
+ }}
+ aria-label={`Remove link to ${link.target_room_name}`}
+ >
+ <DeleteOutline fontSize="small" />
+ </IconButton>
+ )}
</Stack>
))}
</Stack>
)}
- <Button
- size="small"
- variant="outlined"
- startIcon={<AddIcon />}
- onClick={() => setDialogOpen(true)}
- sx={{ alignSelf: "flex-start" }}
- >
- Add linked room
- </Button>
- <AddLinkedRoomDialog
- open={dialogOpen}
- sourceRoomId={roomId}
- existingTargetIds={existingTargetIds}
- onClose={() => setDialogOpen(false)}
- onCreated={() => {
- setDialogOpen(false);
- refetch();
- }}
- />
+ {canWrite && (
+ <>
+ <Button
+ size="small"
+ variant="outlined"
+ startIcon={<AddIcon />}
+ onClick={() => setDialogOpen(true)}
+ sx={{ alignSelf: "flex-start" }}
+ >
+ Add linked room
+ </Button>
+ {dialogOpen && (
+ <AddLinkedRoomDialog
+ sourceRoomId={roomId}
+ existingTargetIds={existingTargetIds}
+ onClose={() => setDialogOpen(false)}
+ onCreated={() => {
+ setDialogOpen(false);
+ refetch();
+ }}
+ />
+ )}
+ </>
+ )}
</Stack>
);
}
+// Mounted only while open, so the room list loads only when someone links.
function AddLinkedRoomDialog({
- open,
sourceRoomId,
existingTargetIds,
onClose,
onCreated,
}: {
- open: boolean;
sourceRoomId: string;
existingTargetIds: Set<string>;
onClose: () => void;
@@ -167,9 +175,6 @@ function AddLinkedRoomDialog({
setError(null);
try {
await attachLinkedRoom(sourceRoomId, selectedId, label.trim());
- setSearch("");
- setSelectedId(null);
- setLabel("");
onCreated();
} catch (e) {
setError(e instanceof Error ? e.message : "Failed to add link");
@@ -178,16 +183,8 @@ function AddLinkedRoomDialog({
}
};
- const handleClose = () => {
- setSearch("");
- setSelectedId(null);
- setLabel("");
- setError(null);
- onClose();
- };
-
return (
- <Dialog open={open} onClose={handleClose} fullWidth maxWidth="sm">
+ <Dialog open onClose={busy ? undefined : onClose} fullWidth maxWidth="sm">
<DialogTitle>Add linked room</DialogTitle>
<DialogContent>
<Stack spacing={2} sx={{ pt: 1 }}>
@@ -240,7 +237,7 @@ function AddLinkedRoomDialog({
</Stack>
</DialogContent>
<DialogActions>
- <Button onClick={handleClose} disabled={busy}>
+ <Button onClick={onClose} disabled={busy}>
Cancel
</Button>
<Button
diff --git a/gateway/src/pages/rooms/RoomResourcesSection.test.tsx b/gateway/src/pages/rooms/RoomResourcesSection.test.tsx
new file mode 100644
index 000000000..d0039f947
--- /dev/null
+++ b/gateway/src/pages/rooms/RoomResourcesSection.test.tsx
@@ -0,0 +1,132 @@
+import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import * as api from "../../data/api";
+import * as hooks from "../../data/hooks";
+import RoomResourcesSection from "./RoomResourcesSection";
+
+vi.mock("react-router", () => ({
+ useNavigate: () => vi.fn(),
+}));
+
+vi.mock("../../data/hooks", () => ({
+ useDocuments: vi.fn(),
+ usePackages: vi.fn(),
+ useReferences: vi.fn(),
+ useRoomDocuments: vi.fn(),
+ useRoomPackages: vi.fn(),
+ useRoomReferences: vi.fn(),
+}));
+
+vi.mock("../../data/api", async (importOriginal) => {
+ const actual = await importOriginal<typeof import("../../data/api")>();
+ return { ...actual, detachDocumentFromRoom: vi.fn() };
+});
+
+function returns<T>(data: T) {
+ return { data, loading: false, error: null, refetch: vi.fn() };
+}
+
+// The server says, per document, whether the viewer may remove it: unlink it
+// if attached, delete it if room-scoped.
+function roomDocuments({ canRemove }: { canRemove: boolean }) {
+ vi.mocked(hooks.useRoomDocuments).mockReturnValue(
+ returns([
+ { id: "d1", name: "Spec", description: "", scope: "global", packages: [], can_remove: canRemove },
+ { id: "d2", name: "Notes", description: "", scope: "room", created_by_agent_name: "planner", can_remove: canRemove },
+ ]) as never,
+ );
+}
+
+const ATTACH = ["Attach reference", "Attach document", "Attach package"];
+const UNLINK = ["Unlink Runbook", "Unlink Starter kit"];
+const REMOVE = ["Unlink Spec", "Delete Notes"];
+
+function button(name: string) {
+ return screen.queryByRole("button", { name });
+}
+
+describe("RoomResourcesSection", () => {
+ beforeEach(() => {
+ vi.mocked(hooks.useRoomReferences).mockReturnValue(
+ returns([
+ { id: "ref1", name: "Runbook", description: "", type: "confluence", type_display_name: "Confluence", packages: [] },
+ ]) as never,
+ );
+ roomDocuments({ canRemove: true });
+ vi.mocked(hooks.useRoomPackages).mockReturnValue(
+ returns([{ id: "p1", name: "Starter kit", description: "" }]) as never,
+ );
+ vi.mocked(hooks.useReferences).mockReturnValue(
+ returns([
+ { id: "ref2", name: "Playbook", description: "", type: "confluence", type_display_name: "Confluence" },
+ ]) as never,
+ );
+ vi.mocked(hooks.useDocuments).mockReturnValue(returns([]) as never);
+ vi.mocked(hooks.usePackages).mockReturnValue(returns([]) as never);
+ vi.mocked(api.detachDocumentFromRoom).mockResolvedValue(undefined as never);
+ });
+
+ afterEach(() => {
+ cleanup();
+ vi.clearAllMocks();
+ vi.restoreAllMocks();
+ });
+
+ it("offers attaching to writers and unlinking to those taking part", () => {
+ render(<RoomResourcesSection roomId="r1" canWrite canUnlink />);
+
+ for (const name of [...ATTACH, ...UNLINK, ...REMOVE]) screen.getByRole("button", { name });
+ });
+
+ it("lets someone taking part unlink without write access, but not attach", () => {
+ render(<RoomResourcesSection roomId="r1" canWrite={false} canUnlink />);
+
+ for (const name of [...UNLINK, ...REMOVE]) screen.getByRole("button", { name });
+ for (const name of ATTACH) expect(button(name)).toBeNull();
+ });
+
+ it("follows the server on which documents the viewer may remove", () => {
+ roomDocuments({ canRemove: false });
+ render(<RoomResourcesSection roomId="r1" canWrite canUnlink />);
+
+ for (const name of REMOVE) expect(button(name)).toBeNull();
+ for (const name of UNLINK) screen.getByRole("button", { name });
+ });
+
+ it("lists what is attached, with nothing to change, to a reader", () => {
+ roomDocuments({ canRemove: false });
+ render(<RoomResourcesSection roomId="r1" canWrite={false} canUnlink={false} />);
+
+ for (const item of ["Runbook", "Spec", "Notes", "Starter kit"]) screen.getByText(item);
+ for (const name of [...ATTACH, ...UNLINK, ...REMOVE]) expect(button(name)).toBeNull();
+ });
+
+ it("loads what can be attached only when a picker opens", async () => {
+ render(<RoomResourcesSection roomId="r1" canWrite canUnlink />);
+
+ expect(hooks.useReferences).not.toHaveBeenCalled();
+ expect(hooks.useDocuments).not.toHaveBeenCalled();
+ expect(hooks.usePackages).not.toHaveBeenCalled();
+
+ fireEvent.click(screen.getByRole("button", { name: "Attach reference" }));
+
+ await screen.findByText("Playbook");
+ expect(hooks.useReferences).toHaveBeenCalled();
+ expect(hooks.useDocuments).not.toHaveBeenCalled();
+ });
+
+ it("asks before deleting a room document, which cannot be undone", async () => {
+ const confirm = vi.spyOn(window, "confirm").mockReturnValue(false);
+ render(<RoomResourcesSection roomId="r1" canWrite canUnlink />);
+
+ fireEvent.click(screen.getByRole("button", { name: "Delete Notes" }));
+ expect(confirm).toHaveBeenCalledWith(
+ "Delete room document “Notes”? This cannot be undone.",
+ );
+ expect(api.detachDocumentFromRoom).not.toHaveBeenCalled();
+
+ confirm.mockReturnValue(true);
+ fireEvent.click(screen.getByRole("button", { name: "Delete Notes" }));
+ await waitFor(() => expect(api.detachDocumentFromRoom).toHaveBeenCalledWith("r1", "d2"));
+ });
+});
diff --git a/gateway/src/pages/rooms/RoomResourcesSection.tsx b/gateway/src/pages/rooms/RoomResourcesSection.tsx
index 3a1d8fc1c..b12b5a1bc 100644
--- a/gateway/src/pages/rooms/RoomResourcesSection.tsx
+++ b/gateway/src/pages/rooms/RoomResourcesSection.tsx
@@ -9,7 +9,7 @@ import {
Stack,
Typography,
} from "@mui/material";
-import { useMemo, useState } from "react";
+import { type ReactNode, useMemo, useState } from "react";
import { useNavigate } from "react-router";
import SearchablePickerDialog, {
type PickerOption,
@@ -33,9 +33,12 @@ import {
interface Props {
roomId: string;
+ // Attaching takes write access to the room; unlinking takes part in it.
+ canWrite: boolean;
+ canUnlink: boolean;
}
-export default function RoomResourcesSection({ roomId }: Props) {
+export default function RoomResourcesSection({ roomId, canWrite, canUnlink }: Props) {
const { data: roomPackages, refetch: refetchPackages } = useRoomPackages(roomId);
const attachedPackageIds = useMemo(
() => new Set((roomPackages ?? []).map((p) => p.id)),
@@ -54,16 +57,21 @@ export default function RoomResourcesSection({ roomId }: Props) {
</Typography>
<RoomReferences
roomId={roomId}
+ canWrite={canWrite}
+ canUnlink={canUnlink}
attachedPackageIds={attachedPackageIds}
packageDescriptions={packageDescriptions}
/>
<RoomDocuments
roomId={roomId}
+ canWrite={canWrite}
attachedPackageIds={attachedPackageIds}
packageDescriptions={packageDescriptions}
/>
<RoomPackages
roomId={roomId}
+ canWrite={canWrite}
+ canUnlink={canUnlink}
packages={roomPackages ?? []}
refetch={refetchPackages}
/>
@@ -103,10 +111,14 @@ function PackageChips({
function RoomReferences({
roomId,
+ canWrite,
+ canUnlink,
attachedPackageIds,
packageDescriptions,
}: {
roomId: string;
+ canWrite: boolean;
+ canUnlink: boolean;
attachedPackageIds: Set<string>;
packageDescriptions: Record<string, string>;
}) {
@@ -116,8 +128,6 @@ function RoomReferences({
error,
refetch,
} = useRoomReferences(roomId);
- const { data: allRefs, loading: allLoading } = useReferences();
- const [pickerOpen, setPickerOpen] = useState(false);
const [error_, setError] = useState<string | null>(null);
const [busy, setBusy] = useState(false);
@@ -126,26 +136,6 @@ function RoomReferences({
[attached],
);
- const options = useMemo<PickerOption[]>(
- () =>
- (allRefs ?? [])
- .filter((r) => !attachedIds.has(r.id))
- .map((r) => ({
- id: r.id,
- primary: (
- <Stack direction="row" alignItems="center" spacing={1}>
- <Chip
- label={r.type_display_name ?? `${r.type} (unknown type)`}
- size="small"
- />
- <span>{r.name || r.description}</span>
- </Stack>
- ),
- search: `${r.name} ${r.description} ${r.type} ${r.type_display_name ?? ""}`.toLowerCase(),
- })),
- [allRefs, attachedIds],
- );
-
const handleAttach = async (ids: string[]) => {
setBusy(true);
setError(null);
@@ -213,46 +203,41 @@ function RoomReferences({
attachedPackageIds={attachedPackageIds}
packageDescriptions={packageDescriptions}
/>
- <IconButton
- size="small"
- onClick={() => handleDetach(ref.id)}
- disabled={busy}
- >
- <DeleteOutline fontSize="small" />
- </IconButton>
+ {canUnlink && (
+ <Button
+ size="small"
+ onClick={() => handleDetach(ref.id)}
+ disabled={busy}
+ aria-label={`Unlink ${ref.name || ref.description}`}
+ >
+ Unlink
+ </Button>
+ )}
</Stack>
))}
</Stack>
)}
- <Button
- size="small"
- variant="outlined"
- startIcon={<AddIcon />}
- onClick={() => setPickerOpen(true)}
- sx={{ alignSelf: "flex-start" }}
- >
- Attach reference
- </Button>
- <SearchablePickerDialog
- open={pickerOpen}
- title="Attach references"
- searchPlaceholder="Search references…"
- submitLabel="Attach"
- options={options}
- loading={allLoading}
- onClose={() => setPickerOpen(false)}
- onSubmit={handleAttach}
- />
+ <AttachControl canWrite={canWrite} label="Attach reference">
+ {(close) => (
+ <ReferencePicker
+ attachedIds={attachedIds}
+ onClose={close}
+ onSubmit={handleAttach}
+ />
+ )}
+ </AttachControl>
</Stack>
);
}
function RoomDocuments({
roomId,
+ canWrite,
attachedPackageIds,
packageDescriptions,
}: {
roomId: string;
+ canWrite: boolean;
attachedPackageIds: Set<string>;
packageDescriptions: Record<string, string>;
}) {
@@ -262,8 +247,6 @@ function RoomDocuments({
error,
refetch,
} = useRoomDocuments(roomId);
- const { data: allDocs, loading: allLoading } = useDocuments();
- const [pickerOpen, setPickerOpen] = useState(false);
const [error_, setError] = useState<string | null>(null);
const [busy, setBusy] = useState(false);
@@ -272,18 +255,6 @@ function RoomDocuments({
[attached],
);
- const options = useMemo<PickerOption[]>(
- () =>
- (allDocs ?? [])
- .filter((d) => !attachedIds.has(d.id))
- .map((d) => ({
- id: d.id,
- primary: d.name || d.description,
- search: `${d.name} ${d.description}`.toLowerCase(),
- })),
- [allDocs, attachedIds],
- );
-
const handleAttach = async (ids: string[]) => {
setBusy(true);
setError(null);
@@ -353,13 +324,16 @@ function RoomDocuments({
attachedPackageIds={attachedPackageIds}
packageDescriptions={packageDescriptions}
/>
- <IconButton
- size="small"
- onClick={() => handleDetach(doc.id)}
- disabled={busy}
- >
- <DeleteOutline fontSize="small" />
- </IconButton>
+ {doc.can_remove && (
+ <Button
+ size="small"
+ onClick={() => handleDetach(doc.id)}
+ disabled={busy}
+ aria-label={`Unlink ${doc.name || doc.description}`}
+ >
+ Unlink
+ </Button>
+ )}
</Stack>
))}
</Stack>
@@ -400,75 +374,62 @@ function RoomDocuments({
variant="outlined"
/>
)}
- <IconButton
- size="small"
- onClick={(e) => {
- e.stopPropagation();
- handleDetach(doc.id);
- }}
- disabled={busy}
- >
- <DeleteOutline fontSize="small" />
- </IconButton>
+ {doc.can_remove && (
+ <IconButton
+ size="small"
+ onClick={(e) => {
+ e.stopPropagation();
+ if (
+ window.confirm(
+ `Delete room document “${doc.name || doc.description}”? This cannot be undone.`,
+ )
+ )
+ handleDetach(doc.id);
+ }}
+ disabled={busy}
+ aria-label={`Delete ${doc.name || doc.description}`}
+ >
+ <DeleteOutline fontSize="small" />
+ </IconButton>
+ )}
</Stack>
))}
</Stack>
)}
</Stack>
)}
- <Button
- size="small"
- variant="outlined"
- startIcon={<AddIcon />}
- onClick={() => setPickerOpen(true)}
- sx={{ alignSelf: "flex-start" }}
- >
- Attach document
- </Button>
- <SearchablePickerDialog
- open={pickerOpen}
- title="Attach documents"
- searchPlaceholder="Search documents…"
- submitLabel="Attach"
- options={options}
- loading={allLoading}
- onClose={() => setPickerOpen(false)}
- onSubmit={handleAttach}
- />
+ <AttachControl canWrite={canWrite} label="Attach document">
+ {(close) => (
+ <DocumentPicker
+ attachedIds={attachedIds}
+ onClose={close}
+ onSubmit={handleAttach}
+ />
+ )}
+ </AttachControl>
</Stack>
);
}
function RoomPackages({
roomId,
+ canWrite,
+ canUnlink,
packages,
refetch,
}: {
roomId: string;
+ canWrite: boolean;
+ canUnlink: boolean;
packages: Array<{ id: string; name: string; description: string }>;
refetch: () => void;
}) {
const navigate = useNavigate();
- const { data: allPackages, loading: allLoading } = usePackages();
- const [pickerOpen, setPickerOpen] = useState(false);
const [error, setError] = useState<string | null>(null);
const [busy, setBusy] = useState(false);
const attachedIds = useMemo(() => new Set(packages.map((p) => p.id)), [packages]);
- const options = useMemo<PickerOption[]>(
- () =>
- (allPackages ?? [])
- .filter((p) => !attachedIds.has(p.id))
- .map((p) => ({
- id: p.id,
- primary: p.name || p.description,
- secondary: p.description || undefined,
- search: `${p.name} ${p.description}`.toLowerCase(),
- })),
- [allPackages, attachedIds],
- );
-
const handleAttach = async (ids: string[]) => {
setBusy(true);
setError(null);
@@ -526,39 +487,158 @@ function RoomPackages({
<Typography variant="body2" sx={{ flexGrow: 1 }}>
{p.name || p.description}
</Typography>
- <IconButton
- size="small"
- onClick={(e) => {
- e.stopPropagation();
- handleDetach(p.id);
- }}
- disabled={busy}
- >
- <DeleteOutline fontSize="small" />
- </IconButton>
+ {canUnlink && (
+ <Button
+ size="small"
+ onClick={(e) => {
+ e.stopPropagation();
+ handleDetach(p.id);
+ }}
+ disabled={busy}
+ aria-label={`Unlink ${p.name || p.description}`}
+ >
+ Unlink
+ </Button>
+ )}
</Stack>
))}
</Stack>
)}
+ <AttachControl canWrite={canWrite} label="Attach package">
+ {(close) => (
+ <PackagePicker
+ attachedIds={attachedIds}
+ onClose={close}
+ onSubmit={handleAttach}
+ />
+ )}
+ </AttachControl>
+ </Stack>
+ );
+}
+
+// The Attach button and its picker, for those who may write to the room. The
+// picker is mounted only while open, so the list it offers loads only when
+// someone attaches.
+function AttachControl({
+ canWrite,
+ label,
+ children,
+}: {
+ canWrite: boolean;
+ label: string;
+ children: (close: () => void) => ReactNode;
+}) {
+ const [open, setOpen] = useState(false);
+ if (!canWrite) return null;
+ return (
+ <>
<Button
size="small"
variant="outlined"
startIcon={<AddIcon />}
- onClick={() => setPickerOpen(true)}
+ onClick={() => setOpen(true)}
sx={{ alignSelf: "flex-start" }}
>
- Attach package
+ {label}
</Button>
- <SearchablePickerDialog
- open={pickerOpen}
- title="Attach packages"
- searchPlaceholder="Search packages…"
- submitLabel="Attach"
- options={options}
- loading={allLoading}
- onClose={() => setPickerOpen(false)}
- onSubmit={handleAttach}
- />
- </Stack>
+ {open && children(() => setOpen(false))}
+ </>
+ );
+}
+
+interface PickerProps {
+ attachedIds: Set<string>;
+ onClose: () => void;
+ onSubmit: (ids: string[]) => Promise<void>;
+}
+
+function ReferencePicker({ attachedIds, onClose, onSubmit }: PickerProps) {
+ const { data, loading } = useReferences();
+ const options = useMemo<PickerOption[]>(
+ () =>
+ (data ?? [])
+ .filter((r) => !attachedIds.has(r.id))
+ .map((r) => ({
+ id: r.id,
+ primary: (
+ <Stack direction="row" alignItems="center" spacing={1}>
+ <Chip
+ label={r.type_display_name ?? `${r.type} (unknown type)`}
+ size="small"
+ />
+ <span>{r.name || r.description}</span>
+ </Stack>
+ ),
+ search: `${r.name} ${r.description} ${r.type} ${r.type_display_name ?? ""}`.toLowerCase(),
+ })),
+ [data, attachedIds],
+ );
+ return (
+ <SearchablePickerDialog
+ open
+ title="Attach references"
+ searchPlaceholder="Search references…"
+ submitLabel="Attach"
+ options={options}
+ loading={loading}
+ onClose={onClose}
+ onSubmit={onSubmit}
+ />
+ );
+}
+
+function DocumentPicker({ attachedIds, onClose, onSubmit }: PickerProps) {
+ const { data, loading } = useDocuments();
+ const options = useMemo<PickerOption[]>(
+ () =>
+ (data ?? [])
+ .filter((d) => !attachedIds.has(d.id))
+ .map((d) => ({
+ id: d.id,
+ primary: d.name || d.description,
+ search: `${d.name} ${d.description}`.toLowerCase(),
+ })),
+ [data, attachedIds],
+ );
+ return (
+ <SearchablePickerDialog
+ open
+ title="Attach documents"
+ searchPlaceholder="Search documents…"
+ submitLabel="Attach"
+ options={options}
+ loading={loading}
+ onClose={onClose}
+ onSubmit={onSubmit}
+ />
+ );
+}
+
+function PackagePicker({ attachedIds, onClose, onSubmit }: PickerProps) {
+ const { data, loading } = usePackages();
+ const options = useMemo<PickerOption[]>(
+ () =>
+ (data ?? [])
+ .filter((p) => !attachedIds.has(p.id))
+ .map((p) => ({
+ id: p.id,
+ primary: p.name || p.description,
+ secondary: p.description || undefined,
+ search: `${p.name} ${p.description}`.toLowerCase(),
+ })),
+ [data, attachedIds],
+ );
+ return (
+ <SearchablePickerDialog
+ open
+ title="Attach packages"
+ searchPlaceholder="Search packages…"
+ submitLabel="Attach"
+ options={options}
+ loading={loading}
+ onClose={onClose}
+ onSubmit={onSubmit}
+ />
);
}
diff --git a/gateway/src/pages/rooms/RoomScopedDocumentView.test.tsx b/gateway/src/pages/rooms/RoomScopedDocumentView.test.tsx
new file mode 100644
index 000000000..cfa62e5cc
--- /dev/null
+++ b/gateway/src/pages/rooms/RoomScopedDocumentView.test.tsx
@@ -0,0 +1,60 @@
+import { cleanup, render, screen } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { RoomDocumentDetail } from "../../data/api";
+import * as hooks from "../../data/hooks";
+import RoomScopedDocumentView from "./RoomScopedDocumentView";
+
+vi.mock("react-router", () => ({
+ useNavigate: () => vi.fn(),
+ useParams: () => ({ roomId: "r1", documentId: "d1" }),
+}));
+
+vi.mock("../../data/hooks", () => ({
+ useRoomDocument: vi.fn(),
+}));
+
+function showDocument(canRemove: boolean, scope: "room" | "global" = "room") {
+ vi.mocked(hooks.useRoomDocument).mockReturnValue({
+ data: {
+ id: "d1",
+ name: "Notes",
+ description: "",
+ content: "hello",
+ scope,
+ can_remove: canRemove,
+ } as RoomDocumentDetail,
+ loading: false,
+ error: null,
+ refetch: vi.fn(),
+ });
+}
+
+describe("RoomScopedDocumentView", () => {
+ afterEach(() => {
+ cleanup();
+ vi.clearAllMocks();
+ });
+
+ it("offers deleting a room document to someone who may delete it", () => {
+ showDocument(true);
+ render(<RoomScopedDocumentView />);
+
+ screen.getByRole("button", { name: "Delete" });
+ });
+
+ it("shows a reader the document with no way to delete it", () => {
+ showDocument(false);
+ render(<RoomScopedDocumentView />);
+
+ screen.getByText("hello");
+ expect(screen.queryByRole("button", { name: "Delete" })).toBeNull();
+ });
+
+ it("offers unlinking, not deleting, a document only attached to the room", () => {
+ showDocument(true, "global");
+ render(<RoomScopedDocumentView />);
+
+ screen.getByRole("button", { name: "Unlink from room" });
+ expect(screen.queryByRole("button", { name: "Delete" })).toBeNull();
+ });
+});
diff --git a/gateway/src/pages/rooms/RoomScopedDocumentView.tsx b/gateway/src/pages/rooms/RoomScopedDocumentView.tsx
index c1e51e03c..5e35cf2e5 100644
--- a/gateway/src/pages/rooms/RoomScopedDocumentView.tsx
+++ b/gateway/src/pages/rooms/RoomScopedDocumentView.tsx
@@ -51,10 +51,16 @@ export default function RoomScopedDocumentView() {
);
}
+ const isRoomScoped = doc.scope === "room";
+
+ // A room-scoped document lives only here, so removing it deletes it. An
+ // attached one is only unlinked from the room.
const handleDelete = async () => {
if (
!window.confirm(
- `Delete room document “${doc.name}”? This cannot be undone.`,
+ isRoomScoped
+ ? `Delete room document “${doc.name}”? This cannot be undone.`
+ : `Unlink “${doc.name}” from this room? The document itself is kept.`,
)
)
return;
@@ -69,8 +75,6 @@ export default function RoomScopedDocumentView() {
}
};
- const isRoomScoped = doc.scope === "room";
-
return (
<Box>
<Stack direction="row" alignItems="center" spacing={1} mb={2}>
@@ -135,16 +139,24 @@ export default function RoomScopedDocumentView() {
<Divider />
{deleteError && <Alert severity="error">{deleteError}</Alert>}
- <Stack direction="row" justifyContent="flex-end">
- <Button
- color="error"
- startIcon={<DeleteOutline />}
- onClick={handleDelete}
- disabled={deleting}
- >
- Delete
- </Button>
- </Stack>
+ {doc.can_remove && (
+ <Stack direction="row" justifyContent="flex-end">
+ {isRoomScoped ? (
+ <Button
+ color="error"
+ startIcon={<DeleteOutline />}
+ onClick={handleDelete}
+ disabled={deleting}
+ >
+ Delete
+ </Button>
+ ) : (
+ <Button onClick={handleDelete} disabled={deleting}>
+ Unlink from room
+ </Button>
+ )}
+ </Stack>
+ )}
</Stack>
</Paper>
</Box>
diff --git a/gateway/src/pages/rooms/RoomsPage.test.tsx b/gateway/src/pages/rooms/RoomsPage.test.tsx
new file mode 100644
index 000000000..fd4a69e12
--- /dev/null
+++ b/gateway/src/pages/rooms/RoomsPage.test.tsx
@@ -0,0 +1,94 @@
+import { cleanup, render, screen, within } from "@testing-library/react";
+import type { GridColDef } from "@mui/x-data-grid";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { RoomSummary } from "../../data/api";
+import * as hooks from "../../data/hooks";
+import RoomsPage from "./RoomsPage";
+
+vi.mock("react-router", () => ({
+ useNavigate: () => vi.fn(),
+}));
+
+vi.mock("../../data/hooks", () => ({
+ useRoomGroups: vi.fn(),
+ useRooms: vi.fn(),
+}));
+
+// The data grid lays rows out from measured sizes, which jsdom does not have,
+// so it renders none. This draws each row, its action cell, and whether it
+// may be ticked for a bulk action.
+vi.mock("../../components/DataTable", () => ({
+ default: ({
+ rows,
+ columns,
+ isRowSelectable,
+ }: {
+ rows: RoomSummary[];
+ columns: GridColDef<RoomSummary>[];
+ isRowSelectable?: (row: RoomSummary) => boolean;
+ }) => {
+ const actions = columns.find((c) => c.field === "actions");
+ return (
+ <div>
+ {rows.map((row) => (
+ <div
+ key={row.id}
+ data-testid={`row-${row.name}`}
+ data-selectable={String(isRowSelectable ? isRowSelectable(row) : true)}
+ >
+ {actions?.renderCell?.({ row } as never)}
+ </div>
+ ))}
+ </div>
+ );
+ },
+}));
+
+function room(id: string, name: string, canWrite: boolean) {
+ return {
+ id,
+ name,
+ description: "",
+ archived: false,
+ group_id: null,
+ bridge_id: null,
+ connected_user_names: [],
+ owner_id: "owner",
+ read_visibility: "public",
+ write_visibility: canWrite ? "public" : "private",
+ can_write: canWrite,
+ } as unknown as RoomSummary;
+}
+
+describe("RoomsPage archiving", () => {
+ beforeEach(() => {
+ vi.mocked(hooks.useRooms).mockReturnValue({
+ data: [room("r1", "planning", true), room("r2", "leadership", false)],
+ loading: false,
+ error: null,
+ refetch: vi.fn(),
+ });
+ vi.mocked(hooks.useRoomGroups).mockReturnValue({
+ data: [],
+ loading: false,
+ error: null,
+ refetch: vi.fn(),
+ });
+ });
+
+ afterEach(() => {
+ cleanup();
+ vi.clearAllMocks();
+ });
+
+ it("offers archiving only rooms the viewer may write to", () => {
+ render(<RoomsPage />);
+
+ const writable = screen.getByTestId("row-planning");
+ const readOnly = screen.getByTestId("row-leadership");
+ within(writable).getByRole("button", { name: "Archive" });
+ expect(within(readOnly).queryByRole("button", { name: "Archive" })).toBeNull();
+ expect(writable.dataset.selectable).toBe("true");
+ expect(readOnly.dataset.selectable).toBe("false");
+ });
+});
diff --git a/gateway/src/pages/rooms/RoomsPage.tsx b/gateway/src/pages/rooms/RoomsPage.tsx
index a6ff4c547..a2bebafab 100644
--- a/gateway/src/pages/rooms/RoomsPage.tsx
+++ b/gateway/src/pages/rooms/RoomsPage.tsx
@@ -176,25 +176,27 @@ export default function RoomsPage() {
width: 116,
sortable: false,
filterable: false,
- renderCell: ({ row }) => (
- <Button
- size="small"
- color="inherit"
- startIcon={
- row.archived ? (
- <UnarchiveOutlined fontSize="small" />
- ) : (
- <ArchiveOutlined fontSize="small" />
- )
- }
- onClick={(e) => {
- e.stopPropagation();
- handleToggleArchive(row.id, row.archived);
- }}
- >
- {row.archived ? "Unarchive" : "Archive"}
- </Button>
- ),
+ // Archiving takes write access to the room.
+ renderCell: ({ row }) =>
+ row.can_write ? (
+ <Button
+ size="small"
+ color="inherit"
+ startIcon={
+ row.archived ? (
+ <UnarchiveOutlined fontSize="small" />
+ ) : (
+ <ArchiveOutlined fontSize="small" />
+ )
+ }
+ onClick={(e) => {
+ e.stopPropagation();
+ handleToggleArchive(row.id, row.archived);
+ }}
+ >
+ {row.archived ? "Unarchive" : "Archive"}
+ </Button>
+ ) : null,
},
],
[handleToggleArchive, byId],
@@ -251,6 +253,7 @@ export default function RoomsPage() {
columns={columns}
fillHeight
checkboxSelection
+ isRowSelectable={(room) => room.can_write}
onRowSelectionModelChange={setSelected}
onRowClick={(params) => navigate(`/rooms/${params.id}`)}
sx={{ "& .MuiDataGrid-row": { cursor: "pointer" } }}
diff --git a/gateway/src/pages/rooms/roomAccess.ts b/gateway/src/pages/rooms/roomAccess.ts
new file mode 100644
index 000000000..e27c949c8
--- /dev/null
+++ b/gateway/src/pages/rooms/roomAccess.ts
@@ -0,0 +1,17 @@
+import type { AccessLevel } from "../../data/visibility";
+
+/** The access levels as they apply to a room. The shared wording speaks to
+ * the owner ("only you"); this holds for whoever is viewing, and a private
+ * room is also seen by those taking part in it. */
+export const ROOM_ACCESS_HELPERS: Record<AccessLevel, string> = {
+ private:
+ "Only those taking part in the room, its owner and admins can see it. Only its owner and admins can change it.",
+ read_only:
+ "Everyone in the workspace can see it. Only its owner and admins can change it.",
+ public:
+ "Everyone in the workspace can see and change it. Only its owner and admins can change its access.",
+};
+
+export const ROOM_ACCESS_OPTION_LABELS: Partial<Record<AccessLevel, string>> = {
+ private: "Private",
+};