Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

feat: manage bot memberships through owner-delegated auth (#1099)

Gustavo Ye486c4285f1c0
diff --git a/scripts/ci/e2e-shards.mjs b/scripts/ci/e2e-shards.mjs
index a036c9767..fe7927f1b 100644
--- a/scripts/ci/e2e-shards.mjs
+++ b/scripts/ci/e2e-shards.mjs
@@ -89,6 +89,7 @@ export const SPEC_SECONDS = {
"66-grouped-message-toolbar.spec.ts": DEFAULT_SPEC_SECONDS,
"66-public-static-resource-cache.spec.ts": DEFAULT_SPEC_SECONDS,
"67-text-sidebar-threads.spec.ts": DEFAULT_SPEC_SECONDS,
+ "68-bot-memberships.spec.ts": DEFAULT_SPEC_SECONDS,
}
function walk(directory) {
diff --git a/scripts/ci/e2e-shards.test.ts b/scripts/ci/e2e-shards.test.ts
index a8dfe5693..23cd81ec6 100644
--- a/scripts/ci/e2e-shards.test.ts
+++ b/scripts/ci/e2e-shards.test.ts
@@ -75,7 +75,7 @@ describe("planE2eShards", () => {
expect(first).toEqual(second)
expect(Object.keys(SPEC_SECONDS).sort()).toEqual(specs)
- expect(first).toHaveLength(19)
+ expect(first).toHaveLength(20)
expect([...assigned].sort()).toEqual(specs)
expect(new Set(assigned).size).toBe(specs.length)
expect(SPEC_SECONDS["18-new-divider-scroll.spec.ts"]).toBe(DEFAULT_SPEC_SECONDS)
@@ -83,6 +83,7 @@ describe("planE2eShards", () => {
expect(SPEC_SECONDS["66-public-static-resource-cache.spec.ts"]).toBe(DEFAULT_SPEC_SECONDS)
expect(SPEC_SECONDS["66-grouped-message-toolbar.spec.ts"]).toBe(DEFAULT_SPEC_SECONDS)
expect(SPEC_SECONDS["67-text-sidebar-threads.spec.ts"]).toBe(DEFAULT_SPEC_SECONDS)
+ expect(SPEC_SECONDS["68-bot-memberships.spec.ts"]).toBe(DEFAULT_SPEC_SECONDS)
expect(SPEC_SECONDS["64-mobile-parent-return.spec.ts"]).toBe(DEFAULT_SPEC_SECONDS)
expect(first.find((shard) => shard.files.includes("64-mobile-parent-return.spec.ts"))?.files)
.toEqual(["64-mobile-parent-return.spec.ts"])
@@ -93,11 +94,11 @@ describe("planE2eShards", () => {
expect(first.find((shard) => shard.files.includes("67-text-sidebar-threads.spec.ts"))?.files)
.toEqual(["67-text-sidebar-threads.spec.ts"])
expect(specSeconds).toEqual([
- 165, 165, 165, 165, 165, 165, 165, 165, 165, 155.638, 154.234, 155.283,
+ 165, 165, 165, 165, 165, 165, 165, 165, 165, 165, 155.638, 154.234, 155.283,
156.095, 155.905, 156.323, 155.711, 153.963, 154.488, 156.138,
])
expect(predictedSeconds).toEqual([
- 240, 240, 240, 240, 240, 240, 240, 240, 240, 230.638, 229.234, 230.283,
+ 240, 240, 240, 240, 240, 240, 240, 240, 240, 240, 230.638, 229.234, 230.283,
231.095, 230.905, 231.323, 230.711, 228.963, 229.488, 231.138,
])
expect(first.every((shard) => (
diff --git a/src/shared/src/community-contract.ts b/src/shared/src/community-contract.ts
index 6d821e436..f8fb8670e 100644
--- a/src/shared/src/community-contract.ts
+++ b/src/shared/src/community-contract.ts
@@ -1,3 +1,4 @@
+export const COMMUNITY_BOT_ACTOR_HEADER = "X-Alook-Bot-Id"
export const COMMUNITY_CONTRACT_HEADER = "X-Alook-Community-Contract"
export const COMMUNITY_CONTRACT_VERSION = 2 as const
export const COMMUNITY_RESOURCE_CONTRACT_VERSION = 3 as const
diff --git a/src/shared/src/index.ts b/src/shared/src/index.ts
index c5c046aa7..c5667a3f0 100644
--- a/src/shared/src/index.ts
+++ b/src/shared/src/index.ts
@@ -831,7 +831,7 @@ export { parseReleaseVersion, releaseVersionGte, semverGte } from "./semver";
export type { ReleaseVersion } from "./semver";
export { resolveMode, cliCommand, cliPackageName, updateCommand, daemonCommand, getBaseUrl, isTauri, isDesktop, isMobile, tauriInvoke } from "./mode";
export type { AlookMode, ModeSignals, BaseUrlSignals } from "./mode";
-export { COMMUNITY_CONTRACT_HEADER, COMMUNITY_CONTRACT_VERSION, COMMUNITY_RESOURCE_CONTRACT_VERSION, requestedCommunityContract, requestsCommunityContract, type CommunityContract } from "./community-contract";
+export { COMMUNITY_BOT_ACTOR_HEADER, COMMUNITY_CONTRACT_HEADER, COMMUNITY_CONTRACT_VERSION, COMMUNITY_RESOURCE_CONTRACT_VERSION, requestedCommunityContract, requestsCommunityContract, type CommunityContract } from "./community-contract";
export * from "./community-resources";
export * from "./runtime-models-contract";
diff --git a/src/web/src/app/api/community/channels/[id]/members/[userId]/route.ts b/src/web/src/app/api/community/channels/[id]/members/[userId]/route.ts
index 3b4802510..fe062db28 100644
--- a/src/web/src/app/api/community/channels/[id]/members/[userId]/route.ts
+++ b/src/web/src/app/api/community/channels/[id]/members/[userId]/route.ts
@@ -92,4 +92,4 @@ export const DELETE = withCommunityActor(async (req: NextRequest, ctx) => {
return new Response(null, { status: 204 })
-})
+}, { allowInactiveBot: true })
diff --git a/src/web/src/app/api/community/servers/[id]/leave/route.ts b/src/web/src/app/api/community/servers/[id]/leave/route.ts
index 4cca04b71..b6bf39fcc 100644
--- a/src/web/src/app/api/community/servers/[id]/leave/route.ts
+++ b/src/web/src/app/api/community/servers/[id]/leave/route.ts
@@ -77,4 +77,4 @@ export const POST = withCommunityActor(async (req, ctx) => {
])
return new Response(null, { status: 204 })
-})
+}, { allowInactiveBot: true })
diff --git a/src/web/src/app/api/community/servers/channels/route.bot.test.ts b/src/web/src/app/api/community/servers/channels/route.bot.test.ts
index b744bbcef..a642623af 100644
--- a/src/web/src/app/api/community/servers/channels/route.bot.test.ts
+++ b/src/web/src/app/api/community/servers/channels/route.bot.test.ts
@@ -79,7 +79,7 @@ describe("GET /api/community/servers/channels — bot arm (folds listChannels al
)
const res = await GET(req({ Authorization: "Bearer crk_abc" }))
expect(res.status).toBe(200)
- expect(await res.json()).toEqual({
+ expect(await res.json()).toMatchObject({
groups: [
{
category: null,
@@ -94,11 +94,18 @@ describe("GET /api/community/servers/channels — bot arm (folds listChannels al
expect(mockListUserServers).toHaveBeenCalledTimes(1)
})
+ it("includes server metadata even with no visible channels and blocks owner exit", async () => {
+ mockListUserServers.mockResolvedValue([{ id: "srv_1", name: "studio", discriminator: "0042", role: "owner", icon: null }])
+ mockListChannelsForMember.mockResolvedValue([])
+ const res = await GET(req({ Authorization: "Bearer crk_abc" }))
+ expect(await res.json()).toEqual({ groups: [], servers: [{ id: "srv_1", name: "studio", handle: "studio#0042", icon: null, canLeave: false }] })
+ })
+
it("bot in zero servers → { groups: [] }", async () => {
mockListUserServers.mockResolvedValue([])
const res = await GET(req({ Authorization: "Bearer crk_abc" }))
expect(res.status).toBe(200)
- expect(await res.json()).toEqual({ groups: [] })
+ expect(await res.json()).toEqual({ groups: [], servers: [] })
expect(mockListChannelsForMember).not.toHaveBeenCalled()
})
})
diff --git a/src/web/src/app/api/community/servers/channels/route.ts b/src/web/src/app/api/community/servers/channels/route.ts
index bff2c6072..fe8bd456b 100644
--- a/src/web/src/app/api/community/servers/channels/route.ts
+++ b/src/web/src/app/api/community/servers/channels/route.ts
@@ -1,8 +1,9 @@
import { NextResponse, type NextRequest } from "next/server"
-import { queries } from "@alook/shared"
+import { queries, formatHandle, isServerOwner } from "@alook/shared"
import type { CommunityCliChannelGroup as ChannelGroup } from "@alook/shared"
import { getDb } from "@/lib/db"
import { withCommunityActor } from "@/lib/middleware/community-actor"
+import { serverIconUrl } from "@/lib/community/storage"
import { buildServerChannelGroups } from "@/lib/community/list-channels"
/**
@@ -37,5 +38,5 @@ export const GET = withCommunityActor(async (_req: NextRequest, ctx) => {
)
const groups: ChannelGroup[] = perServer.flat()
- return NextResponse.json({ groups })
-})
+ return NextResponse.json({ groups, servers: servers.map((server) => ({ id: server.id, name: server.name, handle: formatHandle(server.name, server.discriminator), icon: serverIconUrl(server), canLeave: !isServerOwner(server.role) })) })
+}, { allowInactiveBot: true })
diff --git a/src/web/src/components/community/bots/bot-list-controller.dom.test.ts b/src/web/src/components/community/bots/bot-list-controller.dom.test.ts
index f1fc0b8d5..2eeb562fb 100644
--- a/src/web/src/components/community/bots/bot-list-controller.dom.test.ts
+++ b/src/web/src/components/community/bots/bot-list-controller.dom.test.ts
@@ -314,6 +314,32 @@ describe("useBotListController", () => {
}
})
+ it("opens fresh membership views and resolves the selected bot from current data", () => {
+ mocks.target = null
+ const first = bot("b1", "mac1")
+ const second = bot("b2", "mac2")
+ mocks.bots = [first, second]
+ const renderer = render()
+ expect(latest.membershipsOpen).toBe(false)
+ expect(latest.membershipBot).toBeNull()
+ const generation = latest.membershipsGeneration
+ act(() => latest.openMemberships(first))
+ expect(latest.membershipsOpen).toBe(true)
+ expect(latest.membershipBot?.id).toBe(first.id)
+ expect(latest.membershipsGeneration).toBe(generation + 1)
+ act(() => latest.setMembershipsOpen(false))
+ expect(latest.membershipsOpen).toBe(false)
+ act(() => latest.openMemberships(second))
+ expect(latest.membershipBot?.id).toBe(second.id)
+ expect(latest.membershipsGeneration).toBe(generation + 2)
+ mocks.bots = [first, { ...second, name: "Renamed bot" }]
+ act(() => renderer.rerender(React.createElement(Probe)))
+ expect(latest.membershipBot?.name).toBe("Renamed bot")
+ mocks.bots = [first]
+ act(() => renderer.rerender(React.createElement(Probe)))
+ expect(latest.membershipBot).toBeNull()
+ })
+
it("retains non-URL state and both ref-backed lifecycles across loading/data rerenders", () => {
mocks.target = null
const renderer = render()
@@ -1032,7 +1058,7 @@ describe("useBotListController", () => {
select()
await act(async () => { await latest.resetConfirmedBot() })
expect(mocks.resetBot).toHaveBeenCalledWith({ id: "reset-me", assertActive: expect.any(Function) })
- expect(mocks.toastSuccess).toHaveBeenCalledWith("Session reset.")
+ expect(mocks.toastSuccess).toHaveBeenCalledWith("Restart requested.")
expect(latest.confirmReset).toBeNull()
for (const error of [
@@ -1044,7 +1070,7 @@ describe("useBotListController", () => {
mocks.resetBot.mockRejectedValueOnce(error)
select()
await act(async () => { await latest.resetConfirmedBot() })
- expect(mocks.toastApiError).toHaveBeenCalledWith(error, "Couldn't reset the bot's session")
+ expect(mocks.toastApiError).toHaveBeenCalledWith(error, "Couldn't restart the bot")
expect(mocks.toastError).not.toHaveBeenCalled()
expect(latest.confirmReset).toBeNull()
}
@@ -1054,7 +1080,7 @@ describe("useBotListController", () => {
select()
await act(async () => { await latest.resetConfirmedBot() })
expect(mocks.toastError).toHaveBeenCalledWith(
- "Bot is offline — bring it online before resetting.",
+ "Bot is offline — bring it online before restarting.",
)
expect(mocks.toastApiError).not.toHaveBeenCalled()
expect(latest.confirmReset).toBeNull()
@@ -1069,14 +1095,14 @@ describe("useBotListController", () => {
select()
await act(async () => { await latest.resetConfirmedMachine() })
expect(mocks.resetMachine).toHaveBeenCalledWith({ id: "mac1", assertActive: expect.any(Function) })
- expect(mocks.toastSuccess).toHaveBeenCalledWith("Dispatched reset to 1 agent on One.")
+ expect(mocks.toastSuccess).toHaveBeenCalledWith("Dispatched restart to 1 agent on One.")
expect(latest.confirmResetMachine).toBeNull()
vi.clearAllMocks()
mocks.resetMachine.mockResolvedValueOnce({ dispatched: 3 })
select()
await act(async () => { await latest.resetConfirmedMachine() })
- expect(mocks.toastSuccess).toHaveBeenCalledWith("Dispatched reset to 3 agents on One.")
+ expect(mocks.toastSuccess).toHaveBeenCalledWith("Dispatched restart to 3 agents on One.")
expect(latest.confirmResetMachine).toBeNull()
for (const generic of [
@@ -1089,7 +1115,7 @@ describe("useBotListController", () => {
await act(async () => { await latest.resetConfirmedMachine() })
expect(mocks.toastApiError).toHaveBeenCalledWith(
generic,
- "Couldn't reset the machine's agents",
+ "Couldn't restart the machine's agents",
)
expect(mocks.toastError).not.toHaveBeenCalled()
expect(latest.confirmResetMachine).toBeNull()
@@ -1100,7 +1126,7 @@ describe("useBotListController", () => {
select()
await act(async () => { await latest.resetConfirmedMachine() })
expect(mocks.toastError).toHaveBeenCalledWith(
- "One is offline — bring it online before resetting.",
+ "One is offline — bring it online before restarting.",
)
expect(mocks.toastApiError).not.toHaveBeenCalled()
expect(latest.confirmResetMachine).toBeNull()
diff --git a/src/web/src/components/community/bots/bot-list-controller.ts b/src/web/src/components/community/bots/bot-list-controller.ts
index 0949d6e3d..854ed1041 100644
--- a/src/web/src/components/community/bots/bot-list-controller.ts
+++ b/src/web/src/components/community/bots/bot-list-controller.ts
@@ -68,6 +68,15 @@ export function useBotListController(): BotListController {
const editingBot = bots.find((bot) => bot.id === editingBotId) ?? null
const setEditingBot = (bot: BotSummary | null) => setEditingBotId(bot?.id ?? null)
const [editOpen, setEditOpen] = useAtom(useCreateAtom(false))
+ const [membershipBotId, setMembershipBotId] = useAtom(useCreateAtom<string | null>(null))
+ const [membershipsOpen, setMembershipsOpen] = useAtom(useCreateAtom(false))
+ const [membershipsGeneration, setMembershipsGeneration] = useAtom(useCreateAtom(0))
+ const membershipBot = bots.find((bot) => bot.id === membershipBotId) ?? null
+ const openMemberships = (bot: BotSummary) => {
+ setMembershipBotId(bot.id)
+ setMembershipsGeneration((generation) => generation + 1)
+ setMembershipsOpen(true)
+ }
const [activityBotId, setActivityBotId] = useAtom(useCreateAtom<string | null>(null))
const activityBot = bots.find((bot) => bot.id === activityBotId) ?? null
const setActivityBot = useCallback((bot: BotSummary | null) => setActivityBotId(bot?.id ?? null), [setActivityBotId])
@@ -352,15 +361,15 @@ export function useBotListController(): BotListController {
try {
await resetSession.mutateAsync({ id: confirmReset.id, assertActive: assert })
assert()
- toast.success("Session reset.")
+ toast.success("Restart requested.")
} catch (e) {
try { assert() } catch { return }
const status = (e as { status?: number } | undefined)?.status
const message = (e as { message?: string } | undefined)?.message ?? ""
if (status === 409 && message.toLowerCase().includes("offline")) {
- toast.error("Bot is offline — bring it online before resetting.")
+ toast.error("Bot is offline — bring it online before restarting.")
} else {
- toastApiError(e, "Couldn't reset the bot's session")
+ toastApiError(e, "Couldn't restart the bot")
}
} finally {
try { assert(); setResetBotId((current) => current === id ? null : current) } catch {}
@@ -376,16 +385,16 @@ export function useBotListController(): BotListController {
const { dispatched } = await resetMachineAgents.mutateAsync({ id: confirmResetMachine, assertActive: assert })
assert()
toast.success(
- `Dispatched reset to ${dispatched} agent${dispatched === 1 ? "" : "s"} on ${name}.`,
+ `Dispatched restart to ${dispatched} agent${dispatched === 1 ? "" : "s"} on ${name}.`,
)
} catch (e) {
try { assert() } catch { return }
const status = (e as { status?: number } | undefined)?.status
const message = (e as { message?: string } | undefined)?.message ?? ""
if (status === 409 && message.toLowerCase().includes("offline")) {
- toast.error(`${name} is offline — bring it online before resetting.`)
+ toast.error(`${name} is offline — bring it online before restarting.`)
} else {
- toastApiError(e, "Couldn't reset the machine's agents")
+ toastApiError(e, "Couldn't restart the machine's agents")
}
} finally {
try { assert(); setConfirmResetMachine((current) => current === id ? null : current) } catch {}
@@ -416,6 +425,11 @@ export function useBotListController(): BotListController {
setEditingBot,
editOpen,
setEditOpen,
+ membershipBot,
+ membershipsOpen,
+ setMembershipsOpen,
+ membershipsGeneration,
+ openMemberships,
activityBot,
activityOpen,
activityGeneration,
diff --git a/src/web/src/components/community/bots/bot-list-machine-group.dom.test.ts b/src/web/src/components/community/bots/bot-list-machine-group.dom.test.ts
index 484c2fe3f..79a1897c6 100644
--- a/src/web/src/components/community/bots/bot-list-machine-group.dom.test.ts
+++ b/src/web/src/components/community/bots/bot-list-machine-group.dom.test.ts
@@ -17,6 +17,7 @@ vi.mock("lucide-react", () => ({
ChevronDown: "chevron-icon",
Monitor: "monitor-icon",
MoreVertical: "more-icon",
+ Network: "network-icon",
RotateCcw: "reset-icon",
}))
vi.mock("@/components/avatar", () => ({
@@ -89,6 +90,7 @@ function controller(overrides: Partial<BotListController> = {}): BotListControll
collapsedMachines: new Set(),
setCollapsedMachines: noop,
setConfirmResetMachine: noop,
+ openMemberships: noop,
openActivity: noop,
onActivityOpenChange: noop,
setEditingBot: noop,
@@ -167,7 +169,7 @@ describe("renderBotMachineGroup", () => {
expect(bringMachineOnline).toHaveBeenCalledWith("mac1")
})
- it("keeps machine presence independent from bot presence and projects Reset all", () => {
+ it("keeps machine presence independent from bot presence and projects Restart all", () => {
const setConfirmResetMachine = vi.fn()
const renderer = render(renderBotMachineGroup(
group({ machine: { id: "mac1", displayName: "My Mac", status: "online" } as BotMachineGroup["machine"] }),
@@ -177,7 +179,7 @@ describe("renderBotMachineGroup", () => {
"inline-block size-1.5 shrink-0 rounded-full bg-status-online"))
.toHaveLength(1)
expect(renderer.getByText("Offline")).toBeInTheDocument()
- fireEvent.click(renderer.getByRole("button", { name: "Reset all" }))
+ fireEvent.click(renderer.getByRole("button", { name: "Restart all" }))
expect(setConfirmResetMachine).toHaveBeenCalledWith("mac1")
renderer.rerender(renderBotMachineGroup(
@@ -387,6 +389,7 @@ describe("renderBotMachineGroup", () => {
})
it("keeps menu order, testids, and selected-bot action projections", () => {
+ const openMemberships = vi.fn()
const openActivity = vi.fn()
const setEditingBot = vi.fn()
const setEditOpen = vi.fn()
@@ -397,6 +400,7 @@ describe("renderBotMachineGroup", () => {
const chatWithBot = vi.fn()
const item = bot()
const renderer = render(renderBotMachineGroup(group({ bots: [item] }), controller({
+ openMemberships,
openActivity,
setEditingBot,
setEditOpen,
@@ -411,25 +415,27 @@ describe("renderBotMachineGroup", () => {
))
expect(items.map(text)).toEqual([
" Chat",
+ " Servers & channels",
" View activity",
" Edit",
- " Reset",
+ " Restart",
" Report a problem",
" Deactivate",
" Delete",
])
- expect(items[3]).toHaveAttribute("data-testid", "bot-reset-session-item")
- expect(items[4]).toHaveAttribute("data-testid", "bot-report-problem-item")
+ expect(items[4]).toHaveAttribute("data-testid", "bot-reset-session-item")
+ expect(items[5]).toHaveAttribute("data-testid", "bot-report-problem-item")
expect(items[0]!.firstElementChild).toHaveClass("size-4")
- expect(items[2]!.firstElementChild).toHaveClass("size-4")
- expect(items[4]!.firstElementChild).toHaveClass("size-4")
- expect([0, 2, 4, 5].map((index) => items[index]!.firstElementChild?.localName))
+ expect(items[3]!.firstElementChild).toHaveClass("size-4")
+ expect(items[5]!.firstElementChild).toHaveClass("size-4")
+ expect([0, 3, 5, 6].map((index) => items[index]!.firstElementChild?.localName))
.toEqual(["span", "span", "span", "span"])
- expect(items[1]!.querySelectorAll("activity-icon")).toHaveLength(1)
- expect(items[3]!.querySelectorAll("reset-icon")).toHaveLength(1)
- expect(items[6]).toHaveAttribute("data-variant", "destructive")
+ expect(items[2]!.querySelectorAll("activity-icon")).toHaveLength(1)
+ expect(items[4]!.querySelectorAll("reset-icon")).toHaveLength(1)
+ expect(items[7]).toHaveAttribute("data-variant", "destructive")
for (const item of items) fireEvent.click(item)
expect(chatWithBot).toHaveBeenCalledWith(item)
+ expect(openMemberships).toHaveBeenCalledWith(item)
expect(openActivity).toHaveBeenCalledWith(item)
expect(setEditingBot).toHaveBeenCalledWith(item)
expect(setEditOpen).toHaveBeenCalledWith(true)
diff --git a/src/web/src/components/community/bots/bot-list-machine-group.tsx b/src/web/src/components/community/bots/bot-list-machine-group.tsx
index ee4ca477f..832daa1de 100644
--- a/src/web/src/components/community/bots/bot-list-machine-group.tsx
+++ b/src/web/src/components/community/bots/bot-list-machine-group.tsx
@@ -1,4 +1,4 @@
-import { Activity, ChevronDown, Monitor, MoreVertical, RotateCcw } from "lucide-react"
+import { Network, Activity, ChevronDown, Monitor, MoreVertical, RotateCcw } from "lucide-react"
import { formatModelLabel, isPresenceOnline } from "@alook/shared"
import { AgentAvatar } from "@/components/avatar"
import { ProviderLogo } from "@/components/provider-logo"
@@ -72,7 +72,7 @@ export function renderBotMachineGroup(
onClick={() => controller.setConfirmResetMachine(machineId)}
>
<RotateCcw className="size-3.5" />
- Reset all
+ Restart all
</Button>
</div>
<div className="pl-5">
@@ -183,6 +183,9 @@ export function renderBotMachineGroup(
<DropdownMenuItem onClick={() => controller.chatWithBot(bot)}>
<span className="size-4" aria-hidden /> Chat
</DropdownMenuItem>
+ <DropdownMenuItem data-testid={tid.botMembershipsMenu(bot.id)} onClick={() => controller.openMemberships(bot)}>
+ <Network className="size-4" /> Servers &amp; channels
+ </DropdownMenuItem>
<DropdownMenuItem
onClick={() => controller.openActivity(bot)}
>
@@ -200,7 +203,7 @@ export function renderBotMachineGroup(
data-testid={`bot-reset-session-item`}
onClick={() => controller.setConfirmReset(bot)}
>
- <RotateCcw className="size-4" /> Reset
+ <RotateCcw className="size-4" /> Restart
</DropdownMenuItem>
<DropdownMenuItem
data-testid={tid.botReportProblemItem}
diff --git a/src/web/src/components/community/bots/bot-list-overlays.dom.test.ts b/src/web/src/components/community/bots/bot-list-overlays.dom.test.ts
index a9fe2e7f9..a8589eacd 100644
--- a/src/web/src/components/community/bots/bot-list-overlays.dom.test.ts
+++ b/src/web/src/components/community/bots/bot-list-overlays.dom.test.ts
@@ -21,6 +21,7 @@ vi.mock("@/components/community/onboarding-tiles/agent-help-gallery", () => ({
AgentHelpGallery: host("help"),
}))
vi.mock("@/components/community/billing/billing-sheet", () => ({ BillingSheet: host("billing") }))
+vi.mock("./bot-memberships-sheet", () => ({ BotMembershipsSheet: host("memberships") }))
vi.mock("./bot-activity-modal", () => ({ BotActivityModal: host("activity") }))
vi.mock("./bug-report-dialog", () => ({ BugReportDialog: host("bug") }))
vi.mock("./create-bot-sheet", () => ({ CreateBotSheet: host("create") }))
@@ -112,18 +113,19 @@ describe("renderBotListOverlaySlots", () => {
"create",
"help",
"edit",
+ "memberships",
"activity",
"bug",
"deleteDialog",
"resetDialog",
"resetMachineDialog",
])
- for (const slot of Object.values(slots)) {
+ for (const slot of Object.values(slots).filter((slot) => slot !== null)) {
expect(React.isValidElement(slot)).toBe(true)
expect(Array.isArray(slot)).toBe(false)
if (React.isValidElement(slot)) expect(slot.type).not.toBe(React.Fragment)
}
- expect(Object.values(slots).slice(0, 6).map((slot) =>
+ expect(Object.values(slots).filter((slot) => slot !== null).slice(0, 6).map((slot) =>
(slot!.type as React.ComponentType).displayName)).toEqual([
"Host(billing)",
"Host(create)",
@@ -256,7 +258,7 @@ describe("renderBotListOverlaySlots", () => {
expect(renders[1]!.container.querySelector("alert-description")?.textContent)
.toBe("Its running process will stop and it'll start a fresh session that picks up unfinished work from its notes.")
expect(renders[1]!.container.querySelector("alert-title")?.textContent)
- .toBe("Reset this bot's session?")
+ .toBe("Restart this bot?")
expect(renders[2]!.container.querySelector("alert-description")?.textContent)
.toBe("Every agent on this machine will start a fresh session. Any that aren't currently running will be woken too.")
})
@@ -268,7 +270,7 @@ describe("renderBotListOverlaySlots", () => {
const second = render(withMachine.resetMachineDialog)
const title = (renderer: typeof first) =>
renderer.container.querySelector("alert-title")?.textContent
- expect(title(first)).toBe("Reset all agents on this machine?")
- expect(title(second)).toBe("Reset all agents on My Mac?")
+ expect(title(first)).toBe("Restart all agents on this machine?")
+ expect(title(second)).toBe("Restart all agents on My Mac?")
})
})
diff --git a/src/web/src/components/community/bots/bot-list-overlays.tsx b/src/web/src/components/community/bots/bot-list-overlays.tsx
index 67cb9b9ac..a20fdfdb7 100644
--- a/src/web/src/components/community/bots/bot-list-overlays.tsx
+++ b/src/web/src/components/community/bots/bot-list-overlays.tsx
@@ -9,6 +9,7 @@ import {
AlertDialogTitle,
} from "@/components/ui/alert-dialog"
import { AgentHelpGallery } from "@/components/community/onboarding-tiles/agent-help-gallery"
+import { BotMembershipsSheet } from "./bot-memberships-sheet"
import { BotActivityModal } from "./bot-activity-modal"
import { BugReportDialog } from "./bug-report-dialog"
import { CreateBotSheet } from "./create-bot-sheet"
@@ -42,6 +43,7 @@ export function renderBotListOverlaySlots(
onOpenChange={controller.setEditOpen}
/>
),
+ memberships: controller.membershipBot ? <BotMembershipsSheet key={controller.membershipsGeneration} bot={controller.membershipBot} open={controller.membershipsOpen} onOpenChange={controller.setMembershipsOpen} /> : null,
activity: (
<BotActivityModal
key={controller.activityGeneration}
@@ -95,7 +97,7 @@ export function renderBotListOverlaySlots(
>
<AlertDialogContent>
<AlertDialogHeader>
- <AlertDialogTitle>Reset this bot&apos;s session?</AlertDialogTitle>
+ <AlertDialogTitle>Restart this bot?</AlertDialogTitle>
<AlertDialogDescription>
Its running process will stop and it&apos;ll start a fresh session
that picks up unfinished work from its notes.
@@ -107,7 +109,7 @@ export function renderBotListOverlaySlots(
data-testid="bot-reset-confirm"
onClick={controller.resetConfirmedBot}
>
- Reset
+ Restart
</AlertDialogAction>
</AlertDialogFooter>
</AlertDialogContent>
@@ -121,7 +123,7 @@ export function renderBotListOverlaySlots(
<AlertDialogContent>
<AlertDialogHeader>
<AlertDialogTitle>
- Reset all agents on {controller.confirmResetMachine
+ Restart all agents on {controller.confirmResetMachine
? controller.machineName(controller.confirmResetMachine)
: "this machine"}?
</AlertDialogTitle>
@@ -136,7 +138,7 @@ export function renderBotListOverlaySlots(
data-testid="machine-reset-all-confirm"
onClick={controller.resetConfirmedMachine}
>
- Reset all
+ Restart all
</AlertDialogAction>
</AlertDialogFooter>
</AlertDialogContent>
diff --git a/src/web/src/components/community/bots/bot-list-types.ts b/src/web/src/components/community/bots/bot-list-types.ts
index e80ae1206..e214af7f9 100644
--- a/src/web/src/components/community/bots/bot-list-types.ts
+++ b/src/web/src/components/community/bots/bot-list-types.ts
@@ -38,6 +38,11 @@ export type BotListController = {
setEditingBot: (bot: BotSummary | null) => void
editOpen: boolean
setEditOpen: Atom<boolean>["set"]
+ membershipBot: BotSummary | null
+ membershipsOpen: boolean
+ setMembershipsOpen: (open: boolean) => void
+ membershipsGeneration: number
+ openMemberships: (bot: BotSummary) => void
activityBot: BotSummary | null
activityOpen: boolean
activityGeneration: number
@@ -82,6 +87,7 @@ export type BotListOverlaySlots = {
create: React.ReactElement
help: React.ReactElement
edit: React.ReactElement
+ memberships: React.ReactElement | null
activity: React.ReactElement
bug: React.ReactElement | null
deleteDialog: React.ReactElement
diff --git a/src/web/src/components/community/bots/bot-list-view.tsx b/src/web/src/components/community/bots/bot-list-view.tsx
index 72c02237b..dcb134785 100644
--- a/src/web/src/components/community/bots/bot-list-view.tsx
+++ b/src/web/src/components/community/bots/bot-list-view.tsx
@@ -189,6 +189,7 @@ export function renderBotListView(
{overlays.billing}
{overlays.help}
{overlays.edit}
+ {overlays.memberships}
{overlays.activity}
{overlays.bug}
{overlays.deleteDialog}
diff --git a/src/web/src/components/community/bots/bot-memberships-sheet.dom.test.tsx b/src/web/src/components/community/bots/bot-memberships-sheet.dom.test.tsx
new file mode 100644
index 000000000..ecfd441aa
--- /dev/null
+++ b/src/web/src/components/community/bots/bot-memberships-sheet.dom.test.tsx
@@ -0,0 +1,49 @@
+import React from "react"
+import { describe, expect, it, vi } from "vitest"
+import { render } from "@/test/react-dom-harness"
+import { tid } from "@/lib/community/testids"
+
+vi.mock("@/hooks/community/use-bot-memberships", () => ({
+ useBotMemberships: () => ({
+ pending: false,
+ data: { servers: [{
+ id: "owned", name: "Owned server", handle: "Owned#1234", icon: null, canLeave: false,
+ channels: [
+ { id: "/Owned#1234/public", name: "public", type: "text", canLeave: false },
+ { id: "/Owned#1234/private", name: "private", type: "text", canLeave: true },
+ ],
+ }] },
+ }),
+}))
+vi.mock("../shell/community-sheet", () => ({
+ CommunitySheet: ({ children, description }: React.PropsWithChildren<{ description: React.ReactNode }>) => <div>{description}{children}</div>,
+}))
+vi.mock("@/components/avatar", () => ({
+ AgentAvatar: ({ name, avatarUrl, seed, size }: { name: string; avatarUrl: string; seed: string; size: number }) => <span data-avatar-name={name} data-avatar-url={avatarUrl} data-avatar-seed={seed} data-avatar-size={size} />,
+}))
+vi.mock("../server-icon", () => ({ ServerIcon: () => <span /> }))
+vi.mock("../entity-icon", () => ({ EntityIcon: () => <span /> }))
+
+import { BotMembershipsSheet } from "./bot-memberships-sheet"
+
+describe("bot membership owner restrictions", () => {
+ it("disables server and public exit while preserving private channel exit", () => {
+ const result = render(<BotMembershipsSheet bot={{ id: "bot", name: "Bot", image: "/bot.png" }} open onOpenChange={() => {}} />)
+ const avatar = result.container.querySelector("[data-avatar-seed]")
+ expect(avatar?.getAttribute("data-avatar-seed")).toBe("bot")
+ expect(avatar?.getAttribute("data-avatar-url")).toBe("/bot.png")
+ expect(avatar?.getAttribute("data-avatar-name")).toBe("Bot")
+ expect(avatar?.getAttribute("data-avatar-size")).toBe("24")
+ for (const id of ["owned", "/Owned#1234/public"]) {
+ const button = result.getByTestId(tid.botMembershipsLeave(id)) as HTMLButtonElement
+ expect(button.disabled).toBe(true)
+ expect(button.title).toBe("The server owner cannot leave")
+ expect(button.getAttribute("aria-label")).toMatch(/^Leave /)
+ expect(button.textContent).toBe("")
+ }
+ const privateExit = result.getByTestId(tid.botMembershipsLeave("/Owned#1234/private")) as HTMLButtonElement
+ expect(privateExit.disabled).toBe(false)
+ expect(result.getByTestId(tid.botMembershipsChannel("/Owned#1234/private")).querySelector('[aria-label="Private channel"]')).not.toBeNull()
+ expect(result.getByTestId(tid.botMembershipsChannel("/Owned#1234/public")).querySelector('[aria-label="Private channel"]')).toBeNull()
+ })
+})
diff --git a/src/web/src/components/community/bots/bot-memberships-sheet.tsx b/src/web/src/components/community/bots/bot-memberships-sheet.tsx
new file mode 100644
index 000000000..82a042795
--- /dev/null
+++ b/src/web/src/components/community/bots/bot-memberships-sheet.tsx
@@ -0,0 +1,68 @@
+"use client"
+
+import { useAtom, useCreateAtom } from "@tanstack/react-store"
+import { Loader2, Lock, LogOut } from "lucide-react"
+import { AgentAvatar } from "@/components/avatar"
+import { Button } from "@/components/ui/button"
+import { Skeleton } from "@/components/ui/skeleton"
+import { AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogTitle } from "@/components/ui/alert-dialog"
+import { CommunitySheet } from "../shell/community-sheet"
+import { ServerIcon } from "../server-icon"
+import { EntityIcon } from "../entity-icon"
+import { avatarInitial } from "@/lib/community/avatar"
+import { tid } from "@/lib/community/testids"
+import { useBotMemberships, type BotMembershipTarget } from "@/hooks/community/use-bot-memberships"
+
+export function BotMembershipsSheet({ bot, open, onOpenChange }: {
+ bot: { id: string; name: string; image?: string | null }
+ open: boolean
+ onOpenChange: (open: boolean) => void
+}) {
+ const memberships = useBotMemberships(bot.id, open)
+ const [target, setTarget] = useAtom(useCreateAtom<BotMembershipTarget | null>(null))
+ const [error, setError] = useAtom(useCreateAtom<string | null>(null))
+ const select = (next: BotMembershipTarget) => { setError(null); setTarget(next) }
+ const confirm = async () => {
+ if (!target || memberships.pending) return
+ const assert = memberships.capture()
+ try {
+ if (await memberships.leave(target)) { assert(); setTarget(null); setError(null) }
+ } catch (cause) {
+ try { assert() } catch { return }
+ setError(cause instanceof Error ? cause.message : "Could not leave. Try again.")
+ }
+ }
+ return <>
+ <CommunitySheet open={open} onOpenChange={(next) => { if (!next) setTarget(null); onOpenChange(next) }} title="Servers & channels" description={<span className="flex min-w-0 items-center gap-2"><AgentAvatar name={bot.name} avatarUrl={bot.image} seed={bot.id} size={24} /><span className="min-w-0 truncate" title={bot.name}>{bot.name}</span></span>} contentTestId={tid.botMembershipsSheet}>
+ {memberships.isPending ? <div className="space-y-6" aria-label="Loading servers and channels" aria-busy="true">{[0, 1, 2].map((i) => <div key={i} className="space-y-3"><Skeleton className="h-4 w-36" /><Skeleton className="ml-6 h-9 w-3/4" /><Skeleton className="ml-6 h-9 w-2/3" /></div>)}</div>
+ : memberships.isError ? <div className="space-y-3 py-6"><p role="alert" className="text-sm text-muted-foreground">Could not load servers and channels.</p><Button variant="outline" disabled={memberships.isFetching} onClick={() => void memberships.refetch()}>Try again</Button></div>
+ : memberships.data?.servers.length === 0 ? <div className="py-8"><p className="font-medium">No servers yet</p><p className="mt-1 text-sm text-muted-foreground">{bot.name} hasn&apos;t joined any servers.</p></div>
+ : <div className="space-y-6">{memberships.data?.servers.map((server) => <section key={server.id} data-testid={tid.botMembershipsServer(server.id)}>
+ <div className="flex min-h-11 items-center gap-2">
+ <ServerIcon id={server.id} name={server.name} initial={avatarInitial(server.name)} icon={server.icon} size={16} className="shrink-0 rounded-sm" />
+ <h3 className="min-w-0 flex-1 truncate text-sm font-medium" title={server.name}>{server.name}</h3>
+ <Button variant="ghost" size="icon" className="size-11 shrink-0 text-muted-foreground hover:text-destructive" disabled={memberships.pending || !server.canLeave} aria-label={`Leave ${server.name}`} title={server.canLeave ? "Leave server" : "The server owner cannot leave"} data-testid={tid.botMembershipsLeave(server.id)} onClick={() => select({ kind: "server", id: server.id, ref: server.handle, name: server.name })}><LogOut className="size-4" aria-hidden="true" /></Button>
+ </div>
+ {server.channels.length === 0 ? <p className="py-3 pl-6 text-sm text-muted-foreground">No channels available</p> : server.channels.map((channel) => <div key={channel.id} data-testid={tid.botMembershipsChannel(channel.id)} className="flex min-h-11 items-center gap-2 rounded-md">
+ <span className="flex w-4 shrink-0 justify-center">{channel.canLeave && <Lock className="size-3 translate-x-2 text-muted-foreground" aria-label="Private channel" />}</span>
+ <EntityIcon kind={channel.type} className="size-3.5 shrink-0 text-muted-foreground" />
+ <span className="min-w-0 flex-1 truncate text-sm" title={channel.name}>{channel.name}</span>
+ <Button variant="ghost" size="icon" className="size-11 shrink-0 text-muted-foreground hover:text-destructive" disabled={memberships.pending || (!channel.canLeave && !server.canLeave)} aria-label={`Leave ${channel.name}`} title={!channel.canLeave && !server.canLeave ? "The server owner cannot leave" : "Leave channel"} data-testid={tid.botMembershipsLeave(channel.id)} onClick={() => select(channel.canLeave ? { kind: "channel", id: channel.id, ref: channel.id, name: channel.name, serverName: server.name } : { kind: "server", id: server.id, ref: server.handle, name: server.name, publicChannelName: channel.name })}><LogOut className="size-4" aria-hidden="true" /></Button>
+ </div>)}
+ </section>)}</div>}
+ </CommunitySheet>
+ <AlertDialog open={open && target !== null} onOpenChange={(next) => { if (!next && !memberships.pending) setTarget(null) }}>
+ <AlertDialogContent>
+ <AlertDialogHeader>
+ <AlertDialogTitle className="wrap-break-word">Remove {bot.name} from {target?.publicChannelName ?? target?.name}{target?.publicChannelName ? ` in ${target.name}` : target?.kind === "channel" ? ` in ${target.serverName}` : ""}?</AlertDialogTitle>
+ <AlertDialogDescription>{target?.publicChannelName ? `This is a public channel. To leave it, this bot must leave ${target.name} and all its channels and threads.` : target?.kind === "server" ? "This bot will leave the server and all its channels and threads." : "This bot will leave the channel and its threads, and lose access to them."} Its past messages will remain.</AlertDialogDescription>
+ </AlertDialogHeader>
+ {error && <p role="alert" className="text-sm text-destructive">{error}</p>}
+ <AlertDialogFooter>
+ <AlertDialogCancel className="min-h-11 sm:min-h-0" disabled={memberships.pending}>Cancel</AlertDialogCancel>
+ <AlertDialogAction data-testid={tid.botMembershipsConfirm} disabled={memberships.pending} onClick={() => void confirm()} className="min-h-11 bg-destructive text-destructive-foreground hover:bg-destructive/90 sm:min-h-0">{memberships.pending && <Loader2 className="size-4 animate-spin motion-reduce:animate-none" />}{memberships.pending ? "Leaving…" : target?.kind === "server" ? "Leave server" : "Leave channel"}</AlertDialogAction>
+ </AlertDialogFooter>
+ </AlertDialogContent>
+ </AlertDialog>
+ </>
+}
diff --git a/src/web/src/components/home/landing-workspace-home.tsx b/src/web/src/components/home/landing-workspace-home.tsx
index 78edb23bc..10d59322f 100644
--- a/src/web/src/components/home/landing-workspace-home.tsx
+++ b/src/web/src/components/home/landing-workspace-home.tsx
@@ -22,7 +22,7 @@ const BOTS: BotSummary[] = ["alli", "cecilia", "claudette", "evan", "devin"].map
const profile = DEMO_PROFILES.get(`demo-${name}`)!
return { id: profile.id, name: profile.name!, description: profile.aboutMe!, image: profile.avatar!, avatarVersion: 0, machineId: MACHINE.id, runtime: index === 1 ? "claude" : "codex", modelName: null, reasoningEffort: null, runtimeConfigRevision: 1, isActive: true }
})
-const emptyOverlays = Object.fromEntries(["billing", "create", "help", "edit", "activity", "bug", "deleteDialog", "resetDialog", "resetMachineDialog"].map((key) => [key, <span key={key} />])) as BotListOverlaySlots
+const emptyOverlays = Object.fromEntries(["billing", "create", "help", "edit", "memberships", "activity", "bug", "deleteDialog", "resetDialog", "resetMachineDialog"].map((key) => [key, <span key={key} />])) as BotListOverlaySlots
export function WorkspaceHome({ page, onBack, onDm, onOpenProfile, onMachines }: {
page: "friends" | "bots" | "machines"
@@ -52,6 +52,7 @@ export function WorkspaceHome({ page, onBack, onDm, onOpenProfile, onMachines }:
setBotActive: async (bot, active) => { setBots((rows) => rows.map((row) => row.id === bot.id ? { ...row, isActive: active } : row)) },
initialError: false, retryInitialLoad: () => {}, retryingInitialLoad: false, isLoading: false, machinesLoading: false, machinesUnknown: false,
createOpen: false, setCreateOpen: () => {}, editingBot, setEditingBot: edit, editOpen: false, setEditOpen: () => setPanel("Edit bot"),
+ membershipBot: null, membershipsOpen: false, setMembershipsOpen: () => {}, membershipsGeneration: 0, openMemberships: openPanel("Servers & channels"),
activityBot: null, activityOpen: false, activityGeneration: 0, openActivity: (bot) => { edit(bot); setPanel("Activity") }, onActivityOpenChange: () => {}, onActivityOpenChangeComplete: () => {},
bugReportBot: null, setBugReportBot: () => {}, bugReportOpen: false, setBugReportOpen: () => setPanel("Report a problem"),
confirmDelete: null, setConfirmDelete: (bot) => { edit(bot); setPanel("Delete bot") }, confirmReset: null, setConfirmReset: (bot) => { edit(bot); setPanel("Reset session") },
diff --git a/src/web/src/hooks/community/use-bot-memberships.dom.test.ts b/src/web/src/hooks/community/use-bot-memberships.dom.test.ts
new file mode 100644
index 000000000..dbf90cee7
--- /dev/null
+++ b/src/web/src/hooks/community/use-bot-memberships.dom.test.ts
@@ -0,0 +1,74 @@
+import { CommunityTestProvider } from "@/test/community-owner-fixture"
+import { createElement, type PropsWithChildren } from "react"
+import { QueryClient } from "@tanstack/react-query"
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { act, renderHook, waitFor } from "@/test/react-dom-harness"
+import { useBotMemberships } from "./use-bot-memberships"
+
+const apiFetch = vi.fn()
+vi.mock("@/lib/api/client", () => ({ apiFetch: (...args: unknown[]) => apiFetch(...args) }))
+
+function setup(botId = "bot_1", open = true) {
+ const client = new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: 0 } } })
+ const wrapper = ({ children }: PropsWithChildren) => createElement(CommunityTestProvider, { client }, children)
+ return { ...renderHook((props: { botId: string; open: boolean }) => useBotMemberships(props.botId, props.open), { initialProps: { botId, open }, wrapper }), client }
+}
+
+describe("owned bot memberships", () => {
+ beforeEach(() => apiFetch.mockReset())
+
+ it("loads only the selected bot while open", async () => {
+ apiFetch.mockResolvedValue({ servers: [], groups: [] })
+ const view = setup("bot_1", false)
+ expect(apiFetch).not.toHaveBeenCalled()
+ view.rerender({ botId: "bot_1", open: true })
+ await waitFor(() => expect(view.result.current.isSuccess).toBe(true))
+ expect(apiFetch).toHaveBeenCalledWith("/api/community/servers/channels", expect.objectContaining({ authenticationAccount: "viewer", headers: { "X-Alook-Bot-Id": "bot_1" } }))
+ })
+
+ it("flattens categories into their server and keeps empty servers and public restrictions", async () => {
+ apiFetch.mockResolvedValue({ servers: [{ id: "s1", handle: "studio#0042", name: "studio", canLeave: true, icon: null }, { id: "s2", handle: "empty#0043", name: "empty", canLeave: false, icon: null }], groups: [{ category: { name: "hidden grouping", private: true }, channels: [{ ref: "/studio#0042/work", name: "work", type: "forum", visibility: "private" }] }, { category: null, channels: [{ ref: "/studio#0042/all", name: "all", type: "text", visibility: "public" }] }] })
+ const view = setup()
+ await waitFor(() => expect(view.result.current.isSuccess).toBe(true))
+ expect(view.result.current.data?.servers[0].channels).toEqual([{ id: "/studio#0042/work", name: "work", type: "forum", canLeave: true }, { id: "/studio#0042/all", name: "all", type: "text", canLeave: false }])
+ expect(view.result.current.data?.servers[1]).toMatchObject({ canLeave: false, channels: [] })
+ })
+
+ it("preserves membership data when leave fails and allows a retry", async () => {
+ apiFetch.mockImplementation((_path: string, options: RequestInit = {}) => options.method === "DELETE" ? Promise.reject(new Error("try again")) : Promise.resolve({ servers: [], groups: [] }))
+ const view = setup()
+ await waitFor(() => expect(view.result.current.isSuccess).toBe(true))
+ await act(async () => { await expect(view.result.current.leave({ kind: "channel", id: "c1", ref: "/studio#0042/work", name: "work" })).rejects.toThrow("try again") })
+ await waitFor(() => expect(view.result.current.pending).toBe(false))
+ expect(view.result.current.data).toEqual({ servers: [] })
+ })
+
+ it("blocks duplicate exits and refreshes only the selected bot after success", async () => {
+ let finish!: () => void
+ apiFetch.mockImplementation((_path: string, options: RequestInit = {}) => options.method === "DELETE" ? new Promise<void>((resolve) => { finish = resolve }) : Promise.resolve({ servers: [], groups: [] }))
+ const view = setup()
+ await waitFor(() => expect(view.result.current.isSuccess).toBe(true))
+ const target = { kind: "channel" as const, id: "channel_1", ref: "/studio#0042/work", name: "work" }
+ let first!: Promise<boolean>
+ act(() => { first = view.result.current.leave(target) })
+ await waitFor(() => expect(view.result.current.pending).toBe(true))
+ expect(await view.result.current.leave(target)).toBe(false)
+ await act(async () => { finish(); expect(await first).toBe(true) })
+ expect(apiFetch.mock.calls.filter(([, opts]) => opts?.method === "DELETE")).toHaveLength(1)
+ expect(apiFetch).toHaveBeenCalledWith("/api/community/channels/resolve/members/self?ref=%2Fstudio%230042%2Fwork", expect.objectContaining({ method: "DELETE" }))
+ })
+
+ it("keeps a late exit bound to its original bot and rejects closed-view completion", async () => {
+ let finish!: () => void
+ apiFetch.mockImplementation((_path: string, options: RequestInit = {}) => options.method === "POST" ? new Promise<void>((resolve) => { finish = resolve }) : Promise.resolve({ servers: [], groups: [] }))
+ const view = setup()
+ await waitFor(() => expect(view.result.current.isSuccess).toBe(true))
+ let outcome!: Promise<unknown>
+ act(() => { outcome = view.result.current.leave({ kind: "server", id: "server_1", ref: "studio#0042", name: "work" }).catch((error) => error) })
+ await waitFor(() => expect(view.result.current.pending).toBe(true))
+ view.rerender({ botId: "bot_2", open: true })
+ await act(async () => { finish(); expect(await outcome).toMatchObject({ name: "AbortError" }) })
+ expect(apiFetch).toHaveBeenCalledWith("/api/community/servers/resolve/leave?server=studio%230042", expect.objectContaining({ method: "POST" }))
+ await waitFor(() => expect(view.result.current.data).toEqual({ servers: [] }))
+ })
+})
diff --git a/src/web/src/hooks/community/use-bot-memberships.ts b/src/web/src/hooks/community/use-bot-memberships.ts
new file mode 100644
index 000000000..a7e62af8b
--- /dev/null
+++ b/src/web/src/hooks/community/use-bot-memberships.ts
@@ -0,0 +1,59 @@
+"use client"
+
+import { useIsMutating, useMutation, useQuery, useQueryClient } from "@tanstack/react-query"
+import { COMMUNITY_BOT_ACTOR_HEADER, parseRef, type CommunityCliChannelGroup } from "@alook/shared"
+import { communityKeys } from "@/lib/query-keys"
+import { useCommunityMutationOrigin } from "./community-origin"
+import { useCommunityViewSource } from "./use-community-view-source"
+
+type BotMembershipChannel = { id: string; name: string; type: "text" | "forum"; canLeave: boolean }
+type BotMembershipServer = { id: string; name: string; handle: string; icon: string | null; canLeave: boolean; channels: BotMembershipChannel[] }
+export type BotMembershipTarget = { kind: "channel" | "server"; id: string; ref: string; name: string; serverName?: string; publicChannelName?: string }
+type Memberships = { groups: CommunityCliChannelGroup[]; servers: Omit<BotMembershipServer, "channels">[] }
+
+export function useBotMemberships(botId: string, open: boolean) {
+ const client = useQueryClient()
+ const origin = useCommunityMutationOrigin()
+ const source = useCommunityViewSource(`bot-memberships:${botId}`, open)
+ const queryKey = communityKeys.botMemberships(botId)
+ const mutationKey = [...queryKey, "leave"]
+ const pending = useIsMutating({ mutationKey }) > 0
+ const query = useQuery({
+ queryKey,
+ enabled: open,
+ staleTime: 0,
+ gcTime: 0,
+ queryFn: async ({ signal }) => {
+ const data = await origin.fetch<Memberships>("/api/community/servers/channels", { signal, headers: { [COMMUNITY_BOT_ACTOR_HEADER]: botId } })
+ const channelsByServer = new Map<string, BotMembershipChannel[]>()
+ for (const channel of data.groups.flatMap((group) => group.channels)) {
+ const server = parseRef(channel.ref).server
+ const channels = channelsByServer.get(server) ?? []
+ channels.push({ id: channel.ref, name: channel.name, type: channel.type, canLeave: channel.visibility === "private" })
+ channelsByServer.set(server, channels)
+ }
+ return { servers: data.servers.map((server) => ({ ...server, channels: channelsByServer.get(server.handle) ?? [] })) }
+ },
+ })
+ const mutation = useMutation({
+ mutationKey,
+ meta: { observabilityAction: "community.command" },
+ mutationFn: (target: BotMembershipTarget) => {
+ const ref = encodeURIComponent(target.ref)
+ return origin.fetch<void>(target.kind === "server"
+ ? `/api/community/servers/resolve/leave?server=${ref}`
+ : `/api/community/channels/resolve/members/self?ref=${ref}`,
+ { method: target.kind === "server" ? "POST" : "DELETE", headers: { [COMMUNITY_BOT_ACTOR_HEADER]: botId } })
+ },
+ onSuccess: () => client.invalidateQueries({ queryKey }),
+ })
+ const leave = async (target: BotMembershipTarget) => {
+ if (client.isMutating({ mutationKey })) return false
+ const assert = source.capture()
+ assert()
+ await mutation.mutateAsync(target)
+ assert()
+ return true
+ }
+ return { ...query, pending, leave, capture: source.capture }
+}
diff --git a/src/web/src/lib/community/testids.ts b/src/web/src/lib/community/testids.ts
index 81542a295..9798f0ee1 100644
--- a/src/web/src/lib/community/testids.ts
+++ b/src/web/src/lib/community/testids.ts
@@ -91,6 +91,12 @@ export const tid = {
botAuditPreviewEarlier: "community-bot-audit-preview-earlier",
botAuditPreviewScroll: "community-bot-audit-preview-scroll",
botAuditPreviewBottom: "community-bot-audit-preview-bottom",
+ botMembershipsMenu: (id: string) => `bot-memberships-menu-${id}`,
+ botMembershipsSheet: "bot-memberships-sheet",
+ botMembershipsServer: (id: string) => `bot-memberships-server-${id}`,
+ botMembershipsChannel: (id: string) => `bot-memberships-channel-${id}`,
+ botMembershipsLeave: (id: string) => `bot-memberships-leave-${id}`,
+ botMembershipsConfirm: "bot-memberships-confirm",
botActivityModal: "bot-activity-modal",
botActivityDetail: "bot-activity-detail",
botAuditPreviewRow: (id: string) => `community-bot-audit-preview-row-${id}`,
diff --git a/src/web/src/lib/middleware/auth.test.ts b/src/web/src/lib/middleware/auth.test.ts
index 73779b178..2bb3d2aac 100644
--- a/src/web/src/lib/middleware/auth.test.ts
+++ b/src/web/src/lib/middleware/auth.test.ts
@@ -178,7 +178,7 @@ describe("withAuth middleware", () => {
...(vary ? { Vary: vary } : {}),
} });
const res = await withAuth(async () => original)(new NextRequest("http://localhost/media", { headers: { Cookie: "viewer=A" } }));
- expect(res.headers.get("Vary")).toBe(expected);
+ expect(res.headers.get("Vary")).toBe(expected === "*" ? expected : `${expected}, X-Alook-Bot-Id`);
expect(res.headers.get("Cache-Control")).toBe("private, max-age=31536000, immutable");
expect(res.headers.get("ETag")).toBe('"media-v1"');
expect(res.headers.get("Set-Cookie")).toContain("viewer=refreshed");
@@ -192,7 +192,7 @@ describe("withAuth middleware", () => {
status, headers: { "Cache-Control": "private, max-age=31536000, immutable", Vary: "Accept-Encoding" },
}))(new NextRequest("http://localhost/media", { headers: { Authorization: "Bearer al_test" } }));
expect(res.status).toBe(status);
- expect(res.headers.get("Vary")).toBe("Accept-Encoding, Cookie, Authorization");
+ expect(res.headers.get("Vary")).toBe("Accept-Encoding, Cookie, Authorization, X-Alook-Bot-Id");
});
it("preserves asynchronous machine handler error propagation", async () => {
@@ -837,3 +837,13 @@ describe("warmMachineTokenCache", () => {
await expect(warmMachineTokenCache(null, "al_x", row)).resolves.toBeUndefined();
});
});
+
+
+describe("human-only bot-selection rejection", () => {
+ it.each([withAuth, withCookieHumanAuth, withOptionalAuth])("rejects bot selection before a human-only handler can mutate the owner (%#)", async (wrap) => {
+ const handler = vi.fn(async () => NextResponse.json({ ok: true }))
+ const response = await wrap(handler)(new NextRequest("http://localhost/api/community/bots", { headers: { "X-Alook-Bot-Id": "bot_1" }, method: "POST" }))
+ expect(response.status).toBe(403)
+ expect(handler).not.toHaveBeenCalled()
+ })
+})
diff --git a/src/web/src/lib/middleware/auth.ts b/src/web/src/lib/middleware/auth.ts
index 25b489154..fcdc3f2a4 100644
--- a/src/web/src/lib/middleware/auth.ts
+++ b/src/web/src/lib/middleware/auth.ts
@@ -1,7 +1,7 @@
import { observeWorkerOperation } from "@/lib/observability/worker"
import { NextRequest, NextResponse } from "next/server"
import { getCloudflareContext } from "@opennextjs/cloudflare"
-import { queries } from "@alook/shared"
+import { COMMUNITY_BOT_ACTOR_HEADER, queries } from "@alook/shared"
import { getDb, getPrimaryDb } from "@/lib/db"
import { getAuth } from "@/lib/auth"
import { getKV, cacheKeys, bindCacheKV } from "@/lib/cache"
@@ -249,6 +249,9 @@ export function withCookieHumanAuth(handler: CookieHumanAuthHandler) {
req: NextRequest,
context?: { params?: Promise<Record<string, string>> | Record<string, string> },
) => {
+ if (req.headers.has(COMMUNITY_BOT_ACTOR_HEADER)) {
+ return NextResponse.json({ error: "bot selection is not supported by this endpoint" }, { status: 403 })
+ }
const resolvedParams = context?.params
? context.params instanceof Promise
? await context.params
@@ -304,16 +307,19 @@ export function withCookieHumanAuth(handler: CookieHumanAuthHandler) {
}
}
-export function withAuth(handler: AuthenticatedHandler) {
- const authenticate = createAuthenticatedHandler(handler)
+export function withAuth(handler: AuthenticatedHandler, options: { allowBotSelection?: boolean } = {}) {
+ const authenticate = createAuthenticatedHandler(handler, options)
return async (...args: Parameters<typeof authenticate>) => protectCommunityJsonResponse(args[0], rejectUnknownCommunityContract(args[0]) ?? await authenticate(...args))
}
-function createAuthenticatedHandler(handler: AuthenticatedHandler) {
+function createAuthenticatedHandler(handler: AuthenticatedHandler, options: { allowBotSelection?: boolean }) {
return async (
req: NextRequest,
context?: { params?: Promise<Record<string, string>> | Record<string, string> }
) => {
+ if (req.headers.has(COMMUNITY_BOT_ACTOR_HEADER) && !options.allowBotSelection) {
+ return NextResponse.json({ error: "bot selection is not supported by this endpoint" }, { status: 403 })
+ }
const resolvedParams = context?.params
? context.params instanceof Promise
? await context.params
@@ -459,6 +465,9 @@ export function withOptionalAuth(handler: OptionalAuthHandler) {
req: NextRequest,
context?: { params?: Promise<Record<string, string>> | Record<string, string> }
) => {
+ if (req.headers.has(COMMUNITY_BOT_ACTOR_HEADER)) {
+ return NextResponse.json({ error: "bot selection is not supported by this endpoint" }, { status: 403 })
+ }
const resolvedParams = context?.params
? context.params instanceof Promise
? await context.params
diff --git a/src/web/src/lib/middleware/community-actor.test.ts b/src/web/src/lib/middleware/community-actor.test.ts
index 6277c2888..c99c30a1e 100644
--- a/src/web/src/lib/middleware/community-actor.test.ts
+++ b/src/web/src/lib/middleware/community-actor.test.ts
@@ -14,8 +14,10 @@ vi.mock("@opennextjs/cloudflare", () => ({
}))
vi.mock("@/lib/db", () => ({ getDb: vi.fn(() => ({})) }))
+const mockResolveOwnedBotActor = vi.fn()
const mockResolveBotActor = vi.fn()
vi.mock("./community-agent-runner-auth", () => ({
+ resolveOwnedBotActor: (...a: unknown[]) => mockResolveOwnedBotActor(...a),
resolveBotActor: (...a: unknown[]) => mockResolveBotActor(...a),
}))
@@ -110,7 +112,7 @@ describe("withCommunityActor", () => {
const mediaHandler = vi.fn(async (_request: NextRequest, _ctx: { actor: CommunityActor }) => original)
const res = await withCommunityActor(mediaHandler)(bearer("Bearer crk_abc"))
expect(res.status).toBe(status)
- expect(res.headers.get("Vary")).toBe("Accept-Encoding, Cookie, Authorization")
+ expect(res.headers.get("Vary")).toBe("Accept-Encoding, Cookie, Authorization, X-Alook-Bot-Id")
expect(res.headers.get("Cache-Control")).toBe("private, max-age=31536000, immutable")
expect(res.body).toBe(original.body)
expect(mediaHandler.mock.calls[0]?.[1].actor.kind).toBe("bot")
@@ -136,3 +138,44 @@ describe("rejectBot / requireBot guards", () => {
if (botGate.ok) expect(botGate.bot).toEqual({ kind: "bot", userId: "b", ownerUserId: "o", machineId: "m", isActive: true })
})
})
+
+
+describe("owner selected bot", () => {
+ beforeEach(() => {
+ vi.clearAllMocks()
+ mockHumanCtx = { env: { DB: {} }, userId: "human_1", email: "[email protected]" }
+ mockResolveOwnedBotActor.mockResolvedValue({ kind: "bot", actor: { botUserId: "bot_1", ownerUserId: "human_1", machineId: "offline_machine", isActive: true } })
+ })
+ const request = () => new NextRequest("http://localhost/api/community/servers/channels", { headers: { "X-Alook-Bot-Id": "bot_1" } })
+ it("authenticates the owner then delegates only the selected bot identity, with a private varied response", async () => {
+ const response = await withCommunityActor(handler)(request())
+ expect(mockResolveOwnedBotActor).toHaveBeenCalledWith({}, "bot_1", "human_1", { allowInactive: undefined })
+ expect(await response.json()).toMatchObject({ actor: { kind: "bot", userId: "bot_1", ownerUserId: "human_1", machineId: "offline_machine", delegatedByUserId: "human_1" } })
+ expect(response.headers.get("Cache-Control")).toContain("no-store")
+ expect(response.headers.get("Vary")).toContain("X-Alook-Bot-Id")
+ expect(mockResolveBotActor).not.toHaveBeenCalled()
+ })
+ it("does not resolve a selected bot before human authentication", async () => {
+ mockHumanCtx = null
+ expect((await withCommunityActor(handler)(request())).status).toBe(401)
+ expect(mockResolveOwnedBotActor).not.toHaveBeenCalled()
+ expect(handler).not.toHaveBeenCalled()
+ })
+ it("preserves owned bot lookup rejection without calling the route", async () => {
+ mockResolveOwnedBotActor.mockResolvedValue({ kind: "error", response: NextResponse.json({ error: "bot not found" }, { status: 404 }) })
+ expect((await withCommunityActor(handler)(request())).status).toBe(404)
+ expect(handler).not.toHaveBeenCalled()
+ })
+ it("rejects runner-key identity selection without falling through to human authentication", async () => {
+ const req = request()
+ req.headers.set("Authorization", "Bearer crk_a")
+ expect((await withCommunityActor(handler)(req)).status).toBe(403)
+ expect(mockResolveOwnedBotActor).not.toHaveBeenCalled()
+ expect(mockResolveBotActor).not.toHaveBeenCalled()
+ expect(handler).not.toHaveBeenCalled()
+ })
+ it("passes the route's explicit inactive policy to owner delegation", async () => {
+ await withCommunityActor(handler, { allowInactiveBot: true })(request())
+ expect(mockResolveOwnedBotActor).toHaveBeenCalledWith({}, "bot_1", "human_1", { allowInactive: true })
+ })
+})
diff --git a/src/web/src/lib/middleware/community-actor.ts b/src/web/src/lib/middleware/community-actor.ts
index a0dc15f4f..5cd3db872 100644
--- a/src/web/src/lib/middleware/community-actor.ts
+++ b/src/web/src/lib/middleware/community-actor.ts
@@ -2,7 +2,8 @@ import { NextRequest, NextResponse } from "next/server"
import { getCloudflareContext } from "@opennextjs/cloudflare"
import { getDb } from "@/lib/db"
import { withAuth, type AuthContext } from "./auth"
-import { resolveBotActor } from "./community-agent-runner-auth"
+import { COMMUNITY_BOT_ACTOR_HEADER } from "@alook/shared"
+import { resolveBotActor, resolveOwnedBotActor } from "./community-agent-runner-auth"
import { protectCommunityJsonResponse, rejectUnknownCommunityContract, varyPrivateResponseByCredentials } from "./response-cache"
/**
@@ -46,6 +47,7 @@ export type CommunityActor =
machineId: string
/** Server-internal binding state resolved by runner auth. */
isActive: boolean
+ delegatedByUserId?: string
}
interface CommunityActorContext {
@@ -104,6 +106,9 @@ function createCommunityActorHandler(
// returns `not_bot` for any other header (including an `al_` machine token
// or a session cookie), which we route to the human `withAuth` path below.
if (authHeader?.startsWith("Bearer ") && authHeader.slice(7).trim().startsWith("crk_")) {
+ if (req.headers.has(COMMUNITY_BOT_ACTOR_HEADER)) {
+ return NextResponse.json({ error: "runner keys cannot select another bot" }, { status: 403 })
+ }
const { env } = await getCloudflareContext({ async: true })
const cloudflareEnv = env as Env
const db = getDb(cloudflareEnv.DB)
@@ -136,6 +141,16 @@ function createCommunityActorHandler(
// the unified actor. withAuth owns all human auth behavior (KV cache,
// session guard, Set-Cookie refresh); we do not reimplement any of it.
const delegated = withAuth(async (r, humanCtx: AuthContext & { params?: Record<string, string> }) => {
+ const selectedBotId = r.headers.get(COMMUNITY_BOT_ACTOR_HEADER)
+ if (selectedBotId !== null) {
+ const resolved = await resolveOwnedBotActor(getDb(humanCtx.env.DB), selectedBotId, humanCtx.userId, { allowInactive: options.allowInactiveBot })
+ if (resolved.kind === "error") return resolved.response
+ return handler(r, {
+ env: humanCtx.env,
+ params: humanCtx.params,
+ actor: { kind: "bot", userId: resolved.actor.botUserId, ownerUserId: resolved.actor.ownerUserId, machineId: resolved.actor.machineId, isActive: resolved.actor.isActive, delegatedByUserId: humanCtx.userId },
+ })
+ }
return handler(r, {
env: humanCtx.env,
actor: {
@@ -147,7 +162,7 @@ function createCommunityActorHandler(
},
params: humanCtx.params,
})
- })
+ }, { allowBotSelection: true })
return delegated(req, context)
}
}
diff --git a/src/web/src/lib/middleware/community-agent-runner-auth.test.ts b/src/web/src/lib/middleware/community-agent-runner-auth.test.ts
index a1d1ed599..68e0a009e 100644
--- a/src/web/src/lib/middleware/community-agent-runner-auth.test.ts
+++ b/src/web/src/lib/middleware/community-agent-runner-auth.test.ts
@@ -2,6 +2,7 @@ import { beforeEach, describe, expect, it, vi } from "vitest"
const mockFindRunnerKey = vi.fn()
const mockGetUserInternal = vi.fn()
+const mockGetBotOwnedBy = vi.fn()
const mockGetBotBinding = vi.fn()
const mockLogWarn = vi.fn()
@@ -16,12 +17,13 @@ vi.mock("@alook/shared", () => ({
getUserInternal: (...args: unknown[]) => mockGetUserInternal(...args),
},
communityBot: {
+ getBotOwnedBy: (...args: unknown[]) => mockGetBotOwnedBy(...args),
getBotBinding: (...args: unknown[]) => mockGetBotBinding(...args),
},
},
}))
-import { resolveBotActor } from "./community-agent-runner-auth"
+import { resolveBotActor, resolveOwnedBotActor } from "./community-agent-runner-auth"
describe("resolveBotActor active entitlement gate", () => {
beforeEach(() => {
@@ -76,3 +78,39 @@ describe("resolveBotActor active entitlement gate", () => {
})
})
})
+
+
+describe("resolveOwnedBotActor", () => {
+ beforeEach(() => { vi.clearAllMocks(); mockGetBotOwnedBy.mockResolvedValue({ id: "bot_1", machineId: "machine_1", isActive: true }) })
+ it("uses an owner-scoped live bot lookup and its real machine binding", async () => {
+ expect(await resolveOwnedBotActor({} as never, "bot_1", "owner_1")).toEqual({ kind: "bot", actor: { botUserId: "bot_1", ownerUserId: "owner_1", machineId: "machine_1", isActive: true } })
+ expect(mockGetBotOwnedBy).toHaveBeenCalledWith({}, "bot_1", "owner_1")
+ expect(mockFindRunnerKey).not.toHaveBeenCalled()
+ })
+ it.each(["foreign", "deleted", "missing", ""])("rejects %s with the same not-found response", async (id) => {
+ mockGetBotOwnedBy.mockResolvedValue(null)
+ const result = await resolveOwnedBotActor({} as never, id, "owner_1")
+ expect(result.kind).toBe("error")
+ if (result.kind === "error") expect(result.response.status).toBe(404)
+ })
+ it("rejects an unbound bot even when inactive identities are permitted", async () => {
+ mockGetBotOwnedBy.mockResolvedValue({ id: "bot_1", machineId: null, isActive: false })
+ const result = await resolveOwnedBotActor({} as never, "bot_1", "owner_1", { allowInactive: true })
+ if (result.kind !== "error") throw new Error("expected error")
+ expect(result.response.status).toBe(403)
+ })
+ it("keeps inactive policy explicit without treating a bound offline machine as unauthenticated", async () => {
+ mockGetBotOwnedBy.mockResolvedValue({ id: "bot_1", machineId: "machine_1", isActive: false })
+ const denied = await resolveOwnedBotActor({} as never, "bot_1", "owner_1")
+ if (denied.kind !== "error") throw new Error("expected error")
+ expect(denied.response.status).toBe(403)
+ expect(await resolveOwnedBotActor({} as never, "bot_1", "owner_1", { allowInactive: true })).toMatchObject({ kind: "bot", actor: { isActive: false } })
+ })
+ it("returns retryable service failure when the ownership lookup fails", async () => {
+ mockGetBotOwnedBy.mockRejectedValue(new Error("D1 unavailable"))
+ const result = await resolveOwnedBotActor({} as never, "bot_1", "owner_1")
+ if (result.kind !== "error") throw new Error("expected error")
+ expect(result.response.status).toBe(503)
+ expect(result.response.headers.get("Retry-After")).toBe("1")
+ })
+})
diff --git a/src/web/src/lib/middleware/community-agent-runner-auth.ts b/src/web/src/lib/middleware/community-agent-runner-auth.ts
index d05d1b240..5409641b1 100644
--- a/src/web/src/lib/middleware/community-agent-runner-auth.ts
+++ b/src/web/src/lib/middleware/community-agent-runner-auth.ts
@@ -136,3 +136,14 @@ export async function resolveBotActor(
},
}
}
+
+export async function resolveOwnedBotActor(db: Database, botId: string, ownerId: string, options: ResolveBotActorOptions = {}) {
+ const lookup = await lookupOr503("getBotOwnedBy", () => queries.communityBot.getBotOwnedBy(db, botId, ownerId))
+ if (!lookup.ok) return { kind: "error" as const, response: lookup.response }
+ const bot = lookup.value
+ if (!bot) return { kind: "error" as const, response: NextResponse.json({ error: "bot not found" }, { status: 404 }) }
+ if (!bot.machineId || !bot.isActive && !options.allowInactive) {
+ return { kind: "error" as const, response: NextResponse.json({ error: "bot is inactive or has no machine binding" }, { status: 403 }) }
+ }
+ return { kind: "bot" as const, actor: { botUserId: bot.id, ownerUserId: ownerId, machineId: bot.machineId, isActive: bot.isActive } }
+}
diff --git a/src/web/src/lib/middleware/private-media-cache.test.ts b/src/web/src/lib/middleware/private-media-cache.test.ts
index c87d0c1fd..fdd024eaa 100644
--- a/src/web/src/lib/middleware/private-media-cache.test.ts
+++ b/src/web/src/lib/middleware/private-media-cache.test.ts
@@ -118,7 +118,7 @@ describe("real authentication wrappers inside media policy", () => {
mocks.getSession.mockResolvedValueOnce(session(viewer))
const result = await route(request({ Cookie: `viewer=${viewer}; _ga=${ga}; better-auth.session_data=${sessionData}` }), params)
expect(result.status).toBe(status)
- expect(result.headers.get("Vary")).toBe("Accept-Encoding, Authorization")
+ expect(result.headers.get("Vary")).toBe("Accept-Encoding, Authorization, X-Alook-Bot-Id")
expect(result.headers.get("Cache-Control")).toBe(IMMUTABLE)
expect(result.headers.get("Set-Cookie")).toContain("better-auth.session_data=fixture-refresh")
expect(handler.mock.lastCall?.[1]).toMatchObject({ userId: viewer, params: { id: "fixed" } })
@@ -147,7 +147,7 @@ describe("real authentication wrappers inside media policy", () => {
const handler = vi.fn<AuthenticatedHandler>(async () => media(status))
const result = await withPrivateMediaCache(withAuth(handler))(request({ Authorization: "Bearer al_fixture" }))
expect(result.status).toBe(status)
- expect(result.headers.get("Vary")).toBe("Authorization")
+ expect(result.headers.get("Vary")).toBe("Authorization, X-Alook-Bot-Id")
expect(mocks.getSession).not.toHaveBeenCalled()
expect(handler.mock.lastCall?.[1]).toMatchObject({ userId: "A", workspaceId: "ws1" })
})
@@ -166,7 +166,7 @@ describe("real authentication wrappers inside media policy", () => {
const handler = vi.fn<CommunityActorHandler>(async () => media())
const headers: Record<string, string> = kind === "bot" ? { Authorization: "Bearer crk_fixture" } : { Cookie: "viewer=A; _ga=changed" }
const result = await withPrivateMediaCache(withCommunityActor(handler))(request(headers))
- expect(result.headers.get("Vary")).toBe("Authorization")
+ expect(result.headers.get("Vary")).toBe("Authorization, X-Alook-Bot-Id")
expect(handler.mock.lastCall?.[1].actor.kind).toBe(kind)
expect(mocks.getSession).toHaveBeenCalledTimes(kind === "human" ? 1 : 0)
})
@@ -193,6 +193,6 @@ describe("real authentication wrappers inside media policy", () => {
it("keeps default private account responses credential-specific outside the selected media wrapper", async () => {
const result = await withAuth(async () => media())(request())
- expect(result.headers.get("Vary")).toBe("Cookie, Authorization")
+ expect(result.headers.get("Vary")).toBe("Cookie, Authorization, X-Alook-Bot-Id")
})
})
diff --git a/src/web/src/lib/middleware/response-cache.test.ts b/src/web/src/lib/middleware/response-cache.test.ts
index e2b5e28c6..35526b5dc 100644
--- a/src/web/src/lib/middleware/response-cache.test.ts
+++ b/src/web/src/lib/middleware/response-cache.test.ts
@@ -8,7 +8,7 @@ describe("protected community JSON policy", () => {
const response = await protectCommunityJsonResponse(request, Response.json(status === 200 ? { value: 1 } : { error: "blocked" }, { status,
headers: { "Vary": "Origin, cookie", "Cache-Control": "public, max-age=600", "ETag": "old", "Last-Modified": "old", "Set-Cookie": "session=refreshed; HttpOnly" } }))
expect(response.headers.get("Cache-Control")).toBe("private, no-store, max-age=0")
- expect(response.headers.get("Vary")).toBe("Origin, cookie, X-Alook-Community-Contract, Authorization")
+ expect(response.headers.get("Vary")).toBe("Origin, cookie, X-Alook-Community-Contract, Authorization, X-Alook-Bot-Id")
expect(response.headers.get("ETag")).toBeNull()
expect(response.headers.get("Last-Modified")).toBeNull()
expect(response.headers.get("Set-Cookie")).toBe("session=refreshed; HttpOnly")
diff --git a/src/web/src/lib/middleware/response-cache.ts b/src/web/src/lib/middleware/response-cache.ts
index bb03447f2..4c5f65a50 100644
--- a/src/web/src/lib/middleware/response-cache.ts
+++ b/src/web/src/lib/middleware/response-cache.ts
@@ -1,4 +1,4 @@
-import { COMMUNITY_CONTRACT_HEADER, requestedCommunityContract, communityReadSchemas, requestsCommunityContract } from "@alook/shared"
+import { COMMUNITY_BOT_ACTOR_HEADER, COMMUNITY_CONTRACT_HEADER, requestedCommunityContract, communityReadSchemas, requestsCommunityContract } from "@alook/shared"
export function rejectUnknownCommunityContract(request: Request): Response | null {
const version = request.headers.get(COMMUNITY_CONTRACT_HEADER)
@@ -35,7 +35,7 @@ export async function protectCommunityJsonResponse(request: Request, response: R
const vary = result.headers.get("Vary")?.split(",").map((field) => field.trim()).filter(Boolean) ?? []
const fields = new Set(vary.map((field) => field.toLowerCase()))
if (!fields.has("*")) {
- const missing = [COMMUNITY_CONTRACT_HEADER, "Cookie", "Authorization"].filter((field) => !fields.has(field.toLowerCase()))
+ const missing = [COMMUNITY_CONTRACT_HEADER, "Cookie", "Authorization", COMMUNITY_BOT_ACTOR_HEADER].filter((field) => !fields.has(field.toLowerCase()))
result.headers.set("Vary", [...vary, ...missing].join(", "))
}
return result
@@ -47,7 +47,7 @@ export function varyPrivateResponseByCredentials(response: Response): Response {
const vary = response.headers.get("Vary")?.split(",").map((field) => field.trim()).filter(Boolean) ?? []
const fields = new Set(vary.map((field) => field.toLowerCase()))
if (fields.has("*")) return response
- const missing = ["Cookie", "Authorization"].filter((field) => !fields.has(field.toLowerCase()))
+ const missing = ["Cookie", "Authorization", COMMUNITY_BOT_ACTOR_HEADER].filter((field) => !fields.has(field.toLowerCase()))
if (missing.length === 0) return response
const result = new Response(response.body, response)
result.headers.set("Vary", [...vary, ...missing].join(", "))
diff --git a/src/web/src/lib/observability/coverage.test.ts b/src/web/src/lib/observability/coverage.test.ts
index 33a1de668..92b72f790 100644
--- a/src/web/src/lib/observability/coverage.test.ts
+++ b/src/web/src/lib/observability/coverage.test.ts
@@ -43,6 +43,7 @@ it("keeps existing mutation owners inventoried and semantic variants on the whit
})
const mutationCoverage = [
+ { "file": "src/web/src/hooks/community/use-bot-memberships.ts", "owner": "useBotMemberships", "action": "community.command" },
{ "file": "src/web/src/hooks/community/mutations/bot-creation.ts", "owner": "useBotCreationDecision", "action": "bot.creation.decision" },
{
"file": "src/web/src/app/(public-community)/c/invite/[token]/invite-accept-client.tsx",
diff --git a/src/web/src/lib/query-keys.ts b/src/web/src/lib/query-keys.ts
index 0f6753a9b..0878a268a 100644
--- a/src/web/src/lib/query-keys.ts
+++ b/src/web/src/lib/query-keys.ts
@@ -161,6 +161,7 @@ export const communityKeys = {
// ── Notification settings ───────────────────────────────────────────────
notificationSettings: () =>
[...communityKeys.all, "notification-settings"] as const,
+ botMemberships: (botId: string) => [...communityKeys.all, "bot", botId, "memberships"] as const,
botNotificationSetting: (botId: string, scope: "server" | "channel", scopeId: string) =>
[...communityKeys.all, "bot", botId, "notification-settings", scope, scopeId] as const,
diff --git a/src/web/src/test/e2e-ui/68-bot-memberships.spec.ts b/src/web/src/test/e2e-ui/68-bot-memberships.spec.ts
new file mode 100644
index 000000000..e689c9ade
--- /dev/null
+++ b/src/web/src/test/e2e-ui/68-bot-memberships.spec.ts
@@ -0,0 +1,338 @@
+import { COMMUNITY_BOT_ACTOR_HEADER, WS_EVENTS } from "@alook/shared"
+import { spawnSync } from "node:child_process"
+import type { Page } from "@playwright/test"
+import { test, expect } from "./_fixtures/case-fixture"
+import type { CaseActors, CaseResources } from "./_fixtures/case-fixture"
+import { connectMachine } from "./_fixtures/community-machine"
+import { gotoAfterUserWsAuth } from "./_fixtures/actions"
+import { tid } from "./_fixtures/testids"
+import { REPO_ROOT, WEB_URL } from "./_setup/paths"
+
+type Bot = { id: string; name: string; runnerKey: string }
+type MembershipEvent = { type: string; wireType?: string; userId?: string; channelId?: string; serverId?: string; relation?: string; present?: boolean }
+
+async function prepareMembershipCase(actors: CaseActors, resources: CaseResources) {
+ const headers = (role: "alice" | "bob" = "alice") => ({ Cookie: actors.sessionCookie(role), Origin: WEB_URL, "Content-Type": "application/json" })
+ const call = (path: string, method = "GET", body?: unknown, extra: Record<string, string> = {}) => fetch(`${WEB_URL}${path}`, {method, headers:{...headers(),...extra}, ...(body === undefined ? {} : {body:JSON.stringify(body)})})
+ const pair = await call("/api/community/machines/pair", "POST")
+ expect(pair.status).toBe(200)
+ const { tokenId } = await pair.json() as { tokenId: string }
+ const activation = await fetch(`${WEB_URL}/api/community/daemon/activate`, {method:"POST",headers:{Authorization:`Bearer ${tokenId}`,Origin:WEB_URL,"Content-Type":"application/json"},body:JSON.stringify({hostname:`membership-qa-${Date.now()}`,platform:"darwin",arch:"arm64",runtimeReport:[{id:"codex",status:"healthy"}]})})
+ expect(activation.status).toBe(200)
+ const {machineId,credential} = await activation.json() as {machineId:string;credential:string}
+ resources.own(machineId, async id => {expect([204,404]).toContain((await call(`/api/community/machines/${id}`,"DELETE")).status)})
+ const machine = connectMachine(credential,resources,{machineId,headers:headers()})
+ await machine.opened
+ const bots: Bot[] = []
+ for (const name of ["Research companion", "Release assistant"]) {
+ const response = await call("/api/community/bots","POST",{name,machineId,runtime:"codex"})
+ expect(response.status).toBe(201)
+ const {bot} = await response.json() as {bot:{id:string;name:string}}
+ resources.own(bot.id,async id => {expect([204,404]).toContain((await call(`/api/community/bots/${id}`,"DELETE")).status)})
+ const enroll = await call("/api/community/daemon/enroll-agent","POST",{agentId:bot.id},{Authorization:`Bearer ${credential}`})
+ expect(enroll.status).toBe(200)
+ const {runnerKey} = await enroll.json() as {runnerKey:string}
+ bots.push({...bot,runnerKey})
+ }
+ const [first,second] = bots as [Bot,Bot]
+ const servers: Array<{id:string;handle:string;publicId:string;privateId:string;privateRef:string;hiddenId:string;threadId:string;messageId:string}> = []
+ for (const name of ["Membership studio", "Release planning with a deliberately long server name"]) {
+ const id = await actors.seed.seedServer("alice",name)
+ const token = await actors.seed.createInvite("alice",id)
+ let handle = ""
+ for (const bot of bots) {
+ const joined = await call(`/api/community/invites/${token}/join`,"POST",{},{Authorization:`Bearer ${bot.runnerKey}`})
+ expect(joined.status).toBe(200)
+ const {server} = await joined.json() as {server:{name:string;discriminator:string}}
+ handle=`${server.name}#${server.discriminator}`
+ }
+ const publicId = await actors.seed.seedChannel("alice",id,"announcements","text")
+ await actors.seed.seedChannel("alice",id,"ideas-and-feedback","forum")
+ const categoryId = await actors.seed.seedCategory("alice",id,"Do not show this category",{private:true})
+ const privateId = await actors.seed.seedChannel("alice",id,"private-working-notes","text",categoryId)
+ const hiddenId = await actors.seed.seedChannel("alice",id,"hidden-from-bots","text",categoryId)
+ for (const bot of bots) expect((await call(`/api/community/channels/${privateId}/members`,"POST",{userId:bot.id})).status).toBe(201)
+ const messageId = await actors.seed.seedMessage("alice",privateId,"Preserved history before bot exit")
+ const threadId = await actors.seed.seedThread("alice",messageId,"Child participation")
+ for (const bot of bots) expect((await call(`/api/community/channels/${threadId}/participants`,"POST",{userId:bot.id})).status).toBe(201)
+ servers.push({id,handle,publicId,privateId,privateRef:`/${handle}/private-working-notes`,hiddenId,threadId,messageId})
+ }
+ return {headers,call,bots,first,second,servers,machine}
+}
+
+async function openMemberships(page: Page, bot: Bot) {
+ const card = page.locator('[data-slot="card"]').filter({has:page.getByText(bot.name,{exact:true})})
+ await expect(card).toHaveCount(1)
+ const trigger = card.getByRole("button",{name:"Bot actions",exact:true})
+ await trigger.click()
+ await page.getByTestId(tid.botMembershipsMenu(bot.id)).click()
+ await expect(page.getByTestId(tid.botMembershipsSheet)).toBeVisible()
+ const description = page.getByTestId(tid.botMembershipsSheet).locator('[data-slot="sheet-description"]')
+ await expect(description).toContainText(bot.name)
+ const avatar = description.locator("svg")
+ await expect(avatar).toHaveCount(1)
+ expect(await avatar.innerHTML()).toBe(await card.locator("svg").first().innerHTML())
+ expect((await avatar.boundingBox())!.width).toBe(24)
+ expect((await avatar.boundingBox())!.height).toBe(24)
+ await expect(page.getByRole("menu",{includeHidden:true})).toHaveCount(0)
+ return trigger
+}
+
+function observeMembershipEvents(page: Page) {
+ const events: MembershipEvent[] = []
+ page.on("websocket", socket => socket.on("framereceived", ({payload}) => {
+ const text = String(payload)
+ if (!text.startsWith("{")) return
+ const event = JSON.parse(text) as MembershipEvent & {events?:MembershipEvent[]}
+ for (const item of event.events ?? [event]) {
+ if (item.type === WS_EVENTS.CHANNEL_MEMBER_REMOVE) events.push({...item,wireType:item.type,type:WS_EVENTS.CHANNEL_MEMBERSHIP_CHANGE,relation:"access",present:false})
+ else if (([WS_EVENTS.CHANNEL_MEMBERSHIP_CHANGE,WS_EVENTS.MEMBER_LEAVE] as string[]).includes(item.type)) events.push(item)
+ }
+ }))
+ return events
+}
+
+function membershipRows(serverId: string, botIds: string[]) {
+ const quote = (value: string) => `'${value.replaceAll("'", "''")}'`
+ const sql = `SELECT m.user_id AS userId, m.channel_id AS channelId, m.relation FROM community_channel_member m JOIN community_channel c ON c.id=m.channel_id WHERE c.server_id=${quote(serverId)} AND m.user_id IN (${botIds.map(quote).join(",")}) ORDER BY m.user_id,m.channel_id,m.relation`
+ const result = spawnSync("pnpm", ["exec","wrangler","d1","execute","alook-app","--local","--json","--command",sql],{cwd:`${REPO_ROOT}/src/web`,encoding:"utf8",maxBuffer:4*1024*1024})
+ expect(result.status).toBe(0)
+ return (JSON.parse(result.stdout) as Array<{results:Array<{userId:string;channelId:string;relation:string}>}>)[0]!.results
+}
+
+test("owned bot exits preserve other identities, child participation boundaries and history", async ({caseActors,caseResources},testInfo) => {
+ test.setTimeout(180_000)
+ const actors = await caseActors(["alice","bob"])
+ const fixture = await prepareMembershipCase(actors,caseResources)
+ const {first,second,servers,call,headers} = fixture
+ const [studio,release] = servers
+ const actorHeader = {[COMMUNITY_BOT_ACTOR_HEADER]:first.id}
+ const list = await call("/api/community/servers/channels","GET",undefined,actorHeader)
+ expect(list.status).toBe(200)
+ const body = await list.json() as {servers:Array<{id:string;handle:string}>;groups:Array<{channels:Array<{ref:string;name:string}>}>}
+ expect(body.servers.map(s=>s.id).sort()).toEqual(servers.map(s=>s.id).sort())
+ const channels = body.groups.flatMap(g=>g.channels)
+ expect(channels.some(c=>c.ref===studio.privateRef)).toBe(true)
+ expect(channels.some(c=>c.name==="hidden-from-bots")).toBe(false)
+ expect(channels.some(c=>c.name==="Child participation")).toBe(false)
+ expect((await fetch(`${WEB_URL}/api/community/servers/channels`,{headers:{...headers("bob"),...actorHeader}})).status).toBe(404)
+ expect((await call("/api/community/servers/channels","GET",undefined,{...actorHeader,Authorization:`Bearer ${first.runnerKey}`})).status).toBe(403)
+ expect((await call("/api/community/users/me/notifications","GET",undefined,actorHeader)).status).toBe(403)
+ const publicLeave = `/api/community/channels/resolve/members/self?ref=${encodeURIComponent(`/${studio.handle}/announcements`)}`
+ expect((await call(publicLeave,"DELETE",undefined,actorHeader)).status).toBe(400)
+ expect((await call(`/api/community/channels/${studio.privateId}/members/${second.id}`,"DELETE",undefined,actorHeader)).status).toBe(403)
+ const before = membershipRows(studio.id,[first.id,second.id])
+ expect(before.filter(r=>r.userId===first.id).map(r=>r.relation).sort()).toEqual(["access","notify"])
+ const {page} = await actors.asUser("alice",{viewport:{width:1280,height:900},reducedMotion:"reduce"})
+ const events = observeMembershipEvents(page)
+ await gotoAfterUserWsAuth(page,"/c/me/bots")
+ const trigger = await openMemberships(page,first)
+ const sheet = page.getByTestId(tid.botMembershipsSheet)
+ await expect(sheet.getByTestId(tid.botMembershipsChannel(studio.privateRef))).toBeVisible()
+ await expect(sheet.getByText("Do not show this category",{exact:true})).toHaveCount(0)
+ await expect(sheet.getByText("hidden-from-bots",{exact:true})).toHaveCount(0)
+ await expect(sheet.getByTestId(tid.botMembershipsLeave(`/${studio.handle}/announcements`))).toBeEnabled()
+ await page.getByTestId(tid.botMembershipsLeave(studio.privateRef)).click()
+ await expect(page.getByRole("alertdialog")).toContainText(first.name)
+ await expect(page.getByRole("alertdialog")).toContainText("Membership-studio")
+ await page.getByRole("button",{name:"Cancel",exact:true}).click()
+ expect(membershipRows(studio.id,[first.id,second.id])).toEqual(before)
+ let fail = true
+ let requests = 0
+ let releaseResponse!: () => void
+ const gate = new Promise<void>(r=>releaseResponse=r)
+ caseResources.own(releaseResponse,async r=>r())
+ let captured!: () => void
+ const saved = new Promise<void>(r=>captured=r)
+ const leavePath = `/api/community/channels/resolve/members/self?ref=${encodeURIComponent(studio.privateRef)}`
+ await page.route(`**${leavePath}`,async route=>{
+ requests++
+ expect(route.request().headers()[COMMUNITY_BOT_ACTOR_HEADER.toLowerCase()]).toBe(first.id)
+ expect(route.request().headers().authorization).toBeUndefined()
+ if(fail){await route.fulfill({status:503,contentType:"application/json",body:JSON.stringify({error:"QA temporary failure"})});return}
+ const response = await route.fetch()
+ expect(response.status()).toBe(204)
+ captured()
+ await gate
+ await route.fulfill({response})
+ })
+ await page.getByTestId(tid.botMembershipsLeave(studio.privateRef)).click()
+ const confirm = page.getByTestId(tid.botMembershipsConfirm)
+ await confirm.click()
+ await expect(page.getByRole("alertdialog").getByRole("alert")).toContainText("QA temporary failure")
+ expect(membershipRows(studio.id,[first.id,second.id])).toEqual(before)
+ fail=false
+ await confirm.click()
+ await saved
+ await expect(confirm).toBeDisabled()
+ await expect(page.getByRole("button",{name:"Cancel",exact:true})).toBeDisabled()
+ await confirm.dispatchEvent("click")
+ expect(requests).toBe(2)
+ releaseResponse()
+ await expect(page.getByRole("alertdialog")).toHaveCount(0)
+ await expect(sheet.getByTestId(tid.botMembershipsChannel(studio.privateRef))).toHaveCount(0)
+ const after = membershipRows(studio.id,[first.id,second.id])
+ expect(after).toEqual(before.filter(r=>r.userId===second.id))
+ await testInfo.attach("received-community-events",{body:JSON.stringify(events),contentType:"application/json"})
+ await expect.poll(()=>events.some(e=>e.type===WS_EVENTS.CHANNEL_MEMBERSHIP_CHANGE&&e.userId===first.id&&e.channelId===studio.privateId&&e.relation==="access"&&e.present===false)).toBe(true)
+ expect((await call(leavePath,"DELETE",undefined,actorHeader)).status).toBe(403)
+ expect((await call(`/api/community/bots/${first.id}/active`,"PATCH",{active:false})).status).toBe(200)
+ expect((await call("/api/community/servers/channels","GET",undefined,actorHeader)).status).toBe(200)
+ expect((await call("/api/community/channels/resolve/messages","POST",{channel:`/${release.handle}/announcements`,content:{text:"must not send"}},actorHeader)).status).toBe(403)
+ await page.getByTestId(tid.botMembershipsLeave(`/${release.handle}/announcements`)).click()
+ await expect(page.getByRole("alertdialog")).toContainText("public")
+ await expect(confirm).toHaveText("Leave server")
+ const left = page.waitForResponse(r=>r.request().method()==="POST"&&new URL(r.url()).pathname==="/api/community/servers/resolve/leave")
+ await confirm.click()
+ expect((await left).status()).toBe(204)
+ await expect(sheet.getByTestId(tid.botMembershipsServer(release.id))).toHaveCount(0)
+ expect(membershipRows(release.id,[first.id,second.id]).map(r=>r.userId)).toEqual([second.id,second.id])
+ await expect.poll(()=>events.some(e=>e.type===WS_EVENTS.MEMBER_LEAVE&&e.userId===first.id&&e.serverId===release.id)).toBe(true)
+ const roster = await call(`/api/community/servers/${release.id}/members`)
+ expect(roster.status).toBe(200)
+ const members = (await roster.json() as {members:Array<{userId:string}>}).members.map(m=>m.userId)
+ expect(members).toContain(actors.userId("alice"))
+ expect(members).toContain(second.id)
+ expect(members).not.toContain(first.id)
+ const history = await call(`/api/community/channels/${release.privateId}/messages`)
+ expect(history.status).toBe(200)
+ expect((await history.json() as {messages:Array<{id:string}>}).messages.some(m=>m.id===release.messageId)).toBe(true)
+ await page.getByTestId(tid.botMembershipsLeave(studio.id)).click()
+ await confirm.click()
+ await expect(sheet.getByText("No servers yet",{exact:true})).toBeVisible()
+ await page.keyboard.press("Escape")
+ await expect(sheet).toHaveCount(0)
+ await expect(trigger).toBeFocused()
+ await openMemberships(page,second)
+ for(const server of servers) await expect(page.getByTestId(tid.botMembershipsServer(server.id))).toBeVisible()
+ await testInfo.attach("membership-api-d1-ws",{body:JSON.stringify({before,after,events,protectedIdentities:[actors.userId("alice"),second.id],historyPreserved:release.messageId}),contentType:"application/json"})
+})
+
+test("membership loading and late responses stay bound to the selected bot on desktop and mobile", async ({caseActors,caseResources},testInfo) => {
+ test.setTimeout(180_000)
+ const actors = await caseActors(["alice"])
+ const {first,second,servers,call} = await prepareMembershipCase(actors,caseResources)
+ const [studio,release] = servers
+ expect((await call(`/api/community/servers/resolve/leave?server=${encodeURIComponent(release.handle)}`,"POST",undefined,{[COMMUNITY_BOT_ACTOR_HEADER]:second.id})).status).toBe(204)
+ const {page} = await actors.asUser("alice",{viewport:{width:1440,height:1000},reducedMotion:"reduce"})
+ await gotoAfterUserWsAuth(page,"/c/me/bots")
+ const style="nextjs-portal, .tsqd-open-btn-container { visibility:hidden !important; }"
+ const botCard = page.locator('[data-slot="card"]').filter({has:page.getByText(first.name,{exact:true})})
+ await expect(botCard).toHaveCount(1)
+ await botCard.getByRole("button",{name:"Bot actions",exact:true}).click()
+ await expect(page.getByRole("menuitem",{name:"Restart",exact:true})).toBeVisible()
+ await expect(page.getByRole("menuitem",{name:"Reset",exact:true})).toHaveCount(0)
+ await page.screenshot({path:testInfo.outputPath("bot-restart-menu.png"),style})
+ await page.getByRole("menuitem",{name:"Restart",exact:true}).click()
+ await expect(page.getByRole("alertdialog").getByRole("heading",{name:"Restart this bot?",exact:true})).toBeVisible()
+ await expect(page.getByRole("menu",{includeHidden:true})).toHaveCount(0)
+ await page.screenshot({path:testInfo.outputPath("bot-restart-confirm.png"),style})
+ await page.getByRole("alertdialog").getByRole("button",{name:"Cancel",exact:true}).click()
+ await expect(page.getByRole("alertdialog")).toHaveCount(0)
+ let releaseFailure!: () => void
+ const failureGate = new Promise<void>(r=>releaseFailure=r)
+ caseResources.own(releaseFailure,async r=>r())
+ let fail = true
+ let hold = false
+ let releaseRead!: () => void
+ let captureRead!: () => void
+ let finishRead!: () => void
+ const gate = new Promise<void>(r=>releaseRead=r)
+ const captured = new Promise<void>(r=>captureRead=r)
+ const delivered = new Promise<void>(r=>finishRead=r)
+ caseResources.own(releaseRead,async r=>r())
+ await page.route("**/api/community/servers/channels",async route=>{
+ if(route.request().headers()[COMMUNITY_BOT_ACTOR_HEADER.toLowerCase()]!==first.id){await route.continue();return}
+ if(fail){await failureGate;await route.fulfill({status:503,contentType:"application/json",body:JSON.stringify({error:"QA loading unavailable"})});return}
+ if(!hold){await route.continue();return}
+ const response = await route.fetch()
+ expect(response.status()).toBe(200)
+ captureRead()
+ await gate
+ await route.fulfill({response}).catch(()=>undefined)
+ finishRead()
+ })
+ const sheet = page.getByTestId(tid.botMembershipsSheet)
+ await openMemberships(page,first)
+ await expect(sheet.getByLabel("Loading servers and channels")).toBeVisible()
+ await page.screenshot({path:testInfo.outputPath("memberships-loading.png"),style})
+ releaseFailure()
+ await expect(sheet.getByRole("alert")).toHaveText("Could not load servers and channels.")
+ fail=false
+ await sheet.getByRole("button",{name:"Try again",exact:true}).click()
+ await expect(sheet.getByTestId(tid.botMembershipsServer(release.id))).toBeVisible()
+ await page.keyboard.press("Escape")
+ await expect(sheet).toHaveCount(0)
+ hold=true
+ await openMemberships(page,first)
+ await captured
+ await page.keyboard.press("Escape")
+ await expect(sheet).toHaveCount(0)
+ await openMemberships(page,second)
+ await expect(sheet.getByTestId(tid.botMembershipsServer(studio.id))).toBeVisible()
+ await expect(sheet.getByTestId(tid.botMembershipsServer(release.id))).toHaveCount(0)
+ releaseRead()
+ await delivered
+ await expect(sheet).toContainText(second.name)
+ await expect(sheet.getByTestId(tid.botMembershipsServer(release.id))).toHaveCount(0)
+ hold=false
+ await page.keyboard.press("Escape")
+ await expect(sheet).toHaveCount(0)
+ await openMemberships(page,first)
+ await expect(sheet.getByTestId(tid.botMembershipsServer(release.id))).toBeVisible()
+ await page.screenshot({path:testInfo.outputPath("memberships-desktop-light.png"),style})
+ await page.keyboard.press("Escape")
+ await page.getByTestId(tid.userSettingsOpen).click()
+ await page.getByTestId(tid.settingsTab("appearance")).click()
+ await page.getByRole("button",{name:"Dark",exact:true}).click()
+ await expect(page.getByRole("button",{name:"Dark",exact:true})).toHaveAttribute("aria-pressed","true")
+ await page.getByTestId(tid.settingsClose).click()
+ await openMemberships(page,first)
+ await expect(sheet.getByTestId(tid.botMembershipsServer(release.id))).toBeVisible()
+ await page.screenshot({path:testInfo.outputPath("memberships-desktop-dark.png"),style})
+ await page.keyboard.press("Escape")
+ await page.getByTestId(tid.userSettingsOpen).click()
+ await page.getByTestId(tid.settingsTab("appearance")).click()
+ await page.getByRole("button",{name:"Light",exact:true}).click()
+ await page.getByTestId(tid.settingsClose).click()
+ await page.setViewportSize({width:390,height:844})
+ await openMemberships(page,first)
+ await expect(sheet.getByTestId(tid.botMembershipsChannel(studio.privateRef))).toBeVisible()
+ const box = (await sheet.boundingBox())!
+ expect(box.x).toBeGreaterThanOrEqual(0)
+ expect(box.x+box.width).toBeLessThanOrEqual(390)
+ expect((await sheet.getByTestId(tid.botMembershipsLeave(studio.privateRef)).boundingBox())!.height).toBeGreaterThanOrEqual(44)
+ const actions = sheet.getByTestId(/^bot-memberships-leave-/)
+ expect(await actions.count()).toBeGreaterThan(2)
+ const privateRow = sheet.getByTestId(tid.botMembershipsChannel(studio.privateRef))
+ const lock = privateRow.getByLabel("Private channel",{exact:true})
+ await expect(lock).toBeVisible()
+ const icons = privateRow.locator("svg")
+ expect((await lock.boundingBox())!.x).toBeLessThan((await icons.nth(1).boundingBox())!.x)
+ await expect(sheet.getByTestId(tid.botMembershipsChannel(`/${studio.handle}/announcements`)).getByLabel("Private channel",{exact:true})).toHaveCount(0)
+ for (const action of await actions.all()) {
+ const bounds = (await action.boundingBox())!
+ expect(bounds.height).toBeGreaterThanOrEqual(44)
+ expect(bounds.width).toBeGreaterThanOrEqual(44)
+ await expect(action).toHaveAccessibleName(/Leave/)
+ expect((await action.innerText()).trim()).toBe("")
+ }
+ await page.screenshot({path:testInfo.outputPath("memberships-mobile.png"),style})
+ await sheet.getByTestId(tid.botMembershipsLeave(studio.privateRef)).click()
+ const confirmation = page.getByRole("alertdialog")
+ await expect(confirmation).toContainText("Membership-studio")
+ expect((await page.getByTestId(tid.botMembershipsConfirm).boundingBox())!.height).toBeGreaterThanOrEqual(44)
+ expect((await confirmation.getByRole("button",{name:"Cancel",exact:true}).boundingBox())!.height).toBeGreaterThanOrEqual(44)
+ await page.screenshot({path:testInfo.outputPath("memberships-mobile-confirm.png"),style})
+ await confirmation.getByRole("button",{name:"Cancel",exact:true}).click()
+ await sheet.getByTestId(tid.botMembershipsLeave(`/${studio.handle}/announcements`)).click()
+ await expect(confirmation).toContainText("public")
+ await expect(confirmation).toContainText("Membership-studio")
+ await expect(page.getByTestId(tid.botMembershipsConfirm)).toHaveText("Leave server")
+ await page.screenshot({path:testInfo.outputPath("memberships-mobile-public-confirm.png"),style})
+ await confirmation.getByRole("button",{name:"Cancel",exact:true}).click()
+ await expect(sheet.getByTestId(tid.botMembershipsServer(studio.id))).toBeVisible()
+ await page.keyboard.press("Escape")
+ expect((await call(`/api/community/bots/${first.id}`,"DELETE")).status).toBe(204)
+ expect((await call("/api/community/servers/channels","GET",undefined,{[COMMUNITY_BOT_ACTOR_HEADER]:first.id})).status).toBe(404)
+})