Skip to content

A platform for community discussion. Free, open, simple.

51.5 KB
Raw Blame
# frozen_string_literal: true

describe "MCP group tools" do
  fab!(:user) { Fabricate(:user, refresh_auto_groups: true) }
  fab!(:scope_group, :group)

  before do
    SiteSetting.mcp_server_enabled = true
    scope_group.add(user)
  end

  def authorize(*extra_scopes, auth_user: user)
    scope_group.add(auth_user)
    scopes = [DiscourseMcp::INITIAL_SCOPE, *extra_scopes]
    scopes.each { |scope| McpGroupScope.find_or_create_by!(group: scope_group, scope:) }
    client =
      McpOauthClient.create!(
        client_id: SecureRandom.hex,
        name: "Group tool test client",
        registration_type: "pre_registered",
        trust_state: "approved",
        redirect_uris: ["http://127.0.0.1/callback"],
      )
    authorization =
      DiscourseMcp::OAuth::AuthorizationGrant.create!(
        user: auth_user,
        client:,
        redirect_uri: client.redirect_uris.first,
        requested_scopes: scopes,
      )
    @token = McpOauthAccessToken.issue!(authorization:)
  end

  def call_tool(name, arguments = {})
    McpPrimitive.find_or_create_by!(kind: "tool", identifier: name) do |primitive|
      primitive.enabled = true
    end
    post "/mcp",
         params: {
           jsonrpc: "2.0",
           id: 1,
           method: "tools/call",
           params: {
             name:,
             arguments:,
           },
         }.to_json,
         headers: {
           "HTTP_AUTHORIZATION" => "Bearer #{@token}",
           "CONTENT_TYPE" => "application/json",
           "HTTP_ACCEPT" => "application/json, text/event-stream",
           "HTTP_MCP_PROTOCOL_VERSION" => DiscourseMcp::LEGACY_PROTOCOL_VERSION,
         }
  end

  def structured_content
    response.parsed_body.dig("result", "structuredContent")
  end

  def make_owner(group, owner)
    group.add(owner)
    group.group_users.find_by!(user: owner).update!(owner: true)
  end

  it "requires the group read scope" do
    authorize

    {
      "discourse_list_groups" => {
      },
      "discourse_get_group" => {
        id: 1,
      },
      "discourse_list_group_members" => {
        name: "group",
      },
      "discourse_list_group_membership_requests" => {
        name: "group",
      },
      "discourse_list_group_posts" => {
        name: "group",
      },
    }.each do |name, arguments|
      call_tool(name, arguments)
      aggregate_failures(name) do
        expect(response.status).to eq(403)
        expect(response.headers["WWW-Authenticate"]).to include(
          'error="insufficient_scope"',
          'scope="mcp:groups:read"',
        )
      end
    end
  end

  it "lists only groups visible to the user" do
    visible_group = Fabricate(:group, visibility_level: Group.visibility_levels[:public])
    hidden_group = Fabricate(:group, visibility_level: Group.visibility_levels[:owners])
    make_owner(hidden_group, Fabricate(:user))
    authorize("mcp:groups:read")

    call_tool("discourse_list_groups", { limit: 100 })

    expect(response.status).to eq(200)
    expect(structured_content["groups"].pluck("id")).to include(visible_group.id)
    expect(structured_content["groups"].pluck("id")).not_to include(hidden_group.id)
  end

  it "does not expose member counts when group membership is private" do
    group =
      Fabricate(
        :group,
        visibility_level: Group.visibility_levels[:public],
        members_visibility_level: Group.visibility_levels[:owners],
      )
    group.add(Fabricate(:user))
    authorize("mcp:groups:read")

    call_tool("discourse_list_groups", { limit: 100 })

    group_json = structured_content["groups"].find { |item| item["id"] == group.id }
    expect(group_json["can_see_members"]).to eq(false)
    expect(group_json["user_count"]).to be_nil
  end

  it "does not expose private member counts through group ordering" do
    prefix = "pc#{SecureRandom.hex(3)}"
    small_group =
      Fabricate(
        :group,
        name: "#{prefix}_a",
        visibility_level: Group.visibility_levels[:public],
        members_visibility_level: Group.visibility_levels[:owners],
      )
    small_group.add(Fabricate(:user))
    large_group =
      Fabricate(
        :group,
        name: "#{prefix}_z",
        visibility_level: Group.visibility_levels[:public],
        members_visibility_level: Group.visibility_levels[:owners],
      )
    3.times { large_group.add(Fabricate(:user)) }
    authorize("mcp:groups:read")

    call_tool("discourse_list_groups", { filter: prefix, order: "user_count", ascending: false })

    expect(structured_content["groups"].pluck("id")).to eq([small_group.id, large_group.id])
  end

  it "respects the group directory site setting" do
    SiteSetting.enable_group_directory = false
    authorize("mcp:groups:read")

    call_tool("discourse_list_groups")
    expect(response.status).to eq(403)

    moderator = Fabricate(:moderator, refresh_auto_groups: true)
    authorize("mcp:groups:read", auth_user: moderator)
    call_tool("discourse_list_groups")
    expect(response.status).to eq(200)
  end

  it "does not reveal a hidden group when the token has scope but the user lacks access" do
    hidden_group = Fabricate(:group, visibility_level: Group.visibility_levels[:owners])
    make_owner(hidden_group, Fabricate(:user))
    authorize("mcp:groups:read")

    call_tool("discourse_get_group", { id: hidden_group.id })

    expect(response.status).to eq(200)
    expect(response.parsed_body.dig("result", "isError")).to eq(true)
    expect(response.body).not_to include(hidden_group.name)
  end

  it "returns the safe group fields exposed by the existing group API" do
    group =
      Fabricate(
        :group,
        visibility_level: Group.visibility_levels[:public],
        title: "Group title",
        full_name: "Group full name",
        bio_raw: "Group biography",
        membership_request_template: "Tell us why you want to join",
      )
    sign_in(user)
    get "/groups/#{group.name}.json"
    api_group = response.parsed_body.fetch("group")
    authorize("mcp:groups:read")

    call_tool("discourse_get_group", { id: group.id })

    fields = %w[
      primary_group
      grant_trust_level
      flair_url
      flair_bg_color
      flair_color
      bio_cooked
      default_notification_level
      membership_request_template
      publish_read_state
      mentionable
      messageable
    ]
    expect(structured_content.fetch("group").slice(*fields)).to eq(api_group.slice(*fields))
  end

  it "gets an automatic group that the existing group API allows the user to see" do
    automatic_group = Group[:trust_level_0]
    authorize("mcp:groups:read")

    call_tool("discourse_get_group", { id: automatic_group.id })

    expect(response.status).to eq(200)
    expect(structured_content.dig("group", "id")).to eq(automatic_group.id)
  end

  it "does not return group email credentials" do
    secret = "mcp-group-secret-#{SecureRandom.hex}"
    group = Fabricate(:group, visibility_level: Group.visibility_levels[:public])
    group.update_columns(
      incoming_email: "mcp-#{SecureRandom.hex}@example.com",
      email_username: "mcp-user-#{SecureRandom.hex}",
      email_password: secret,
    )
    admin = Fabricate(:admin, refresh_auto_groups: true)
    authorize("mcp:groups:read", auth_user: admin)

    call_tool("discourse_get_group", { id: group.id })

    expect(response.status).to eq(200)
    expect(structured_content.dig("group", "id")).to eq(group.id)
    expect(response.body).not_to include(secret, group.incoming_email, group.email_username)
  end

  it "does not add membership queries for each listed group" do
    Fabricate(:group, visibility_level: Group.visibility_levels[:public])
    authorize("mcp:groups:read")

    initial_queries =
      track_sql_queries { call_tool("discourse_list_groups", { limit: 100 }) }.grep(/group_users/i)
    5.times { Fabricate(:group, visibility_level: Group.visibility_levels[:public]) }
    expanded_queries =
      track_sql_queries { call_tool("discourse_list_groups", { limit: 100 }) }.grep(/group_users/i)

    expect(expanded_queries.size).to be <= initial_queries.size
  end

  it "applies group directory query modifiers" do
    visible_group = Fabricate(:group, visibility_level: Group.visibility_levels[:public])
    filtered_group = Fabricate(:group, visibility_level: Group.visibility_levels[:public])
    plugin = Plugin::Instance.new
    modifier = proc { |groups| groups.where.not(id: filtered_group.id) }
    plugin.register_modifier(:groups_index_query, &modifier)
    authorize("mcp:groups:read")

    call_tool("discourse_list_groups", { limit: 100 })

    expect(structured_content["groups"].pluck("id")).to include(visible_group.id)
    expect(structured_content["groups"].pluck("id")).not_to include(filtered_group.id)
  ensure
    DiscoursePluginRegistry.unregister_modifier(plugin, :groups_index_query, &modifier) if plugin
  end

  it "keeps membership queries bounded for moderators managing owner-visible groups" do
    SiteSetting.moderators_manage_groups = true
    moderator = Fabricate(:moderator, refresh_auto_groups: true)
    group = Fabricate(:group, visibility_level: Group.visibility_levels[:owners])
    make_owner(group, moderator)
    authorize("mcp:groups:read", auth_user: moderator)

    initial_queries =
      track_sql_queries { call_tool("discourse_list_groups", { limit: 100 }) }.grep(/group_users/i)
    expect(structured_content["groups"]).to include(
      include("id" => group.id, "can_admin_group" => true, "can_edit_group" => true),
    )

    5.times do
      owned_group = Fabricate(:group, visibility_level: Group.visibility_levels[:owners])
      make_owner(owned_group, moderator)
    end
    expanded_queries =
      track_sql_queries { call_tool("discourse_list_groups", { limit: 100 }) }.grep(/group_users/i)

    expect(response.status).to eq(200)
    expect(expanded_queries.size).to be <= initial_queries.size
  end

  it "preserves the difference between moderator and administrator visibility" do
    hidden_group = Fabricate(:group, visibility_level: Group.visibility_levels[:owners])
    make_owner(hidden_group, Fabricate(:user))
    moderator = Fabricate(:moderator, refresh_auto_groups: true)
    authorize("mcp:groups:read", auth_user: moderator)

    call_tool("discourse_get_group", { id: hidden_group.id })
    expect(response.parsed_body.dig("result", "isError")).to eq(true)

    admin = Fabricate(:admin, refresh_auto_groups: true)
    authorize("mcp:groups:read", auth_user: admin)
    call_tool("discourse_get_group", { id: hidden_group.id })

    expect(response.status).to eq(200)
    expect(structured_content.dig("group", "id")).to eq(hidden_group.id)
  end

  it "does not list private members when the token has scope but the user lacks access" do
    public_group =
      Fabricate(
        :group,
        visibility_level: Group.visibility_levels[:public],
        members_visibility_level: Group.visibility_levels[:public],
      )
    visible_member = Fabricate(:user)
    public_group.add(visible_member)
    private_group =
      Fabricate(
        :group,
        visibility_level: Group.visibility_levels[:public],
        members_visibility_level: Group.visibility_levels[:owners],
      )
    private_member = Fabricate(:user)
    private_group.add(private_member)
    authorize("mcp:groups:read")

    call_tool("discourse_list_group_members", { name: public_group.name })
    expect(structured_content["members"].pluck("username")).to include(visible_member.username)

    call_tool("discourse_list_group_members", { name: private_group.name })
    expect(response.status).to eq(403)
    expect(response.body).not_to include(private_member.username)
  end

  it "hides activity timestamps for members whose profiles are hidden" do
    SiteSetting.allow_users_to_hide_profile = true
    public_group =
      Fabricate(
        :group,
        visibility_level: Group.visibility_levels[:public],
        members_visibility_level: Group.visibility_levels[:public],
      )
    hidden_member = Fabricate(:user, last_seen_at: 1.hour.ago, last_posted_at: 2.hours.ago)
    hidden_member.user_option.update!(hide_profile: true)
    visible_member = Fabricate(:user, last_seen_at: 3.hours.ago, last_posted_at: 4.hours.ago)
    public_group.add(hidden_member)
    public_group.add(visible_member)
    user.update!(trust_level: TrustLevel[2])
    authorize("mcp:groups:read")

    call_tool("discourse_list_group_members", { name: public_group.name })

    members = structured_content["members"]
    hidden_member_json = members.find { |member| member["id"] == hidden_member.id }
    visible_member_json = members.find { |member| member["id"] == visible_member.id }
    expect(hidden_member_json).not_to include("last_seen_at", "last_posted_at")
    expect(visible_member_json).to include("last_seen_at", "last_posted_at")
  end

  it "uses the existing group API filtering rules for members" do
    group =
      Fabricate(
        :group,
        visibility_level: Group.visibility_levels[:public],
        members_visibility_level: Group.visibility_levels[:public],
      )
    first_member = Fabricate(:user)
    second_member = Fabricate(:user)
    group.add(first_member)
    group.add(second_member)
    authorize("mcp:groups:read")

    call_tool(
      "discourse_list_group_members",
      { name: group.name, filter: "#{first_member.username},#{second_member.username}" },
    )

    expect(structured_content["members"].pluck("username")).to contain_exactly(
      first_member.username,
      second_member.username,
    )

    call_tool("discourse_list_group_members", { name: group.name, filter: first_member.email })
    expect(structured_content["members"]).to be_empty

    admin = Fabricate(:admin, refresh_auto_groups: true)
    authorize("mcp:groups:read", auth_user: admin)
    call_tool("discourse_list_group_members", { name: group.name, filter: first_member.email })

    expect(structured_content["members"].pluck("username")).to contain_exactly(
      first_member.username,
    )
  end

  it "requires group management permission even when the token has scope" do
    managed_group = Fabricate(:group, visibility_level: Group.visibility_levels[:public])
    make_owner(managed_group, user)
    managed_group.update!(allow_membership_requests: true)
    requester = Fabricate(:user)
    request = Fabricate(:group_request, group: managed_group, user: requester)
    authorize("mcp:groups:read")

    call_tool("discourse_list_group_membership_requests", { name: managed_group.name })
    expect(structured_content["requests"]).to contain_exactly(
      include("username" => requester.username, "reason" => request.reason),
    )

    unmanaged_group = Fabricate(:group, visibility_level: Group.visibility_levels[:public])
    make_owner(unmanaged_group, Fabricate(:user))
    unmanaged_group.update!(allow_membership_requests: true)
    hidden_request = Fabricate(:group_request, group: unmanaged_group)
    call_tool("discourse_list_group_membership_requests", { name: unmanaged_group.name })

    expect(response.status).to eq(403)
    expect(response.body).not_to include(hidden_request.reason)
  end

  it "uses the existing group API filtering rules for membership requests" do
    group = Fabricate(:group, visibility_level: Group.visibility_levels[:public])
    make_owner(group, user)
    first_request = Fabricate(:group_request, group:)
    second_request = Fabricate(:group_request, group:)
    authorize("mcp:groups:read")

    call_tool(
      "discourse_list_group_membership_requests",
      {
        name: group.name,
        filter: "#{first_request.user.username},#{second_request.user.username}",
      },
    )

    expect(structured_content["requests"].pluck("username")).to contain_exactly(
      first_request.user.username,
      second_request.user.username,
    )

    admin = Fabricate(:admin, refresh_auto_groups: true)
    authorize("mcp:groups:read", auth_user: admin)
    call_tool(
      "discourse_list_group_membership_requests",
      { name: group.name, filter: first_request.user.email },
    )

    expect(structured_content["requests"].pluck("username")).to contain_exactly(
      first_request.user.username,
    )
  end

  it "lists only group posts visible to the user" do
    author_group =
      Fabricate(
        :group,
        visibility_level: Group.visibility_levels[:public],
        members_visibility_level: Group.visibility_levels[:public],
      )
    author = Fabricate(:user)
    author_group.add(author)
    public_post = Fabricate(:post, user: author)
    private_category = Fabricate(:private_category, group: Fabricate(:group))
    private_post =
      Fabricate(:post, user: author, topic: Fabricate(:topic, category: private_category))
    private_message = Fabricate(:private_message_post, user: author)
    authorize("mcp:groups:read")

    call_tool("discourse_list_group_posts", { name: author_group.name })

    expect(structured_content["posts"].pluck("id")).to include(public_post.id)
    expect(structured_content["posts"].pluck("id")).not_to include(private_post.id)
    expect(structured_content["posts"].pluck("id")).not_to include(private_message.id)
  end

  it "paginates group posts when IDs and creation times have different orders" do
    group =
      Fabricate(
        :group,
        visibility_level: Group.visibility_levels[:public],
        members_visibility_level: Group.visibility_levels[:public],
      )
    author = Fabricate(:user)
    group.add(author)
    newest_post = Fabricate(:post, user: author, created_at: 1.day.ago)
    shared_created_at = 2.days.ago
    lower_id_post = Fabricate(:post, user: author, created_at: shared_created_at)
    higher_id_post = Fabricate(:post, user: author, created_at: shared_created_at)
    authorize("mcp:groups:read")

    call_tool("discourse_list_group_posts", { name: group.name, limit: 1 })

    expect(structured_content["posts"].pluck("id")).to eq([newest_post.id])
    expect(structured_content.dig("meta", "has_more")).to eq(true)
    cursor = structured_content.dig("meta", "next_before_post_id")

    call_tool("discourse_list_group_posts", { name: group.name, limit: 1, before_post_id: cursor })

    expect(structured_content["posts"].pluck("id")).to eq([higher_id_post.id])
    expect(structured_content.dig("meta", "has_more")).to eq(true)

    cursor = structured_content.dig("meta", "next_before_post_id")
    call_tool("discourse_list_group_posts", { name: group.name, limit: 1, before_post_id: cursor })

    expect(structured_content["posts"].pluck("id")).to eq([lower_id_post.id])
    expect(structured_content.dig("meta", "has_more")).to eq(false)
  end

  it "rejects multiple group post cursors" do
    group =
      Fabricate(
        :group,
        visibility_level: Group.visibility_levels[:public],
        members_visibility_level: Group.visibility_levels[:public],
      )
    authorize("mcp:groups:read")

    call_tool(
      "discourse_list_group_posts",
      { name: group.name, before_post_id: 1, before: 1.day.ago.iso8601 },
    )

    expect(response.status).to eq(200)
    expect(response.parsed_body.dig("result", "isError")).to eq(true)
    expect(response.body).to include(I18n.t("mcp.errors.group_post_single_cursor"))
  end

  it "does not list group posts when the token has scope but the user cannot see members" do
    group =
      Fabricate(
        :group,
        visibility_level: Group.visibility_levels[:public],
        members_visibility_level: Group.visibility_levels[:owners],
      )
    author = Fabricate(:user)
    group.add(author)
    post = Fabricate(:post, user: author)
    authorize("mcp:groups:read")

    call_tool("discourse_list_group_posts", { name: group.name })

    expect(response.status).to eq(403)
    expect(response.body).not_to include(post.topic.title)
  end

  describe "write tools" do
    fab!(:group)
    fab!(:member, :user)

    def tool_error
      response.parsed_body.dig("result", "content", 0, "text")
    end

    it "requires the group write scope" do
      authorize("mcp:groups:read")

      {
        "discourse_create_group" => {
          name: "new-group",
        },
        "discourse_update_group" => {
          group_id: group.id,
          bio_raw: "hi",
        },
        "discourse_delete_group" => {
          group_id: group.id,
          expected_name: group.name,
          confirm: true,
        },
        "discourse_manage_group_members" => {
          group_id: group.id,
          action: "add",
          usernames: [member.username],
        },
        "discourse_invite_group_members" => {
          group_id: group.id,
          emails: ["[email protected]"],
        },
        "discourse_manage_group_owners" => {
          group_id: group.id,
          action: "add",
          usernames: [member.username],
        },
        "discourse_manage_group_membership" => {
          group_id: group.id,
          action: "join",
        },
        "discourse_handle_group_membership_request" => {
          group_id: group.id,
          username: member.username,
          action: "approve",
        },
      }.each do |name, arguments|
        call_tool(name, arguments)
        aggregate_failures(name) do
          expect(response.status).to eq(403)
          expect(response.headers["WWW-Authenticate"]).to include(
            'error="insufficient_scope"',
            'scope="mcp:groups:write"',
          )
        end
      end
    end

    it "denies every management tool when the token has scope but the user has no group rights" do
      authorize("mcp:groups:write")

      {
        "discourse_create_group" => {
          name: "new-group",
        },
        "discourse_update_group" => {
          group_id: group.id,
          bio_raw: "hi",
        },
        "discourse_delete_group" => {
          group_id: group.id,
          expected_name: group.name,
          confirm: true,
        },
        "discourse_manage_group_members" => {
          group_id: group.id,
          action: "add",
          usernames: [member.username],
        },
        "discourse_invite_group_members" => {
          group_id: group.id,
          emails: ["[email protected]"],
        },
        "discourse_manage_group_owners" => {
          group_id: group.id,
          action: "add",
          usernames: [member.username],
        },
        "discourse_handle_group_membership_request" => {
          group_id: group.id,
          username: member.username,
          action: "approve",
        },
      }.each do |name, arguments|
        call_tool(name, arguments)
        aggregate_failures(name) { expect(response.status).to eq(403) }
      end

      expect(Group.exists?(group.id)).to eq(true)
      expect(group.reload.users).not_to include(member)
    end

    it "does not reveal groups the user cannot see" do
      hidden = Fabricate(:group, visibility_level: Group.visibility_levels[:owners])
      make_owner(hidden, Fabricate(:user))
      authorize("mcp:groups:write")

      call_tool("discourse_update_group", { group_id: hidden.id, bio_raw: "hi" })

      expect(response.status).to eq(200)
      expect(tool_error).to eq(I18n.t("mcp.errors.group_not_found"))
    end

    describe "discourse_create_group" do
      it "creates a group with owners and members for an admin" do
        admin = Fabricate(:admin, refresh_auto_groups: true)
        authorize("mcp:groups:write", auth_user: admin)

        call_tool(
          "discourse_create_group",
          {
            name: "docs-team",
            full_name: "Documentation 猫",
            visibility_level: Group.visibility_levels[:logged_on_users],
            owner_usernames: [member.username],
          },
        )

        expect(response.status).to eq(200)
        created = Group.find(structured_content["id"])
        expect(created.name).to eq("docs-team")
        expect(created.full_name).to eq("Documentation 猫")
        expect(created.visibility_level).to eq(Group.visibility_levels[:logged_on_users])
        expect(created.group_users.find_by(user: member).owner).to eq(true)
      end

      it "creates a group with a unicode name when unicode usernames are enabled" do
        SiteSetting.unicode_usernames = true
        admin = Fabricate(:admin, refresh_auto_groups: true)
        authorize("mcp:groups:write", auth_user: admin)

        call_tool("discourse_create_group", { name: "docs-猫" })

        expect(response.status).to eq(200)
        expect(Group.find(structured_content["id"]).name).to eq("docs-猫")
      end

      it "lets a moderator create a group only when moderators manage groups" do
        moderator = Fabricate(:moderator, refresh_auto_groups: true)
        authorize("mcp:groups:write", auth_user: moderator)

        call_tool("discourse_create_group", { name: "mod-group" })
        expect(response.status).to eq(403)

        SiteSetting.moderators_manage_groups = true
        call_tool("discourse_create_group", { name: "mod-group" })
        expect(response.status).to eq(200)
      end

      it "reports validation errors without creating a group" do
        admin = Fabricate(:admin, refresh_auto_groups: true)
        authorize("mcp:groups:write", auth_user: admin)

        expect { call_tool("discourse_create_group", { name: group.name }) }.not_to change {
          Group.count
        }
        expect(response.parsed_body.dig("result", "isError")).to eq(true)
      end

      it "rejects fields the tool does not expose" do
        admin = Fabricate(:admin, refresh_auto_groups: true)
        authorize("mcp:groups:write", auth_user: admin)

        call_tool("discourse_create_group", { name: "smtp-group", smtp_server: "evil.example.com" })

        expect(response.parsed_body.dig("error", "code")).to eq(-32_602)
      end
    end

    describe "discourse_update_group" do
      it "applies only existing categories to group and member notification defaults" do
        category = Fabricate(:category)
        missing_id = Category.maximum(:id) + 1
        make_owner(group, user)
        authorize("mcp:groups:write")

        call_tool(
          "discourse_update_group",
          {
            group_id: group.id,
            watching_category_ids: [category.id, missing_id],
            update_existing_users: true,
          },
        )

        expect(response.status).to eq(200)
        expect(response.parsed_body.dig("result", "isError")).to eq(false)
        expect(group.reload.group_category_notification_defaults.pluck(:category_id)).to eq(
          [category.id],
        )
        expect(CategoryUser.where(user:).pluck(:category_id, :notification_level)).to eq(
          [[category.id, NotificationLevels.all[:watching]]],
        )
      end

      it "rejects conflicting tag levels including synonyms before changing the group or its members" do
        tag = Fabricate(:tag)
        synonym = Fabricate(:tag, target_tag: tag)
        make_owner(group, user)
        group.update!(watching_tags: [tag.name])
        original_bio = group.bio_raw
        TagUser.change(user.id, tag.id, NotificationLevels.all[:watching])
        authorize("mcp:groups:write")

        [tag.name, synonym.name.upcase].each do |name|
          call_tool(
            "discourse_update_group",
            {
              group_id: group.id,
              bio_raw: "Must not be saved",
              watching_tags: [tag.name],
              tracking_tags: [name],
              update_existing_users: true,
            },
          )

          expect(response.parsed_body.dig("result", "isError")).to eq(true)
          expect(tool_error).to eq(I18n.t("groups.errors.conflicting_notification_defaults"))
          expect(group.reload.bio_raw).to eq(original_bio)
          expect(group.group_tag_notification_defaults.pluck(:tag_id, :notification_level)).to eq(
            [[tag.id, NotificationLevels.all[:watching]]],
          )
          expect(TagUser.find_by!(user:, tag:).notification_level).to eq(
            NotificationLevels.all[:watching],
          )
        end
      end

      it "rejects conflicting category levels even when existing members would be left alone" do
        category = Fabricate(:category)
        make_owner(group, user)
        authorize("mcp:groups:write")

        call_tool(
          "discourse_update_group",
          {
            group_id: group.id,
            watching_category_ids: [category.id],
            muted_category_ids: [category.id],
            update_existing_users: false,
          },
        )

        expect(response.parsed_body.dig("result", "isError")).to eq(true)
        expect(tool_error).to eq(I18n.t("groups.errors.conflicting_notification_defaults"))
        expect(group.reload.group_category_notification_defaults).to be_empty
        expect(CategoryUser.where(user:, category:)).to be_empty
      end

      it "moves a tag default and matching member preferences with a partial update" do
        tag = Fabricate(:tag)
        make_owner(group, user)
        group.update!(tracking_tags: [tag.name])
        TagUser.change(user.id, tag.id, NotificationLevels.all[:tracking])
        group.add(member)
        TagUser.change(member.id, tag.id, NotificationLevels.all[:muted])
        authorize("mcp:groups:write")

        call_tool(
          "discourse_update_group",
          { group_id: group.id, watching_tags: [tag.name], update_existing_users: true },
        )

        expect(response.status).to eq(200)
        expect(response.parsed_body.dig("result", "isError")).not_to eq(true)
        expect(
          group.reload.group_tag_notification_defaults.pluck(:tag_id, :notification_level),
        ).to eq([[tag.id, NotificationLevels.all[:watching]]])
        expect(TagUser.find_by!(user:, tag:).notification_level).to eq(
          NotificationLevels.all[:watching],
        )
        expect(TagUser.find_by!(user: member, tag:).notification_level).to eq(
          NotificationLevels.all[:muted],
        )
        newcomer = Fabricate(:user)
        group.add(newcomer)
        expect(TagUser.find_by!(user: newcomer, tag:).notification_level).to eq(
          NotificationLevels.all[:watching],
        )
      end

      it "applies mixed-case tag names and synonyms to the canonical tags for members" do
        tag = Fabricate(:tag, name: "release-猫")
        target = Fabricate(:tag)
        synonym = Fabricate(:tag, target_tag: target)
        make_owner(group, user)
        authorize("mcp:groups:write")

        call_tool(
          "discourse_update_group",
          {
            group_id: group.id,
            watching_tags: [tag.name.upcase, synonym.name, target.name],
            update_existing_users: true,
          },
        )

        expect(response.status).to eq(200)
        expect(response.parsed_body.dig("result", "isError")).not_to eq(true)
        expect(group.reload.group_tag_notification_defaults.pluck(:tag_id)).to contain_exactly(
          tag.id,
          target.id,
        )
        expect(TagUser.where(user:).pluck(:tag_id, :notification_level)).to contain_exactly(
          [tag.id, NotificationLevels.all[:watching]],
          [target.id, NotificationLevels.all[:watching]],
        )
      end

      it "preserves omitted notification defaults when editing the profile" do
        category = Fabricate(:category)
        tag = Fabricate(:tag)
        make_owner(group, user)
        group.update!(watching_category_ids: [category.id], tracking_tags: [tag.name])
        group.add(member)
        CategoryUser.set_notification_level_for_category(
          member,
          NotificationLevels.all[:watching],
          category.id,
        )
        TagUser.change(member.id, tag.id, NotificationLevels.all[:tracking])
        authorize("mcp:groups:write")

        [nil, true].each do |choice|
          arguments = { group_id: group.id, bio_raw: "Updated bio 猫" }
          arguments[:update_existing_users] = choice unless choice.nil?
          call_tool("discourse_update_group", arguments)

          expect(response.parsed_body.dig("result", "isError")).not_to eq(true)
          expect(CategoryUser.find_by(user: member, category:)&.notification_level).to eq(
            NotificationLevels.all[:watching],
          )
          expect(TagUser.find_by(user: member, tag:)&.notification_level).to eq(
            NotificationLevels.all[:tracking],
          )
        end
        expect(group.reload.bio_raw).to eq("Updated bio 猫")
      end

      it "lets a group owner change the profile but ignores staff-only fields" do
        make_owner(group, user)
        original_name = group.name
        authorize("mcp:groups:write")

        call_tool(
          "discourse_update_group",
          { group_id: group.id, bio_raw: "We write docs 猫", name: "renamed" },
        )

        expect(response.status).to eq(200)
        group.reload
        expect(group.bio_raw).to eq("We write docs 猫")
        expect(group.name).to eq(original_name)
      end

      it "requires at least one field the user may change" do
        make_owner(group, user)
        authorize("mcp:groups:write")

        call_tool("discourse_update_group", { group_id: group.id, name: "renamed" })

        expect(tool_error).to eq(I18n.t("mcp.errors.group_update_required"))
      end

      it "asks for confirmation before changing notification defaults of existing members" do
        admin = Fabricate(:admin, refresh_auto_groups: true)
        category = Fabricate(:category)
        group.add(member)
        authorize("mcp:groups:write", auth_user: admin)

        call_tool(
          "discourse_update_group",
          { group_id: group.id, watching_category_ids: [category.id] },
        )

        expect(response.parsed_body.dig("result", "isError")).to eq(true)
        expect(tool_error).to eq(
          I18n.t("mcp.errors.group_update_existing_users_required", count: 1),
        )
        expect(CategoryUser.where(user: member, category:)).to be_empty

        call_tool(
          "discourse_update_group",
          { group_id: group.id, watching_category_ids: [category.id], update_existing_users: true },
        )

        expect(response.status).to eq(200)
        expect(CategoryUser.find_by(user: member, category:).notification_level).to eq(
          NotificationLevels.all[:watching],
        )
      end
    end

    describe "discourse_delete_group" do
      fab!(:admin) { Fabricate(:admin, refresh_auto_groups: true) }

      it "deletes a group for an admin after confirmation" do
        authorize("mcp:groups:write", auth_user: admin)

        call_tool(
          "discourse_delete_group",
          { group_id: group.id, expected_name: group.name, confirm: true },
        )

        expect(response.status).to eq(200)
        expect(structured_content).to eq("deleted" => true, "group_id" => group.id)
        expect(Group.exists?(group.id)).to eq(false)
      end

      it "refuses without confirmation or with the wrong name" do
        authorize("mcp:groups:write", auth_user: admin)

        call_tool(
          "discourse_delete_group",
          { group_id: group.id, expected_name: group.name, confirm: false },
        )
        expect(tool_error).to eq(I18n.t("mcp.errors.group_delete_confirmation_required"))

        call_tool(
          "discourse_delete_group",
          { group_id: group.id, expected_name: "wrong", confirm: true },
        )
        expect(tool_error).to eq(I18n.t("mcp.errors.group_delete_name_mismatch"))
        expect(Group.exists?(group.id)).to eq(true)
      end

      it "refuses an automatic group" do
        authorize("mcp:groups:write", auth_user: admin)
        automatic = Group.find(Group::AUTO_GROUPS[:trust_level_1])

        call_tool(
          "discourse_delete_group",
          { group_id: automatic.id, expected_name: automatic.name, confirm: true },
        )

        expect(tool_error).to eq(I18n.t("groups.errors.can_not_modify_automatic"))
        expect(Group.exists?(automatic.id)).to eq(true)
      end

      it "refuses a moderator who may otherwise manage groups" do
        SiteSetting.moderators_manage_groups = true
        moderator = Fabricate(:moderator, refresh_auto_groups: true)
        make_owner(group, moderator)
        authorize("mcp:groups:write", auth_user: moderator)

        call_tool(
          "discourse_delete_group",
          { group_id: group.id, expected_name: group.name, confirm: true },
        )

        expect(response.status).to eq(403)
        expect(Group.exists?(group.id)).to eq(true)
      end
    end

    describe "discourse_manage_group_members" do
      before { make_owner(group, user) }

      it "rejects conflicting selectors without changing members or owners" do
        authorize("mcp:groups:write")
        %w[discourse_manage_group_members discourse_manage_group_owners].each do |tool|
          expect do
            call_tool(
              tool,
              {
                group_id: group.id,
                action: "add",
                usernames: [member.username],
                user_ids: [user.id],
              },
            )
          end.not_to change { group.group_users.count }

          expect(response.parsed_body.dig("result", "isError")).to eq(true)
          expect(tool_error).to eq(I18n.t("mcp.errors.group_member_selector_required"))
        end
      end

      it "resolves mixed-case account emails for a user who may view emails" do
        authorize("mcp:groups:write", auth_user: Fabricate(:admin, refresh_auto_groups: true))
        call_tool(
          "discourse_manage_group_members",
          { group_id: group.id, action: "add", user_emails: [member.email.upcase] },
        )

        expect(response.parsed_body.dig("result", "isError")).not_to eq(true)
        expect(group.users).to include(member)
      end

      it "refuses the email selector for an owner who may not view emails" do
        authorize("mcp:groups:write")
        expect(user.guardian.can_see_emails?).to eq(false)

        %w[discourse_manage_group_members discourse_manage_group_owners].each do |tool|
          [member.email, "[email protected]"].each do |email|
            call_tool(tool, { group_id: group.id, action: "add", user_emails: [email] })
            expect(response.status).to eq(403)
            expect(response.body).not_to include(email, member.username)
          end
        end
        expect(group.reload.users).not_to include(member)
      end

      it "rejects more than 100 parsed usernames before changing members or owners" do
        selected_users = 101.times.map { |index| Fabricate(:user, username: "limituser#{index}") }
        usernames = selected_users.map(&:username).each_slice(2).map { |names| names.join(",") }
        authorize("mcp:groups:write")

        %w[discourse_manage_group_members discourse_manage_group_owners].each do |tool|
          expect do
            call_tool(tool, { group_id: group.id, action: "add", usernames: })
          end.not_to change { group.group_users.count }

          expect(response.parsed_body.dig("result", "isError")).to eq(true)
          expect(tool_error).to eq(I18n.t("mcp.errors.group_user_limit", count: 100))
        end
      end

      it "accepts exactly 100 parsed usernames for member and owner changes" do
        selected_users = 100.times.map { |index| Fabricate(:user, username: "limituser#{index}") }
        usernames = selected_users.map(&:username).each_slice(2).map { |names| names.join(",") }
        authorize("mcp:groups:write")

        %w[discourse_manage_group_members discourse_manage_group_owners].each do |tool|
          call_tool(tool, { group_id: group.id, action: "add", usernames: })

          expect(response.parsed_body.dig("result", "isError")).to eq(false)
          expect(structured_content["usernames"]).to match_array(selected_users.map(&:username))
        end
        expect(group.group_users.where(owner: true).pluck(:user_id)).to match_array(
          [user.id, *selected_users.map(&:id)],
        )
      end

      it "resolves decomposed Unicode usernames" do
        SiteSetting.unicode_usernames = true
        unicode_user = Fabricate(:user, username: "café猫")
        authorize("mcp:groups:write")
        call_tool(
          "discourse_manage_group_members",
          {
            group_id: group.id,
            action: "add",
            usernames: [unicode_user.username.unicode_normalize(:nfd)],
          },
        )

        expect(response.parsed_body.dig("result", "isError")).not_to eq(true)
        expect(group.users).to include(unicode_user)
      end

      it "reports unknown usernames and makes no partial membership change" do
        authorize("mcp:groups:write")
        unknown_username = "missing_group_user"
        [[member.username, unknown_username], [unknown_username]].each do |usernames|
          expect do
            call_tool(
              "discourse_manage_group_members",
              { group_id: group.id, action: "add", usernames: },
            )
          end.not_to change { group.group_users.count }

          expect(response.parsed_body.dig("result", "isError")).to eq(true)
          expect(tool_error).to eq(
            I18n.t("groups.errors.users_not_found", values: unknown_username),
          )
        end
      end

      it "adds and removes members by username" do
        authorize("mcp:groups:write")

        call_tool(
          "discourse_manage_group_members",
          { group_id: group.id, action: "add", usernames: [member.username] },
        )

        expect(response.status).to eq(200)
        expect(structured_content["usernames"]).to eq([member.username])
        expect(group.reload.users).to include(member)

        call_tool(
          "discourse_manage_group_members",
          { group_id: group.id, action: "remove", user_ids: [member.id] },
        )

        expect(response.status).to eq(200)
        expect(group.reload.users).not_to include(member)
      end

      it "reports existing members as skipped when adding a mixed selection" do
        authorize("mcp:groups:write")

        expect_enqueued_with(
          job: :notify_users_added_to_group,
          args: {
            user_ids: [member.id],
            group_id: group.id,
          },
        ) do
          call_tool(
            "discourse_manage_group_members",
            {
              group_id: group.id,
              action: "add",
              usernames: [user.username, member.username],
              notify_users: true,
            },
          )
        end

        expect(response.status).to eq(200)
        expect(structured_content["usernames"]).to eq([member.username])
        expect(structured_content["skipped_usernames"]).to eq([user.username])
        expect(group.reload.users).to contain_exactly(user, member)
      end

      it "reports users who were never members as skipped" do
        authorize("mcp:groups:write")

        call_tool(
          "discourse_manage_group_members",
          { group_id: group.id, action: "remove", usernames: [member.username] },
        )

        expect(structured_content["skipped_usernames"]).to eq([member.username])
      end

      it "requires a user selector" do
        authorize("mcp:groups:write")

        call_tool("discourse_manage_group_members", { group_id: group.id, action: "add" })

        expect(tool_error).to eq(I18n.t("mcp.errors.group_member_selector_required"))
      end

      it "refuses a member who does not own the group" do
        group.add(member)
        authorize("mcp:groups:write", auth_user: member)

        call_tool(
          "discourse_manage_group_members",
          { group_id: group.id, action: "add", usernames: [user.username] },
        )

        expect(response.status).to eq(403)
      end

      it "refuses an automatic group" do
        authorize("mcp:groups:write", auth_user: Fabricate(:admin, refresh_auto_groups: true))

        call_tool(
          "discourse_manage_group_members",
          {
            group_id: Group::AUTO_GROUPS[:trust_level_1],
            action: "add",
            usernames: [member.username],
          },
        )

        expect(response.status).to eq(403)
      end
    end

    describe "discourse_invite_group_members" do
      it "adds known addresses and invites the rest" do
        admin = Fabricate(:admin, refresh_auto_groups: true)
        authorize("mcp:groups:write", auth_user: admin)

        call_tool(
          "discourse_invite_group_members",
          { group_id: group.id, emails: [member.email, "[email protected]"] },
        )

        expect(response.status).to eq(200)
        expect(structured_content["usernames"]).to eq([member.username])
        expect(structured_content["emails"]).to eq(["[email protected]"])
        expect(group.reload.users).to include(member)
        expect(Invite.last.groups).to eq([group])
      end

      it "refuses a TL2 group owner who may invite but may not view emails" do
        owner = Fabricate(:user, trust_level: TrustLevel[2], refresh_auto_groups: true)
        make_owner(group, owner)
        authorize("mcp:groups:write", auth_user: owner)
        expect(owner.guardian.can_invite_to_forum?([group])).to eq(true)
        expect(owner.guardian.can_see_emails?).to eq(false)

        expect do
          call_tool(
            "discourse_invite_group_members",
            { group_id: group.id, emails: [member.email, "[email protected]"] },
          )
        end.not_to change { Invite.count }

        expect(response.status).to eq(403)
        expect(response.body).not_to include(member.email, member.username)
        expect(group.reload.users).not_to include(member)
      end
    end

    describe "discourse_manage_group_owners" do
      before { make_owner(group, user) }

      it "lets an owner grant ownership and an admin revoke it" do
        authorize("mcp:groups:write")

        call_tool(
          "discourse_manage_group_owners",
          { group_id: group.id, action: "add", usernames: [member.username] },
        )

        expect(response.status).to eq(200)
        expect(group.group_users.find_by(user: member).owner).to eq(true)

        authorize("mcp:groups:write", auth_user: Fabricate(:admin, refresh_auto_groups: true))
        call_tool(
          "discourse_manage_group_owners",
          { group_id: group.id, action: "remove", usernames: [member.username] },
        )

        expect(response.status).to eq(200)
        expect(group.group_users.find_by(user: member).owner).to eq(false)
        expect(group.reload.users).to include(member)
      end

      it "refuses owner removal by a non-staff owner even with write scope" do
        make_owner(group, member)
        authorize("mcp:groups:write")

        call_tool(
          "discourse_manage_group_owners",
          { group_id: group.id, action: "remove", user_ids: [member.id] },
        )

        expect(response.status).to eq(403)
        expect(group.group_users.find_by(user: member)).to be_owner
      end

      it "allows moderator owner removal only when they can manage the group" do
        moderator = Fabricate(:moderator, refresh_auto_groups: true)
        make_owner(group, member)
        authorize("mcp:groups:write", auth_user: moderator)

        SiteSetting.moderators_manage_groups = false
        call_tool(
          "discourse_manage_group_owners",
          { group_id: group.id, action: "remove", user_ids: [member.id] },
        )
        expect(response.status).to eq(403)
        expect(group.group_users.find_by(user: member)).to be_owner

        SiteSetting.moderators_manage_groups = true
        call_tool(
          "discourse_manage_group_owners",
          { group_id: group.id, action: "remove", user_ids: [member.id] },
        )
        expect(response.parsed_body.dig("result", "isError")).not_to eq(true)
        expect(group.group_users.find_by(user: member)).not_to be_owner
      end

      it "refuses an automatic group" do
        authorize("mcp:groups:write", auth_user: Fabricate(:admin, refresh_auto_groups: true))

        call_tool(
          "discourse_manage_group_owners",
          {
            group_id: Group::AUTO_GROUPS[:trust_level_1],
            action: "add",
            usernames: [member.username],
          },
        )

        expect(tool_error).to eq(I18n.t("groups.errors.can_not_modify_automatic"))
      end
    end

    describe "discourse_manage_group_membership" do
      it "joins and leaves a group that allows public admission and exit" do
        group.update!(public_admission: true, public_exit: true)
        authorize("mcp:groups:write")

        call_tool("discourse_manage_group_membership", { group_id: group.id, action: "join" })

        expect(response.status).to eq(200)
        expect(structured_content).to include("changed" => true, "member" => true)
        expect(group.reload.users).to include(user)

        call_tool("discourse_manage_group_membership", { group_id: group.id, action: "leave" })

        expect(structured_content).to include("changed" => true, "member" => false)
        expect(group.reload.users).not_to include(user)
      end

      it "refuses to join a group that does not allow public admission" do
        authorize("mcp:groups:write")

        call_tool("discourse_manage_group_membership", { group_id: group.id, action: "join" })

        expect(response.status).to eq(403)
        expect(group.reload.users).not_to include(user)
      end

      it "requests membership and messages the owners" do
        owner = Fabricate(:user)
        make_owner(group, owner)
        group.update!(allow_membership_requests: true)
        authorize("mcp:groups:write")

        call_tool(
          "discourse_manage_group_membership",
          { group_id: group.id, action: "request", reason: "I write the docs 猫" },
        )

        expect(response.status).to eq(200)
        expect(GroupRequest.find_by(group:, user:).reason).to eq("I write the docs 猫")
        topic = Topic.find(structured_content["topic_id"])
        expect(topic.archetype).to eq(Archetype.private_message)
        expect(topic.allowed_users).to include(owner)
      end

      it "requires a reason to request membership" do
        make_owner(group, Fabricate(:user))
        group.update!(allow_membership_requests: true)
        authorize("mcp:groups:write")

        call_tool("discourse_manage_group_membership", { group_id: group.id, action: "request" })

        expect(tool_error).to eq(I18n.t("mcp.errors.group_request_reason_required"))
      end
    end

    describe "discourse_handle_group_membership_request" do
      fab!(:requester, :user)

      before do
        make_owner(group, user)
        group.update!(allow_membership_requests: true)
        GroupMembershipRequester.request(requester.guardian, group, "I write the docs")
      end

      it "approves a request and adds the requester" do
        authorize("mcp:groups:write")

        call_tool(
          "discourse_handle_group_membership_request",
          { group_id: group.id, username: requester.username, action: "approve" },
        )

        expect(response.status).to eq(200)
        expect(structured_content).to include("accepted" => true)
        expect(group.reload.users).to include(requester)
        expect(GroupRequest.where(group:, user: requester)).to be_empty
      end

      it "denies a request without adding the requester" do
        authorize("mcp:groups:write")

        call_tool(
          "discourse_handle_group_membership_request",
          { group_id: group.id, username: requester.username, action: "deny" },
        )

        expect(response.status).to eq(200)
        expect(structured_content).to include("accepted" => false)
        expect(group.reload.users).not_to include(requester)
        expect(GroupRequest.where(group:, user: requester)).to be_empty
      end

      it "reports a user with no pending request" do
        authorize("mcp:groups:write")

        call_tool(
          "discourse_handle_group_membership_request",
          { group_id: group.id, username: member.username, action: "approve" },
        )

        expect(tool_error).to eq(I18n.t("mcp.errors.group_membership_request_not_found"))
      end

      it "does not tell a non-owner whether a request exists" do
        authorize("mcp:groups:write", auth_user: member)

        call_tool(
          "discourse_handle_group_membership_request",
          { group_id: group.id, username: requester.username, action: "approve" },
        )

        expect(response.status).to eq(403)
        expect(response.body).not_to include(requester.username)
      end
    end
  end
end