Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript
28.8 KB
Raw Blame
import React from 'react'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import {
  cleanup,
  fireEvent,
  render as rtlRender,
  screen,
  waitFor,
  within,
} from '@testing-library/react'
import TeamDetailsPage from '../../app/profile-admin/teams/[teamId]/page'
import UserDetailsPage from '../../app/profile-admin/users/[userId]/page'
import * as api from '../../lib/api'
import { ToastProvider } from '../Toast'

const pushMock = vi.fn()
const replaceMock = vi.fn()
const navigationState = vi.hoisted(() => ({
  params: { tab: 'agents' } as { userId?: string; teamId?: string; tab?: string },
}))

vi.mock('next/navigation', () => ({
  useParams: () => navigationState.params,
  usePathname: () =>
    navigationState.params.teamId
      ? '/users-and-teams/teams/team-1/agents'
      : '/users-and-teams/users/user-1/agents',
  useRouter: () => ({ push: pushMock, replace: replaceMock }),
  useSearchParams: () => new URLSearchParams(),
}))

vi.mock('@components/DetailPageShell', () => ({
  DetailPageShell: ({
    actions,
    children,
    contentClassName,
    title,
  }: {
    actions?: React.ReactNode
    children: React.ReactNode
    contentClassName?: string
    title?: React.ReactNode
  }) => (
    <main>
      <h1>{title}</h1>
      <div aria-label="Detail actions">{actions}</div>
      <div className={contentClassName} data-testid="detail-page-content">
        {children}
      </div>
    </main>
  ),
}))

vi.mock('../../lib/api', async () => {
  const actual = await vi.importActual<typeof import('../../lib/api')>('../../lib/api')
  return {
    ...actual,
    addAdminTeamMember: vi.fn(),
    apiGet: vi.fn(),
    deleteAdminMember: vi.fn(),
    deleteAdminTeam: vi.fn(),
    deleteAdminUser: vi.fn(),
    getAdminTeam: vi.fn(),
    getAdminTeamAgents: vi.fn(),
    getAdminTeamContexts: vi.fn(),
    getAdminTeamMembers: vi.fn(),
    getAdminTeamPendingInvitations: vi.fn(),
    getAdminTeams: vi.fn(),
    getAdminUserAgents: vi.fn(),
    getAdminUserContext: vi.fn(),
    getAdminUserContexts: vi.fn(),
    getAdminUserTeams: vi.fn(),
    getAdminUsers: vi.fn(),
    getContexts: vi.fn(),
    getHosts: vi.fn(),
    inviteAdminTeamMember: vi.fn(),
    renameAdminTeam: vi.fn(),
    updateAdminMemberRole: vi.fn(),
    updateAdminTeamAgents: vi.fn(),
    updateAdminTeamContexts: vi.fn(),
    updateAdminUserAgents: vi.fn(),
    updateAdminUserContext: vi.fn(),
    updateAdminUserContexts: vi.fn(),
  }
})

function render(children: React.ReactNode) {
  return rtlRender(<ToastProvider>{children}</ToastProvider>)
}

function renderTeamDetails() {
  navigationState.params = { teamId: 'team-1', tab: 'agents' }
  return render(<TeamDetailsPage />)
}

function renderUserDetails() {
  navigationState.params = { userId: 'user-1', tab: 'agents' }
  return render(<UserDetailsPage />)
}

const contextItems = [
  { metadata: { name: 'ctx-alpha' }, spec: { contextId: 'ctx-alpha', mcpServers: [] } },
  { metadata: { name: 'ctx-unrelated' }, spec: { contextId: 'ctx-unrelated', mcpServers: [] } },
  { metadata: { name: 'ctx-beta' }, spec: { contextId: 'ctx-beta', mcpServers: [] } },
]

const hostItems = [
  { metadata: { name: 'agent-alpha' }, spec: { contextRef: 'ctx-alpha' } },
  { metadata: { name: 'agent-beta' }, spec: { contextRef: 'ctx-beta' } },
]

