Skip to content

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

Merge remote-tracking branch 'origin/main' into gateway-permission-gates

Abel Dantas86bf0d1994a9
diff --cc core/switch_core/gateway/agents.py
index e357f099c,555b17ad3..10a46f2bd
--- a/core/switch_core/gateway/agents.py
+++ b/core/switch_core/gateway/agents.py
@@@ -746,9 -730,10 +750,10 @@@ async def update_addressing_policy
user.name,
)
- return await assemble_agent_detail(
+ detail = 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,9 -783,10 +804,10 @@@ async def update_can_manage_agents
user.name,
)
- return await assemble_agent_detail(
+ detail = 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,
@@@ -829,9 -813,10 +835,10 @@@ async def get_agent_detail
if agent is None:
raise HTTPException(status_code=404, detail=f"Agent not found: {agent_id}")
- return await assemble_agent_detail(
+ detail = 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 --cc core/switch_core/gateway/packages.py
index d74ac6792,16a719c87..31fe374c5
--- a/core/switch_core/gateway/packages.py
+++ b/core/switch_core/gateway/packages.py
@@@ -414,10 -441,9 +441,10 @@@ 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, Principal(user.id, is_admin)
- )
+ principal = Principal(user.id, is_admin)
+ readable = {p.id for p in pkgs if can(principal, "read", p)}
- details = await _enrich(session, pkgs, resource_service, user_store)
++ details = await _enrich(session, pkgs, resource_service, user_store, principal)
+ return [d.model_copy(update={"can_read": d.id in readable}) for d in details]
@router.post("/rooms/{room_id}/packages/{package_id}", status_code=201)
diff --cc core/switch_core/gateway/rooms.py
index cc66970c7,af870ec6c..d58096b47
--- a/core/switch_core/gateway/rooms.py
+++ b/core/switch_core/gateway/rooms.py
@@@ -222,7 -197,7 +197,8 @@@ 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)
+ owner = await session.get(User, room.owner_id) if room.owner_id else None
+ 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)
diff --cc core/switch_core/gateway/schemas.py
index f19eb68ef,7b09f6847..6be06c306
--- a/core/switch_core/gateway/schemas.py
+++ b/core/switch_core/gateway/schemas.py
@@@ -1664,12 -1723,11 +1728,16 @@@ 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
+ # Whether the caller may open the package. Every route returns only
+ # packages the caller may read, except a room's package list: a private
+ # package its owner attached is listed to every reader of the room, and the
+ # Gateway shows that one without a link.
+ can_read: bool = True
class PackageCreateRequest(BaseModel):
diff --cc core/tests/switch_core/gateway/test_room_detail_access.py
index f54084884,000000000..3d7385cff
mode 100644,000000..100644
--- a/core/tests/switch_core/gateway/test_room_detail_access.py
+++ b/core/tests/switch_core/gateway/test_room_detail_access.py
@@@ -1,179 -1,0 +1,102 @@@
+"""What the room detail tells the Gateway about the caller's access.
+
+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, and a room's linked rooms say whether the caller may open each one.
+"""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+from typing import Any
+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(
+ get_agent_statuses_by_ids_in_session=AsyncMock(return_value={}),
+ room_role_store=RoomRoleStore(),
+ connections=SimpleNamespace(live_connection_ids=lambda: set()),
+ agent_store=AgentStore(),
+ )
+
+
+async def _add_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 _add_room(
+ session: AsyncSession,
+ *,
+ name: str,
+ owner_id: str | None,
+ read_visibility: str = "private",
+ write_visibility: str = "private",
+) -> Room:
+ room = Room(
+ transport_room_id=f"!{name}:test",
+ name=name,
+ description=f"{name} desc",
+ owner_id=owner_id,
+ read_visibility=read_visibility,
+ write_visibility=write_visibility,
+ )
+ session.add(room)
+ await session.flush()
+ return room
+
+
+class TestRoomDetailOwner:
+ async def test_detail_names_the_owner(
+ self, session_factory: async_sessionmaker[AsyncSession]
+ ) -> None:
+ async with session_factory() as session:
+ owner = await _add_user(session, name="owner")
+ room = await _add_room(session, name="r1", owner_id=owner.id)
+
+ detail = await get_room(
+ room.id,
+ session,
+ _ROOM_STORE,
+ None, # type: ignore[arg-type] # bridge_store: the room has no bridge
+ None, # type: ignore[arg-type] # external_user_store
+ _protocol(),
+ owner,
+ await _USER_STORE.administers(session, owner),
+ )
+
+ 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 --cc gateway/src/data/api.ts
index a70c0ffe7,c6ceb14c6..7c9f29400
--- a/gateway/src/data/api.ts
+++ b/gateway/src/data/api.ts
@@@ -1915,10 -1990,10 +1993,13 @@@ 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;
+ // Whether the caller may open the package. Only a room's package list
+ // includes packages the caller cannot read.
+ can_read: boolean;
}
export interface PackageCreateInput {
diff --cc gateway/src/pages/rooms/RoomResourcesSection.test.tsx
index 000000000,d0039f947..a7228aee5
mode 000000,100644..100644
--- a/gateway/src/pages/rooms/RoomResourcesSection.test.tsx
+++ b/gateway/src/pages/rooms/RoomResourcesSection.test.tsx
@@@ -1,0 -1,132 +1,152 @@@
+ 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";
+
++const navigate = vi.hoisted(() => vi.fn());
+ vi.mock("react-router", () => ({
- useNavigate: () => vi.fn(),
++ useNavigate: () => navigate,
+ }));
+
+ 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("opens an attached package only for a viewer who may read it", () => {
++ // A private package its owner attached is listed to every reader of the
++ // room, but the server says only some of them may open it.
++ vi.mocked(hooks.useRoomPackages).mockReturnValue(
++ returns([
++ { id: "p1", name: "Starter kit", description: "", can_read: true },
++ { id: "p2", name: "Secret kit", description: "", can_read: false },
++ ]) as never,
++ );
++ render(<RoomResourcesSection roomId="r1" canWrite={false} canUnlink={false} />);
++
++ fireEvent.click(screen.getByTestId("room-package-p1"));
++ expect(navigate).toHaveBeenLastCalledWith("/resources/packages/p1");
++ navigate.mockClear();
++ fireEvent.click(screen.getByTestId("room-package-p2"));
++ expect(navigate).not.toHaveBeenCalled();
++ screen.getByText("Secret kit");
++ });
++
+ 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 --cc gateway/src/pages/rooms/RoomResourcesSection.tsx
index 8aaee225e,b12b5a1bc..b313ce226
--- a/gateway/src/pages/rooms/RoomResourcesSection.tsx
+++ b/gateway/src/pages/rooms/RoomResourcesSection.tsx
@@@ -47,13 -49,6 +49,12 @@@ export default function RoomResourcesSe
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 the server says may read it get a link to it.
+ const readablePackageIds = useMemo(
- () =>
- new Set((roomPackages ?? []).filter((p) => p.can_read).map((p) => p.id)),
++ () => new Set((roomPackages ?? []).filter((p) => p.can_read).map((p) => p.id)),
+ [roomPackages],
+ );
return (
<Stack spacing={3}>
@@@ -63,8 -58,8 +64,9 @@@
<RoomReferences
roomId={roomId}
canWrite={canWrite}
+ canUnlink={canUnlink}
attachedPackageIds={attachedPackageIds}
+ readablePackageIds={readablePackageIds}
packageDescriptions={packageDescriptions}
/>
<RoomDocuments
@@@ -124,14 -112,14 +126,16 @@@ function PackageChips(
function RoomReferences({
roomId,
canWrite,
+ canUnlink,
attachedPackageIds,
+ readablePackageIds,
packageDescriptions,
}: {
roomId: string;
canWrite: boolean;
+ canUnlink: boolean;
attachedPackageIds: Set<string>;
+ readablePackageIds: Set<string>;
packageDescriptions: Record<string, string>;
}) {
const {
@@@ -235,11 -201,10 +217,11 @@@
<PackageChips
packageIds={ref.packages ?? []}
attachedPackageIds={attachedPackageIds}
+ readablePackageIds={readablePackageIds}
packageDescriptions={packageDescriptions}
/>
- {canWrite && (
- <IconButton
+ {canUnlink && (
+ <Button
size="small"
onClick={() => handleDetach(ref.id)}
disabled={busy}
@@@ -386,11 -322,10 +341,11 @@@ function RoomDocuments(
<PackageChips
packageIds={doc.packages ?? []}
attachedPackageIds={attachedPackageIds}
+ readablePackageIds={readablePackageIds}
packageDescriptions={packageDescriptions}
/>
- {canWrite && (
- <IconButton
+ {doc.can_remove && (
+ <Button
size="small"
onClick={() => handleDetach(doc.id)}
disabled={busy}
@@@ -492,8 -420,8 +440,8 @@@ function RoomPackages(
}: {
roomId: string;
canWrite: boolean;
- packages: Array<{ id: string; name: string; description: string }>;
- readablePackageIds: Set<string>;
+ canUnlink: boolean;
- packages: Array<{ id: string; name: string; description: string }>;
++ packages: Array<{ id: string; name: string; description: string; can_read?: boolean }>;
refetch: () => void;
}) {
const navigate = useNavigate();
@@@ -566,17 -479,10 +499,13 @@@
px: 1,
py: 0.5,
borderRadius: 1,
- ...(readablePackageIds.has(p.id) && {
- cursor: "pointer",
- "&:hover": { backgroundColor: "action.hover" },
++ ...(p.can_read && {
+ cursor: "pointer",
+ "&:hover": { backgroundColor: "action.hover" },
+ }),
}}
- onClick={
- readablePackageIds.has(p.id)
- ? () => navigate(`/resources/packages/${p.id}`)
- : undefined
- }
- onClick={() => navigate(`/resources/packages/${p.id}`)}
++ onClick={p.can_read ? () => navigate(`/resources/packages/${p.id}`) : undefined}
+ data-testid={`room-package-${p.id}`}
>
<Typography variant="body2" sx={{ flexGrow: 1 }}>
{p.name || p.description}
diff --cc gateway/src/pages/rooms/RoomsPage.test.tsx
index 18371bb2d,fd4a69e12..c8f12f008
--- a/gateway/src/pages/rooms/RoomsPage.test.tsx
+++ b/gateway/src/pages/rooms/RoomsPage.test.tsx
@@@ -1,15 -1,10 +1,15 @@@
-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 { cleanup, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
- import type { GridColDef, GridRowId, GridRowParams } from "@mui/x-data-grid";
++import type { GridColDef, GridRowId } from "@mui/x-data-grid";
+import { useState } from "react";
+import { afterEach, describe, expect, it, vi } from "vitest";
import type { RoomSummary } from "../../data/api";
-import * as hooks from "../../data/hooks";
+import * as api from "../../data/api";
import RoomsPage from "./RoomsPage";
+// Archiving a room is a write. The page offers it only on rooms the server says
+// the caller may write to, and says when the server changed fewer rooms than
+// were asked for.
+
vi.mock("react-router", () => ({
useNavigate: () => vi.fn(),
}));
@@@ -71,27 -25,17 +71,27 @@@ vi.mock("../../components/DataTable", (
}: {
rows: RoomSummary[];
columns: GridColDef<RoomSummary>[];
- isRowSelectable?: (p: GridRowParams<RoomSummary>) => boolean;
+ isRowSelectable?: (row: RoomSummary) => boolean;
- }) => {
+ onRowSelectionModelChange?: (ids: GridRowId[]) => void;
+ }) {
+ const [picked, setPicked] = useState<GridRowId[]>([]);
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)}
- >
+ <div key={row.id} data-testid={`row-${row.name}`}>
+ {row.name}
- {(isRowSelectable?.({ row } as GridRowParams<RoomSummary>) ?? true) && (
++ {(isRowSelectable?.(row) ?? true) && (
+ <input
+ type="checkbox"
+ aria-label={`select ${row.name}`}
+ onChange={() => {
+ const next = [...picked, row.id];
+ setPicked(next);
+ onRowSelectionModelChange?.(next);
+ }}
+ />
+ )}
{actions?.renderCell?.({ row } as never)}
</div>
))}
diff --cc gateway/src/pages/rooms/RoomsPage.tsx
index ce3abd121,a2bebafab..c3c7b3ba5
--- a/gateway/src/pages/rooms/RoomsPage.tsx
+++ b/gateway/src/pages/rooms/RoomsPage.tsx
@@@ -76,26 -72,12 +76,22 @@@ export default function RoomsPage()
],
);
- // Archiving is a write, as the server reports it for each room. Other rooms
- // get no archive action and can't be selected.
- const canWrite = useCallback((room: RoomSummary) => room.can_write, []);
-
const handleToggleArchive = useCallback(
async (roomId: string, archived: boolean) => {
- if (archived) {
- await unarchiveRoom(roomId);
- } else {
- await archiveRoom(roomId);
+ setNotice(null);
+ try {
+ if (archived) {
+ await unarchiveRoom(roomId);
+ } else {
+ await archiveRoom(roomId);
+ }
+ } catch (err) {
+ setNotice({
+ severity: "error",
+ text: `Couldn't ${archived ? "unarchive" : "archive"} the room: ${
+ err instanceof Error ? err.message : "unknown error"
+ }`,
+ });
}
refetch();
},