Skip to content

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

Link a room's linked rooms and packages only for people who can open them

Abel Dantas7d7abba0f915
diff --git a/core/switch_core/gateway/room_links.py b/core/switch_core/gateway/room_links.py
index 3c2e18a14..bc25c89a0 100644
--- a/core/switch_core/gateway/room_links.py
+++ b/core/switch_core/gateway/room_links.py
@@ -1,10 +1,11 @@
from __future__ import annotations
-from typing import Annotated
+from typing import Annotated, Any
from fastapi import APIRouter, Depends, HTTPException, Response
from sqlalchemy.ext.asyncio import AsyncSession
+from switch_core.authz import Principal, can
from switch_core.bridges.resource.service import ResourceService
from switch_core.db.models import User
from switch_core.db.stores.room_store import RoomStore
@@ -28,6 +29,24 @@ from switch_core.gateway.schemas import (
router = APIRouter()
+async def _linked_room_details(
+ session: AsyncSession,
+ room_store: RoomStore,
+ rows: list[dict[str, Any]],
+ user: User,
+ is_admin: bool,
+) -> list[LinkedRoomDetail]:
+ """The rows as details, each saying whether `user` may read its target."""
+ targets = await room_store.get_many(session, {r["target_room_id"] for r in rows})
+ principal = Principal(user.id, is_admin)
+ details = []
+ for row in rows:
+ target = targets.get(row["target_room_id"])
+ readable = target is not None and can(principal, "read", target)
+ details.append(LinkedRoomDetail(**row, can_read=readable))
+ return details
+
+
@router.get("/linked-rooms/graph")
async def get_room_link_graph(
session: Annotated[AsyncSession, Depends(get_session)],
@@ -49,7 +68,7 @@ async def list_linked_rooms(
) -> list[LinkedRoomDetail]:
await require_room_access(session, room_store, room_id, user, "read", is_admin)
rows = await resource_service.list_linked_rooms_for_room(session, room_id)
- return [LinkedRoomDetail(**row) for row in rows]
+ return await _linked_room_details(session, room_store, rows, user, is_admin)
@router.get("/rooms/{room_id}/linked-rooms/inbound")
@@ -89,7 +108,8 @@ async def create_linked_room(
except ValueError as e:
raise HTTPException(status_code=400, detail=str(e)) from e
await session.commit()
- return LinkedRoomDetail(**row)
+ [detail] = await _linked_room_details(session, room_store, [row], user, is_admin)
+ return detail
@router.delete("/rooms/{room_id}/linked-rooms/{target_room_id}", status_code=204)
diff --git a/core/switch_core/gateway/schemas.py b/core/switch_core/gateway/schemas.py
index 0a54c040d..e22be2f3a 100644
--- a/core/switch_core/gateway/schemas.py
+++ b/core/switch_core/gateway/schemas.py
@@ -1263,6 +1263,9 @@ class LinkedRoomDetail(BaseModel):
target_room_name: str
target_room_description: str
label: str
+ # Whether the caller may open the linked room. A room can link to one its
+ # readers cannot see, and the Gateway shows that one without a link.
+ can_read: bool = False
class InboundLinkedRoomDetail(BaseModel):
diff --git a/core/tests/switch_core/gateway/test_room_detail_access.py b/core/tests/switch_core/gateway/test_room_detail_access.py
index da0f3c858..f54084884 100644
--- a/core/tests/switch_core/gateway/test_room_detail_access.py
+++ b/core/tests/switch_core/gateway/test_room_detail_access.py
@@ -2,7 +2,7 @@
The Gateway offers a room's controls from what the server sends: the room's
owner decides who may change its access or delete it, so the detail has to
-carry it.
+carry it, and a room's linked rooms say whether the caller may open each one.
"""
from __future__ import annotations
@@ -13,17 +13,36 @@ from unittest.mock import AsyncMock
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+from switch_core.bridges.resource.service import ResourceService
from switch_core.db.models import Room, User
from switch_core.db.stores.agent_store import AgentStore
+from switch_core.db.stores.document_store import DocumentStore
+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_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.room_links import create_linked_room, list_linked_rooms
from switch_core.gateway.rooms import get_room
+from switch_core.gateway.schemas import LinkedRoomCreateRequest
_ROOM_STORE = RoomStore()
_USER_STORE = UserStore()
+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,
+ )
+
+
def _protocol() -> Any:
"""Just enough of `AgentCore` for a room with no agents or roles held."""
return SimpleNamespace(
@@ -83,3 +102,78 @@ class TestRoomDetailOwner:
assert detail.owner_id == owner.id
assert detail.owner_name == "owner"
+
+
+class TestLinkedRoomReadAccess:
+ async def test_each_linked_room_says_whether_the_caller_may_read_it(
+ self, session_factory: async_sessionmaker[AsyncSession]
+ ) -> None:
+ async with session_factory() as session:
+ owner = await _add_user(session, name="owner")
+ reader = await _add_user(session, name="reader")
+ source = await _add_room(
+ session, name="src", owner_id=owner.id, read_visibility="public"
+ )
+ shared = await _add_room(
+ session, name="shared", owner_id=owner.id, read_visibility="public"
+ )
+ hidden = await _add_room(session, name="hidden", owner_id=owner.id)
+ mine = await _add_room(session, name="mine", owner_id=reader.id)
+ svc = _svc(session_factory)
+ for target in (shared, hidden, mine):
+ await svc.attach_linked_room(
+ session,
+ source_room_id=source.id,
+ target_room_id=target.id,
+ label="see also",
+ )
+
+ async def readable_for(user: User) -> dict[str, bool]:
+ links = await list_linked_rooms(
+ source.id,
+ session,
+ svc,
+ _ROOM_STORE,
+ user,
+ await _USER_STORE.administers(session, user),
+ )
+ return {link.target_room_name: link.can_read for link in links}
+
+ assert await readable_for(reader) == {
+ "shared": True,
+ "hidden": False,
+ "mine": True,
+ }
+ # The owner reads what they own, not a private room of someone else.
+ assert await readable_for(owner) == {
+ "shared": True,
+ "hidden": True,
+ "mine": False,
+ }
+
+ async def test_a_new_link_says_whether_the_caller_may_read_it(
+ self, session_factory: async_sessionmaker[AsyncSession]
+ ) -> None:
+ async with session_factory() as session:
+ owner = await _add_user(session, name="owner")
+ other = await _add_user(session, name="other")
+ source = await _add_room(
+ session,
+ name="src",
+ owner_id=owner.id,
+ read_visibility="public",
+ write_visibility="public",
+ )
+ hidden = await _add_room(session, name="hidden", owner_id=owner.id)
+
+ link = await create_linked_room(
+ source.id,
+ LinkedRoomCreateRequest(target_room_id=hidden.id, label="see also"),
+ session,
+ _svc(session_factory),
+ _ROOM_STORE,
+ other,
+ await _USER_STORE.administers(session, other),
+ )
+
+ assert link.can_read is False
diff --git a/gateway/src/data/api.ts b/gateway/src/data/api.ts
index b57a44c42..f8ecf1eff 100644
--- a/gateway/src/data/api.ts
+++ b/gateway/src/data/api.ts
@@ -1593,6 +1593,9 @@ export interface LinkedRoomDetail {
target_room_name: string;
target_room_description: string;
label: string;
+ // Whether the caller may open the linked room; a room can link to one its
+ // readers cannot see.
+ can_read: boolean;
}
export interface InboundLinkedRoomDetail {
diff --git a/gateway/src/pages/rooms/RoomLinkedRoomsSection.tsx b/gateway/src/pages/rooms/RoomLinkedRoomsSection.tsx
index a0d34af3c..ddf3b3e01 100644
--- a/gateway/src/pages/rooms/RoomLinkedRoomsSection.tsx
+++ b/gateway/src/pages/rooms/RoomLinkedRoomsSection.tsx
@@ -73,14 +73,23 @@ export default function RoomLinkedRoomsSection({ roomId, canWrite }: Props) {
direction="row"
alignItems="center"
spacing={1}
+ // A linked room the viewer can't read is listed, but not as a
+ // link: opening it would only be refused.
sx={{
px: 1,
py: 0.5,
borderRadius: 1,
- cursor: "pointer",
- "&:hover": { backgroundColor: "action.hover" },
+ ...(link.can_read && {
+ cursor: "pointer",
+ "&:hover": { backgroundColor: "action.hover" },
+ }),
}}
- onClick={() => navigate(`/rooms/${link.target_room_id}`)}
+ onClick={
+ link.can_read
+ ? () => navigate(`/rooms/${link.target_room_id}`)
+ : undefined
+ }
+ data-testid={`linked-room-${link.target_room_id}`}
>
<Chip label={link.label} size="small" />
<Stack sx={{ flexGrow: 1, minWidth: 0 }}>
diff --git a/gateway/src/pages/rooms/RoomResourcesSection.tsx b/gateway/src/pages/rooms/RoomResourcesSection.tsx
index a50b295f0..2d0e43c68 100644
--- a/gateway/src/pages/rooms/RoomResourcesSection.tsx
+++ b/gateway/src/pages/rooms/RoomResourcesSection.tsx
@@ -22,6 +22,7 @@ import {
detachPackageFromRoom,
detachReferenceFromRoom,
} from "../../data/api";
+import { useAuth } from "../../data/AuthContext";
import {
useDocuments,
usePackages,
@@ -30,6 +31,7 @@ import {
useRoomPackages,
useRoomReferences,
} from "../../data/hooks";
+import { canReadResource } from "./roomAccess";
interface Props {
roomId: string;
@@ -47,6 +49,18 @@ export default function RoomResourcesSection({ roomId, canWrite }: Props) {
for (const p of roomPackages ?? []) m[p.id] = p.name || p.description;
return m;
}, [roomPackages]);
+ // A private package attached by its owner is listed to every reader of the
+ // room, but only those who may read it get a link to it.
+ const { user, canAdminTenant } = useAuth();
+ const readablePackageIds = useMemo(
+ () =>
+ new Set(
+ (roomPackages ?? [])
+ .filter((p) => canReadResource(p, user?.id, canAdminTenant))
+ .map((p) => p.id),
+ ),
+ [roomPackages, user, canAdminTenant],
+ );
return (
<Stack spacing={3}>
@@ -57,18 +71,21 @@ export default function RoomResourcesSection({ roomId, canWrite }: Props) {
roomId={roomId}
canWrite={canWrite}
attachedPackageIds={attachedPackageIds}
+ readablePackageIds={readablePackageIds}
packageDescriptions={packageDescriptions}
/>
<RoomDocuments
roomId={roomId}
canWrite={canWrite}
attachedPackageIds={attachedPackageIds}
+ readablePackageIds={readablePackageIds}
packageDescriptions={packageDescriptions}
/>
<RoomPackages
roomId={roomId}
canWrite={canWrite}
packages={roomPackages ?? []}
+ readablePackageIds={readablePackageIds}
refetch={refetchPackages}
/>
</Stack>
@@ -78,10 +95,12 @@ export default function RoomResourcesSection({ roomId, canWrite }: Props) {
function PackageChips({
packageIds,
attachedPackageIds,
+ readablePackageIds,
packageDescriptions,
}: {
packageIds: string[];
attachedPackageIds: Set<string>;
+ readablePackageIds: Set<string>;
packageDescriptions: Record<string, string>;
}) {
const navigate = useNavigate();
@@ -95,10 +114,14 @@ function PackageChips({
label={`via ${packageDescriptions[pid] ?? "package"}`}
size="small"
variant="outlined"
- onClick={(e) => {
- e.stopPropagation();
- navigate(`/resources/packages/${pid}`);
- }}
+ onClick={
+ readablePackageIds.has(pid)
+ ? (e) => {
+ e.stopPropagation();
+ navigate(`/resources/packages/${pid}`);
+ }
+ : undefined
+ }
/>
))}
</Stack>
@@ -109,11 +132,13 @@ function RoomReferences({
roomId,
canWrite,
attachedPackageIds,
+ readablePackageIds,
packageDescriptions,
}: {
roomId: string;
canWrite: boolean;
attachedPackageIds: Set<string>;
+ readablePackageIds: Set<string>;
packageDescriptions: Record<string, string>;
}) {
const {
@@ -217,6 +242,7 @@ function RoomReferences({
<PackageChips
packageIds={ref.packages ?? []}
attachedPackageIds={attachedPackageIds}
+ readablePackageIds={readablePackageIds}
packageDescriptions={packageDescriptions}
/>
{canWrite && (
@@ -263,11 +289,13 @@ function RoomDocuments({
roomId,
canWrite,
attachedPackageIds,
+ readablePackageIds,
packageDescriptions,
}: {
roomId: string;
canWrite: boolean;
attachedPackageIds: Set<string>;
+ readablePackageIds: Set<string>;
packageDescriptions: Record<string, string>;
}) {
const {
@@ -365,6 +393,7 @@ function RoomDocuments({
<PackageChips
packageIds={doc.packages ?? []}
attachedPackageIds={attachedPackageIds}
+ readablePackageIds={readablePackageIds}
packageDescriptions={packageDescriptions}
/>
{canWrite && (
@@ -465,11 +494,13 @@ function RoomPackages({
roomId,
canWrite,
packages,
+ readablePackageIds,
refetch,
}: {
roomId: string;
canWrite: boolean;
packages: Array<{ id: string; name: string; description: string }>;
+ readablePackageIds: Set<string>;
refetch: () => void;
}) {
const navigate = useNavigate();
@@ -542,10 +573,17 @@ function RoomPackages({
px: 1,
py: 0.5,
borderRadius: 1,
- cursor: "pointer",
- "&:hover": { backgroundColor: "action.hover" },
+ ...(readablePackageIds.has(p.id) && {
+ cursor: "pointer",
+ "&:hover": { backgroundColor: "action.hover" },
+ }),
}}
- onClick={() => navigate(`/resources/packages/${p.id}`)}
+ onClick={
+ readablePackageIds.has(p.id)
+ ? () => navigate(`/resources/packages/${p.id}`)
+ : undefined
+ }
+ data-testid={`room-package-${p.id}`}
>
<Typography variant="body2" sx={{ flexGrow: 1 }}>
{p.name || p.description}
diff --git a/gateway/src/pages/rooms/roomAccess.ts b/gateway/src/pages/rooms/roomAccess.ts
index d06875e99..79734e016 100644
--- a/gateway/src/pages/rooms/roomAccess.ts
+++ b/gateway/src/pages/rooms/roomAccess.ts
@@ -15,3 +15,19 @@ export function canWriteRoom(
room.write_visibility === "public"
);
}
+
+/** Whether a user may open an owned resource (a room, a package), as the
+ * server decides it (`can(..., "read", ...)`): its owner, a tenant admin, or
+ * anyone when it is publicly readable. */
+export function canReadResource(
+ resource: Pick<VisibilityPair, "read_visibility"> & { owner_id: string | null },
+ userId: string | null | undefined,
+ canAdminTenant: boolean,
+): boolean {
+ if (!userId) return false;
+ return (
+ canAdminTenant ||
+ (resource.owner_id !== null && resource.owner_id === userId) ||
+ resource.read_visibility === "public"
+ );
+}
diff --git a/gateway/src/pages/rooms/roomWriteControls.test.tsx b/gateway/src/pages/rooms/roomWriteControls.test.tsx
index e190bc556..b626e61ff 100644
--- a/gateway/src/pages/rooms/roomWriteControls.test.tsx
+++ b/gateway/src/pages/rooms/roomWriteControls.test.tsx
@@ -1,11 +1,21 @@
-import { cleanup, render, screen } from "@testing-library/react";
-import { MemoryRouter } from "react-router";
-import { afterEach, describe, expect, it, vi } from "vitest";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { useAuth } from "../../data/AuthContext";
import RoomLinkedRoomsSection from "./RoomLinkedRoomsSection";
import RoomResourcesSection from "./RoomResourcesSection";
// The room's linked rooms and resources change only for someone with write
-// access to the room, so their controls show only to them.
+// access to the room, so their controls show only to them. A linked room or
+// package opens only for someone who may read it.
+
+const navigate = vi.fn();
+vi.mock("react-router", () => ({
+ useNavigate: () => navigate,
+}));
+
+vi.mock("../../data/AuthContext", () => ({
+ useAuth: vi.fn(),
+}));
const result = <T,>(data: T) => ({
data,
@@ -22,6 +32,14 @@ vi.mock("../../data/hooks", () => ({
target_room_name: "other",
target_room_description: "",
label: "see also",
+ can_read: true,
+ },
+ {
+ target_room_id: "r3",
+ target_room_name: "hidden",
+ target_room_description: "",
+ label: "private",
+ can_read: false,
},
]),
useRooms: () => result([]),
@@ -42,18 +60,51 @@ vi.mock("../../data/hooks", () => ({
{ id: "doc1", name: "notes", description: "", scope: "global", packages: [] },
]),
useDocuments: () => result([]),
- useRoomPackages: () => result([{ id: "pkg1", name: "kit", description: "" }]),
+ useRoomPackages: () =>
+ result([
+ {
+ id: "pkg1",
+ name: "kit",
+ description: "",
+ owner_id: "someone",
+ read_visibility: "public",
+ },
+ {
+ id: "pkg2",
+ name: "secret-kit",
+ description: "",
+ owner_id: "someone",
+ read_visibility: "private",
+ },
+ {
+ id: "pkg3",
+ name: "my-kit",
+ description: "",
+ owner_id: "u1",
+ read_visibility: "private",
+ },
+ ]),
usePackages: () => result([]),
}));
-afterEach(cleanup);
+beforeEach(() => {
+ vi.mocked(useAuth).mockReturnValue({
+ user: { id: "u1" },
+ canAdminTenant: false,
+ } as unknown as ReturnType<typeof useAuth>);
+});
+
+afterEach(() => {
+ cleanup();
+ navigate.mockReset();
+});
function renderSections(canWrite: boolean) {
render(
- <MemoryRouter>
+ <>
<RoomResourcesSection roomId="r1" canWrite={canWrite} />
<RoomLinkedRoomsSection roomId="r1" canWrite={canWrite} />
- </MemoryRouter>,
+ </>,
);
}
@@ -82,6 +133,38 @@ describe("room resources and linked rooms", () => {
for (const name of ADD_BUTTONS) {
expect(screen.getByRole("button", { name })).toBeTruthy();
}
- expect(screen.getAllByTestId("DeleteOutlineIcon")).toHaveLength(4);
+ // A reference, a document, three packages and two linked rooms.
+ expect(screen.getAllByTestId("DeleteOutlineIcon")).toHaveLength(7);
+ });
+});
+
+describe("linked rooms and attached packages", () => {
+ it("open only when the viewer may read them", () => {
+ renderSections(false);
+
+ fireEvent.click(screen.getByTestId("linked-room-r2"));
+ expect(navigate).toHaveBeenLastCalledWith("/rooms/r2");
+ fireEvent.click(screen.getByTestId("room-package-pkg1"));
+ expect(navigate).toHaveBeenLastCalledWith("/resources/packages/pkg1");
+ fireEvent.click(screen.getByTestId("room-package-pkg3"));
+ expect(navigate).toHaveBeenLastCalledWith("/resources/packages/pkg3");
+ navigate.mockReset();
+
+ fireEvent.click(screen.getByTestId("linked-room-r3"));
+ fireEvent.click(screen.getByTestId("room-package-pkg2"));
+ expect(navigate).not.toHaveBeenCalled();
+ expect(screen.getByText("hidden")).toBeTruthy();
+ expect(screen.getByText("secret-kit")).toBeTruthy();
+ });
+
+ it("all open for an admin", () => {
+ vi.mocked(useAuth).mockReturnValue({
+ user: { id: "u2" },
+ canAdminTenant: true,
+ } as unknown as ReturnType<typeof useAuth>);
+ renderSections(false);
+
+ fireEvent.click(screen.getByTestId("room-package-pkg2"));
+ expect(navigate).toHaveBeenLastCalledWith("/resources/packages/pkg2");
});
});