beforeEach(() => {
  vi.clearAllMocks()
  navigationState.params = { tab: 'agents' }
  vi.mocked(api.getContexts).mockResolvedValue({ items: contextItems })
  vi.mocked(api.getHosts).mockResolvedValue({ items: hostItems })
  vi.mocked(api.apiGet).mockResolvedValue({ items: [] })
  vi.mocked(api.getAdminTeams).mockResolvedValue({
    items: [{ id: 'team-1', name: 'Platform', memberCount: 1 }],
  })
  vi.mocked(api.getAdminUserTeams).mockResolvedValue({ items: [] })
  vi.mocked(api.getAdminUsers).mockResolvedValue({
    items: [
      {
        id: 'user-1',
        email: '[email protected]',
        name: 'Member One',
        picture: null,
        displayName: 'Member One',
        activeTeamCount: 1,
      },
    ],
  })
  vi.mocked(api.getAdminUserContext).mockResolvedValue({
    id: 'user-1',
    email: '[email protected]',
    name: 'Member One',
    picture: null,
    displayName: 'Member One',
    channels: { emails: [], slackUserNames: [], telegramIds: [] },
  })
  vi.mocked(api.getAdminTeam).mockResolvedValue({ id: 'team-1', name: 'Platform' })
  vi.mocked(api.getAdminTeamMembers).mockResolvedValue({ items: [] })
  vi.mocked(api.getAdminTeamPendingInvitations).mockResolvedValue({ items: [] })
})

afterEach(() => {
  cleanup()
})

describe('profile-admin agent compatibility access', () => {
  it('continues the detail panel surface through team tab content', async () => {
    renderTeamDetails()
    await waitFor(() =>
      expect(screen.getByTestId('detail-page-content')).toHaveClass(
        'cu-detail-content-stack--panel-continuation'
      )
    )
  })

  it('continues the detail panel surface and bolds member contact values', async () => {
    navigationState.params = { userId: 'user-1', tab: 'contact' }
    render(<UserDetailsPage />)

    await screen.findByText('Member name')
    const primaryEmailField = screen.getByText('Primary email').parentElement
    expect(primaryEmailField).not.toBeNull()
    expect(within(primaryEmailField as HTMLElement).getByText('[email protected]').tagName).toBe(
      'STRONG'
    )
    expect(primaryEmailField?.querySelector('.cu-field__readonly')).toBeNull()
    expect(screen.getByTestId('detail-page-content')).toHaveClass(
      'cu-detail-content-stack--panel-continuation'
    )
  })

  it('adds existing team members with the shared searchable chip picker and dialog', async () => {
    vi.mocked(api.getAdminTeamContexts).mockResolvedValue({ teamId: 'team-1', contextIds: [] })
    vi.mocked(api.getAdminTeamAgents).mockResolvedValue({
      teamId: 'team-1',
      agentNames: [],
      deletedAgentNames: [],
      deletedHistoryLimit: 10,
    })
    vi.mocked(api.addAdminTeamMember).mockResolvedValue({} as never)
    navigationState.params = { teamId: 'team-1', tab: 'members' }
    render(<TeamDetailsPage />)

    await screen.findByRole('button', { name: 'Add member' })
    fireEvent.click(screen.getByRole('button', { name: 'Add member' }))
    const dialog = screen.getByRole('dialog', { name: 'Add member' })
    expect(dialog).toHaveClass('eft-dialog')
    fireEvent.click(within(dialog).getByRole('tab', { name: 'Existing member' }))
    fireEvent.click(within(dialog).getByRole('option', { name: 'Member One, [email protected]' }))
    expect(dialog.querySelector('.cu-selection-dropdown__chips')).toHaveTextContent('Member One')
    expect(within(dialog).getByLabelText('Role')).toBeInTheDocument()
    fireEvent.click(within(dialog).getByRole('button', { name: 'Add member' }))

    await waitFor(() =>
      expect(api.addAdminTeamMember).toHaveBeenCalledWith('team-1', 'user-1', 'member')
    )
    await waitFor(() => expect(screen.queryByRole('dialog')).toBeNull())
  })

  it('adds members to teams through the shared searchable chip picker and dialog', async () => {
    vi.mocked(api.getAdminUserContexts).mockResolvedValue({ userId: 'user-1', contextIds: [] })
    vi.mocked(api.getAdminUserAgents).mockResolvedValue({
      userId: 'user-1',
      agentNames: [],
      deletedAgentNames: [],
      deletedHistoryLimit: 10,
    })
    vi.mocked(api.addAdminTeamMember).mockResolvedValue({} as never)
    navigationState.params = { userId: 'user-1', tab: 'teams' }
    render(<UserDetailsPage />)

    await screen.findByRole('button', { name: 'Add to team' })
    fireEvent.click(screen.getByRole('button', { name: 'Add to team' }))
    const dialog = screen.getByRole('dialog', { name: 'Add to team' })
    expect(dialog).toHaveClass('eft-dialog')
    fireEvent.click(within(dialog).getByRole('option', { name: 'Platform, 1 member' }))
    expect(dialog.querySelector('.cu-selection-dropdown__chips')).toHaveTextContent('Platform')
    expect(within(dialog).getByLabelText('Role')).toBeInTheDocument()
    fireEvent.click(within(dialog).getByRole('button', { name: 'Add to team' }))

    await waitFor(() =>
      expect(api.addAdminTeamMember).toHaveBeenCalledWith('team-1', 'user-1', 'member')
    )
    await waitFor(() => expect(screen.queryByRole('dialog')).toBeNull())
  })

  it('renames a team through the scalar edit dialog and retains failures', async () => {
    vi.mocked(api.getAdminTeam)
      .mockResolvedValueOnce({ id: 'team-1', name: 'Platform' })
      .mockResolvedValueOnce({ id: 'team-1', name: 'Platform Engineering (canonical)' })
    vi.mocked(api.getAdminTeamContexts).mockResolvedValue({ teamId: 'team-1', contextIds: [] })
    vi.mocked(api.getAdminTeamAgents).mockResolvedValue({
      teamId: 'team-1',
      agentNames: [],
      deletedAgentNames: [],
      deletedHistoryLimit: 10,
    })
    vi.mocked(api.renameAdminTeam)
      .mockRejectedValueOnce(new Error('Rename failed'))
      .mockResolvedValueOnce({ id: 'team-1', name: 'Platform Engineering' })
    renderTeamDetails()

    await screen.findByRole('heading', { name: 'Platform' })
    fireEvent.click(screen.getByRole('button', { name: 'Team actions' }))
    fireEvent.click(screen.getByRole('menuitem', { name: 'Rename team' }))
    const dialog = await screen.findByRole('dialog', { name: 'Rename team' })
    const input = within(dialog).getByRole('textbox', { name: 'Team name' })
    expect(input).toHaveValue('Platform')
    fireEvent.change(input, { target: { value: 'Platform Engineering' } })
    fireEvent.click(within(dialog).getByRole('button', { name: 'Rename team' }))

    expect(await within(dialog).findByRole('alert')).toHaveTextContent('Rename failed')
    expect(input).toHaveValue('Platform Engineering')
    fireEvent.click(within(dialog).getByRole('button', { name: 'Rename team' }))
    await waitFor(() => expect(api.renameAdminTeam).toHaveBeenCalledTimes(2))
    await waitFor(() => expect(api.getAdminTeam).toHaveBeenCalledTimes(2))
    await waitFor(() => expect(screen.queryByRole('dialog')).toBeNull())
    expect(
      screen.getByRole('heading', { name: 'Platform Engineering (canonical)' })
    ).toBeInTheDocument()
    expect(screen.getByText('Team renamed.')).toBeInTheDocument()
  })

  it('grants member agent access through the shared relationship dialog', async () => {
    vi.mocked(api.getAdminUserContexts).mockResolvedValue({ userId: 'user-1', contextIds: [] })
    vi.mocked(api.getAdminUserAgents).mockResolvedValue({
      userId: 'user-1',
      agentNames: [],
      deletedAgentNames: [],
      deletedHistoryLimit: 10,
    })
    vi.mocked(api.updateAdminUserAgents).mockResolvedValue({
      userId: 'user-1',
      agentNames: ['agent-alpha'],
      deletedAgentNames: [],
      deletedHistoryLimit: 10,
    })
    vi.mocked(api.updateAdminUserContexts).mockResolvedValue({
      userId: 'user-1',
      contextIds: ['ctx-alpha'],
    })
    renderUserDetails()

    await screen.findByRole('button', { name: 'Grant agent' })
    fireEvent.click(screen.getByRole('button', { name: 'Grant agent' }))
    const dialog = screen.getByRole('dialog', { name: 'Grant agent access' })
    fireEvent.click(within(dialog).getByRole('option', { name: /agent-alpha/ }))
    fireEvent.click(within(dialog).getByRole('button', { name: 'Grant agent' }))

    await waitFor(() =>
      expect(api.updateAdminUserAgents).toHaveBeenCalledWith('user-1', ['agent-alpha'], [])
    )
    expect(api.updateAdminUserContexts).toHaveBeenCalledWith('user-1', ['ctx-alpha'])
    await waitFor(() => expect(screen.queryByRole('dialog')).toBeNull())
  })

  it('keeps the team agent chooser open with its selection when persistence fails', async () => {
    vi.mocked(api.getAdminTeamContexts).mockResolvedValue({ teamId: 'team-1', contextIds: [] })
    vi.mocked(api.getAdminTeamAgents).mockResolvedValue({
      teamId: 'team-1',
      agentNames: [],
      deletedAgentNames: [],
      deletedHistoryLimit: 10,
    })
    vi.mocked(api.updateAdminTeamAgents).mockRejectedValue(new Error('Agent grant failed'))
    renderTeamDetails()

    await screen.findByRole('button', { name: 'Add agent' })
    fireEvent.click(screen.getByRole('button', { name: 'Add agent' }))
    const dialog = screen.getByRole('dialog', { name: 'Add agent access' })
    const option = within(dialog).getByRole('option', { name: /agent-alpha/ })
    fireEvent.click(option)
    fireEvent.click(within(dialog).getByRole('button', { name: 'Add agent' }))

    expect(await within(dialog).findByRole('alert')).toHaveTextContent('Agent grant failed')
    expect(option).toHaveAttribute('aria-selected', 'true')
    expect(screen.getByRole('dialog', { name: 'Add agent access' })).toBeInTheDocument()
  })

  it('renders team agent loading skeleton rows in the shared table', () => {
    vi.mocked(api.getAdminTeamAgents).mockReturnValue(new Promise(() => {}))

    renderTeamDetails()

    const table = screen.getByRole('table')
    expect(within(table).getByRole('columnheader', { name: 'Agent' })).toBeInTheDocument()
    expect(within(table).getByRole('columnheader', { name: 'Agent ID' })).toBeInTheDocument()
    expect(within(table).getAllByRole('row')).toHaveLength(4)
  })

  // TASK-234: the member Agents tab must show the agent's display name
  // (spec.host) — e.g. a newly created or renamed agent — with the immutable
  // identifier as fallback when no display name exists.
  it('shows agent display names in the member Agents tab, falling back to the identifier', async () => {
    vi.mocked(api.getHosts).mockResolvedValue({
      items: [
        {
          metadata: { name: 'agent-alpha' },
          spec: { contextRef: 'ctx-alpha', host: 'Alpha Bot' },
        },
        { metadata: { name: 'agent-beta' }, spec: { contextRef: 'ctx-beta' } },
      ],
    })
    vi.mocked(api.getAdminUserContexts).mockResolvedValue({
      userId: 'user-1',
      contextIds: ['ctx-alpha', 'ctx-beta'],
    })
    vi.mocked(api.getAdminUserAgents).mockResolvedValue({
      userId: 'user-1',
      agentNames: ['agent-alpha', 'agent-beta'],
      deletedAgentNames: [],
      deletedHistoryLimit: 10,
    })

    renderUserDetails()

    expect(await screen.findByRole('button', { name: 'Alpha Bot' })).toBeInTheDocument()
    expect(screen.getByRole('button', { name: 'agent-beta' })).toBeInTheDocument()
    expect(screen.queryByRole('button', { name: 'agent-alpha' })).not.toBeInTheDocument()
  })

  // Review R1-H1: display names are not unique. Two agents sharing one display
  // name must stay distinguishable in the member Agents tab — slug visible as
  // secondary identity, action labels disambiguated — and revoking one row's
  // access must still target exactly that row's slug.
  it('distinguishes duplicate member agent display names by their slug', async () => {
    vi.mocked(api.getHosts).mockResolvedValue({
      items: [
        {
          metadata: { name: 'agent-dup-a' },
          spec: { contextRef: 'ctx-alpha', host: 'Duplicate Bot' },
        },
        {
          metadata: { name: 'agent-dup-b' },
          spec: { contextRef: 'ctx-beta', host: 'Duplicate Bot' },
        },
      ],
    })
    vi.mocked(api.getAdminUserContexts).mockResolvedValue({
      userId: 'user-1',
      contextIds: ['ctx-alpha', 'ctx-beta'],
    })
    vi.mocked(api.getAdminUserAgents).mockResolvedValue({
      userId: 'user-1',
      agentNames: ['agent-dup-a', 'agent-dup-b'],
      deletedAgentNames: [],
      deletedHistoryLimit: 10,
    })
    vi.mocked(api.updateAdminUserAgents).mockResolvedValue({
      userId: 'user-1',
      agentNames: ['agent-dup-b'],
      deletedAgentNames: ['agent-dup-a'],
      deletedHistoryLimit: 10,
    })
    vi.mocked(api.updateAdminUserContexts).mockResolvedValue({
      userId: 'user-1',
      contextIds: ['ctx-beta'],
    })

    renderUserDetails()

    // Same display name twice, each row carrying its own immutable slug.
    expect(await screen.findAllByRole('button', { name: 'Duplicate Bot' })).toHaveLength(2)
    expect(screen.getAllByText('agent-dup-a', { selector: '.cu-access-agent-id' })).toHaveLength(1)
    expect(screen.getAllByText('agent-dup-b', { selector: '.cu-access-agent-id' })).toHaveLength(1)

    // The action menu of the first row is labeled with its slug; revoking it
    // removes exactly agent-dup-a and keeps agent-dup-b.
    fireEvent.click(screen.getByRole('button', { name: 'Actions for Duplicate Bot (agent-dup-a)' }))
    fireEvent.click(screen.getByRole('menuitem', { name: 'Revoke access' }))
    const confirmDialog = await screen.findByRole('alertdialog')
    expect(confirmDialog).toHaveTextContent('agent-dup-a')
    fireEvent.click(confirmDialog.querySelector('.cu-btn--danger')!)

    await waitFor(() => {
      expect(api.updateAdminUserAgents).toHaveBeenCalledWith(
        'user-1',
        ['agent-dup-b'],
        expect.arrayContaining(['agent-dup-a', 'agent-dup-b'])
      )
    })
    expect(api.updateAdminUserContexts).toHaveBeenCalledWith('user-1', ['ctx-beta'])
  })
  // Same rename propagation on the team Agents tab.
  it('shows agent display names in the team Agents tab, falling back to the identifier', async () => {
    vi.mocked(api.getHosts).mockResolvedValue({
      items: [
        {
          metadata: { name: 'agent-alpha' },
          spec: { contextRef: 'ctx-alpha', host: 'Alpha Bot' },
        },
        { metadata: { name: 'agent-beta' }, spec: { contextRef: 'ctx-beta' } },
      ],
    })
    vi.mocked(api.getAdminTeamContexts).mockResolvedValue({
      teamId: 'team-1',
      contextIds: ['ctx-alpha', 'ctx-beta'],
    })
    vi.mocked(api.getAdminTeamAgents).mockResolvedValue({
      teamId: 'team-1',
      agentNames: ['agent-alpha', 'agent-beta'],
      deletedAgentNames: [],
      deletedHistoryLimit: 10,
    })

    renderTeamDetails()

    expect(await screen.findByRole('button', { name: 'Alpha Bot' })).toBeInTheDocument()
    expect(screen.getByRole('button', { name: 'agent-beta' })).toBeInTheDocument()
    expect(screen.queryByRole('button', { name: 'agent-alpha' })).not.toBeInTheDocument()
  })

  // Review R1-H1 on the team Agents tab: duplicate display names stay
  // distinguishable via the visible slug, and revoking one row targets
  // exactly that row's slug.
  it('distinguishes duplicate team agent display names by their slug', async () => {
    vi.mocked(api.getHosts).mockResolvedValue({
      items: [
        {
          metadata: { name: 'agent-dup-a' },
          spec: { contextRef: 'ctx-alpha', host: 'Duplicate Bot' },
        },
        {
          metadata: { name: 'agent-dup-b' },
          spec: { contextRef: 'ctx-beta', host: 'Duplicate Bot' },
        },
      ],
    })
    vi.mocked(api.getAdminTeamContexts).mockResolvedValue({
      teamId: 'team-1',
      contextIds: ['ctx-alpha', 'ctx-beta'],
    })
    vi.mocked(api.getAdminTeamAgents).mockResolvedValue({
      teamId: 'team-1',
      agentNames: ['agent-dup-a', 'agent-dup-b'],
      deletedAgentNames: [],
      deletedHistoryLimit: 10,
    })
    vi.mocked(api.updateAdminTeamAgents).mockResolvedValue({
      teamId: 'team-1',
      agentNames: ['agent-dup-b'],
      deletedAgentNames: ['agent-dup-a'],
      deletedHistoryLimit: 10,
    })
    vi.mocked(api.updateAdminTeamContexts).mockResolvedValue({
      teamId: 'team-1',
      contextIds: ['ctx-beta'],
    })

    renderTeamDetails()

    expect(await screen.findAllByRole('button', { name: 'Duplicate Bot' })).toHaveLength(2)
    expect(screen.getAllByText('agent-dup-a', { selector: '.cu-access-agent-id' })).toHaveLength(1)
    expect(screen.getAllByText('agent-dup-b', { selector: '.cu-access-agent-id' })).toHaveLength(1)

    fireEvent.click(
      screen.getByRole('button', { name: 'Actions for agent Duplicate Bot (agent-dup-a)' })
    )
    fireEvent.click(screen.getByRole('menuitem', { name: 'Revoke agent access' }))
    const confirmDialog = await screen.findByRole('alertdialog')
    expect(confirmDialog).toHaveTextContent('agent-dup-a')
    fireEvent.click(confirmDialog.querySelector('.cu-btn--danger')!)

    await waitFor(() => {
      expect(api.updateAdminTeamAgents).toHaveBeenCalledWith(
        'team-1',
        ['agent-dup-b'],
        expect.arrayContaining(['agent-dup-a', 'agent-dup-b'])
      )
    })
    expect(api.updateAdminTeamContexts).toHaveBeenCalledWith('team-1', ['ctx-beta'])
  })

  it('removes only owned Context grants when a member loses final agent access', async () => {
    vi.mocked(api.getAdminUserContexts)
      .mockResolvedValueOnce({ userId: 'user-1', contextIds: ['ctx-alpha', 'ctx-unrelated'] })
      .mockResolvedValueOnce({ userId: 'user-1', contextIds: ['ctx-alpha', 'ctx-unrelated'] })
    vi.mocked(api.getAdminUserAgents).mockResolvedValue({
      userId: 'user-1',
      agentNames: ['agent-alpha'],
      deletedAgentNames: [],
      deletedHistoryLimit: 10,
    })
    vi.mocked(api.updateAdminUserAgents).mockResolvedValue({
      userId: 'user-1',
      agentNames: [],
      deletedAgentNames: ['agent-alpha'],
      deletedHistoryLimit: 10,
    })
    vi.mocked(api.updateAdminUserContexts).mockResolvedValue({
      userId: 'user-1',
      contextIds: ['ctx-unrelated'],
    })

    renderUserDetails()

    await screen.findByRole('button', { name: 'Actions for agent-alpha' })
    fireEvent.click(screen.getByRole('button', { name: 'Actions for agent-alpha' }))
    fireEvent.click(screen.getByRole('menuitem', { name: 'Revoke access' }))
    fireEvent.click((await screen.findByRole('alertdialog')).querySelector('.cu-btn--danger')!)

    await waitFor(() => {
      expect(api.updateAdminUserAgents).toHaveBeenCalledWith('user-1', [], ['agent-alpha'])
    })
    expect(api.updateAdminUserContexts).toHaveBeenCalledWith('user-1', ['ctx-unrelated'])
  })

  it('renders and revokes a member Agent grant represented only by legacy Context access', async () => {
    vi.mocked(api.getAdminUserContexts)
      .mockResolvedValueOnce({ userId: 'user-1', contextIds: ['ctx-alpha', 'ctx-unrelated'] })
      .mockResolvedValueOnce({ userId: 'user-1', contextIds: ['ctx-alpha', 'ctx-unrelated'] })
    vi.mocked(api.getAdminUserAgents).mockResolvedValue({
      userId: 'user-1',
      agentNames: ['agent-beta'],
      deletedAgentNames: [],
      deletedHistoryLimit: 10,
    })
    vi.mocked(api.updateAdminUserAgents).mockResolvedValue({
      userId: 'user-1',
      agentNames: ['agent-beta'],
      deletedAgentNames: ['agent-alpha'],
      deletedHistoryLimit: 10,
    })
    vi.mocked(api.updateAdminUserContexts).mockResolvedValue({
      userId: 'user-1',
      contextIds: ['ctx-beta', 'ctx-unrelated'],
    })

    renderUserDetails()

    await screen.findByRole('button', { name: 'Actions for agent-alpha' })
    expect(screen.getByRole('button', { name: 'Actions for agent-beta' })).toBeInTheDocument()
    fireEvent.click(screen.getByRole('button', { name: 'Actions for agent-alpha' }))
    fireEvent.click(screen.getByRole('menuitem', { name: 'Revoke access' }))
    fireEvent.click((await screen.findByRole('alertdialog')).querySelector('.cu-btn--danger')!)

    await waitFor(() => {
      expect(api.updateAdminUserAgents).toHaveBeenCalledWith(
        'user-1',
        ['agent-beta'],
        ['agent-beta']
      )
    })
    expect(api.updateAdminUserContexts).toHaveBeenCalledWith('user-1', [
      'ctx-beta',
      'ctx-unrelated',
    ])
  })

  it('preserves a member legacy Context-only Agent when a direct Agent is revoked', async () => {
    vi.mocked(api.getAdminUserContexts)
      .mockResolvedValueOnce({ userId: 'user-1', contextIds: ['ctx-alpha', 'ctx-unrelated'] })
      .mockResolvedValueOnce({ userId: 'user-1', contextIds: ['ctx-alpha', 'ctx-unrelated'] })
    vi.mocked(api.getAdminUserAgents).mockResolvedValue({
      userId: 'user-1',
      agentNames: ['agent-beta'],
      deletedAgentNames: [],
      deletedHistoryLimit: 10,
    })
    vi.mocked(api.updateAdminUserAgents).mockResolvedValue({
      userId: 'user-1',
      agentNames: ['agent-alpha'],
      deletedAgentNames: ['agent-beta'],
      deletedHistoryLimit: 10,
    })
    vi.mocked(api.updateAdminUserContexts).mockResolvedValue({
      userId: 'user-1',
      contextIds: ['ctx-alpha', 'ctx-unrelated'],
    })

    renderUserDetails()

    await screen.findByRole('button', { name: 'Actions for agent-alpha' })
    fireEvent.click(screen.getByRole('button', { name: 'Actions for agent-beta' }))
    fireEvent.click(screen.getByRole('menuitem', { name: 'Revoke access' }))
    fireEvent.click((await screen.findByRole('alertdialog')).querySelector('.cu-btn--danger')!)

    await waitFor(() => {
      expect(api.updateAdminUserAgents).toHaveBeenCalledWith(
        'user-1',
        ['agent-alpha'],
        ['agent-beta']
      )
    })
    expect(api.updateAdminUserContexts).toHaveBeenCalledWith('user-1', [
      'ctx-alpha',
      'ctx-unrelated',
    ])
  })

  it('removes only owned Context grants when a team loses final agent access', async () => {
    vi.mocked(api.getAdminTeamContexts)
      .mockResolvedValueOnce({ teamId: 'team-1', contextIds: ['ctx-alpha', 'ctx-unrelated'] })
      .mockResolvedValueOnce({ teamId: 'team-1', contextIds: ['ctx-alpha', 'ctx-unrelated'] })
    vi.mocked(api.getAdminTeamAgents).mockResolvedValue({
      teamId: 'team-1',
      agentNames: ['agent-alpha'],
      deletedAgentNames: [],
      deletedHistoryLimit: 10,
    })
    vi.mocked(api.updateAdminTeamAgents).mockResolvedValue({
      teamId: 'team-1',
      agentNames: [],
      deletedAgentNames: ['agent-alpha'],
      deletedHistoryLimit: 10,
    })
    vi.mocked(api.updateAdminTeamContexts).mockResolvedValue({
      teamId: 'team-1',
      contextIds: ['ctx-unrelated'],
    })

    renderTeamDetails()

    await screen.findByRole('button', { name: 'Actions for agent agent-alpha' })
    fireEvent.click(screen.getByRole('button', { name: 'Actions for agent agent-alpha' }))
    fireEvent.click(screen.getByRole('menuitem', { name: 'Revoke agent access' }))
    fireEvent.click((await screen.findByRole('alertdialog')).querySelector('.cu-btn--danger')!)

    await waitFor(() => {
      expect(api.updateAdminTeamAgents).toHaveBeenCalledWith('team-1', [], ['agent-alpha'])
    })
    expect(api.updateAdminTeamContexts).toHaveBeenCalledWith('team-1', ['ctx-unrelated'])
  })

  it('renders and revokes a team Agent grant represented only by legacy Context access', async () => {
    vi.mocked(api.getAdminTeamContexts)
      .mockResolvedValueOnce({ teamId: 'team-1', contextIds: ['ctx-alpha', 'ctx-unrelated'] })
      .mockResolvedValueOnce({ teamId: 'team-1', contextIds: ['ctx-alpha', 'ctx-unrelated'] })
    vi.mocked(api.getAdminTeamAgents).mockResolvedValue({
      teamId: 'team-1',
      agentNames: ['agent-beta'],
      deletedAgentNames: [],
      deletedHistoryLimit: 10,
    })
    vi.mocked(api.updateAdminTeamAgents).mockResolvedValue({
      teamId: 'team-1',
      agentNames: ['agent-beta'],
      deletedAgentNames: ['agent-alpha'],
      deletedHistoryLimit: 10,
    })
    vi.mocked(api.updateAdminTeamContexts).mockResolvedValue({
      teamId: 'team-1',
      contextIds: ['ctx-beta', 'ctx-unrelated'],
    })

    renderTeamDetails()

    await screen.findByRole('button', { name: 'Actions for agent agent-alpha' })
    expect(screen.getByRole('button', { name: 'Actions for agent agent-beta' })).toBeInTheDocument()
    fireEvent.click(screen.getByRole('button', { name: 'Actions for agent agent-alpha' }))
    fireEvent.click(screen.getByRole('menuitem', { name: 'Revoke agent access' }))
    fireEvent.click((await screen.findByRole('alertdialog')).querySelector('.cu-btn--danger')!)

    await waitFor(() => {
      expect(api.updateAdminTeamAgents).toHaveBeenCalledWith(
        'team-1',
        ['agent-beta'],
        ['agent-beta']
      )
    })
    expect(api.updateAdminTeamContexts).toHaveBeenCalledWith('team-1', [
      'ctx-beta',
      'ctx-unrelated',
    ])
  })

  it('preserves a team legacy Context-only Agent when a direct Agent is revoked', async () => {
    vi.mocked(api.getAdminTeamContexts)
      .mockResolvedValueOnce({ teamId: 'team-1', contextIds: ['ctx-alpha', 'ctx-unrelated'] })
      .mockResolvedValueOnce({ teamId: 'team-1', contextIds: ['ctx-alpha', 'ctx-unrelated'] })
    vi.mocked(api.getAdminTeamAgents).mockResolvedValue({
      teamId: 'team-1',
      agentNames: ['agent-beta'],
      deletedAgentNames: [],
      deletedHistoryLimit: 10,
    })
    vi.mocked(api.updateAdminTeamAgents).mockResolvedValue({
      teamId: 'team-1',
      agentNames: ['agent-alpha'],
      deletedAgentNames: ['agent-beta'],
      deletedHistoryLimit: 10,
    })
    vi.mocked(api.updateAdminTeamContexts).mockResolvedValue({
      teamId: 'team-1',
      contextIds: ['ctx-alpha', 'ctx-unrelated'],
    })

    renderTeamDetails()

    await screen.findByRole('button', { name: 'Actions for agent agent-alpha' })
    fireEvent.click(screen.getByRole('button', { name: 'Actions for agent agent-beta' }))
    fireEvent.click(screen.getByRole('menuitem', { name: 'Revoke agent access' }))
    fireEvent.click((await screen.findByRole('alertdialog')).querySelector('.cu-btn--danger')!)

    await waitFor(() => {
      expect(api.updateAdminTeamAgents).toHaveBeenCalledWith(
        'team-1',
        ['agent-alpha'],
        ['agent-beta']
      )
    })
    expect(api.updateAdminTeamContexts).toHaveBeenCalledWith('team-1', [
      'ctx-alpha',
      'ctx-unrelated',
    ])
  })
})