feat: group conversations

.claude/settings.json

@@ -0,0 +1,3 @@
+{
+  "additionalDirectories": ["../baileys-api"]
+}

.env.example

@@ -293,5 +293,7 @@ AZURE_APP_SECRET=
 BAILEYS_PROVIDER_DEFAULT_CLIENT_NAME=Chatwoot
 BAILEYS_PROVIDER_DEFAULT_URL=http://localhost:3025
 BAILEYS_PROVIDER_DEFAULT_API_KEY=
+# Enable WhatsApp group conversations for Baileys provider (default: false)
+BAILEYS_WHATSAPP_GROUPS_ENABLED=false
 
 RESEND_API_KEY=

app/builders/contact_inbox_with_contact_builder.rb

@@ -55,7 +55,8 @@ def create_contact
       email: contact_attributes[:email],
       identifier: contact_attributes[:identifier],
       additional_attributes: contact_attributes[:additional_attributes],
-      custom_attributes: contact_attributes[:custom_attributes]
+      custom_attributes: contact_attributes[:custom_attributes],
+      group_type: contact_attributes[:group_type] || :individual
     )
   end
 

app/controllers/api/v1/accounts/contacts/group_admin_controller.rb

@@ -0,0 +1,56 @@
+class Api::V1::Accounts::Contacts::GroupAdminController < Api::V1::Accounts::Contacts::BaseController
+  VALID_PROPERTIES = %w[announce restrict join_approval_mode member_add_mode].freeze
+
+  def leave
+    authorize @contact, :update?
+    channel.group_leave(@contact.identifier)
+    head :ok
+  rescue Whatsapp::Providers::WhatsappBaileysService::ProviderUnavailableError => e
+    render json: { error: e.message }, status: :unprocessable_entity
+  end
+
+  def update
+    authorize @contact, :update?
+    property = property_params[:property]
+    enabled = ActiveModel::Type::Boolean.new.cast(property_params[:enabled])
+    return render json: { error: 'invalid_property' }, status: :unprocessable_entity unless property.in?(VALID_PROPERTIES)
+
+    apply_property_change(property, enabled)
+    update_contact_attribute(property, enabled)
+    head :ok
+  rescue Whatsapp::Providers::WhatsappBaileysService::ProviderUnavailableError => e
+    render json: { error: e.message }, status: :unprocessable_entity
+  end
+
+  private
+
+  def apply_property_change(property, enabled)
+    case property
+    when 'announce', 'restrict'
+      channel.group_setting_update(@contact.identifier, property, enabled)
+    when 'join_approval_mode'
+      channel.group_join_approval_mode(@contact.identifier, enabled ? 'on' : 'off')
+    when 'member_add_mode'
+      channel.group_member_add_mode(@contact.identifier, enabled ? 'all_member_add' : 'admin_add')
+    end
+  end
+
+  def property_params
+    params.permit(:property, :enabled)
+  end
+
+  def channel
+    @channel ||= @contact.group_channel
+  end
+
+  def resolve_group_conversations
+    Current.account.conversations
+           .where(contact_id: @contact.id, group_type: :group, status: %i[open pending])
+           .find_each { |c| c.update!(status: :resolved) }
+  end
+
+  def update_contact_attribute(key, value)
+    new_attrs = (@contact.additional_attributes || {}).merge(key => value)
+    @contact.update!(additional_attributes: new_attrs)
+  end
+end

app/controllers/api/v1/accounts/contacts/group_invites_controller.rb

@@ -0,0 +1,27 @@
+class Api::V1::Accounts::Contacts::GroupInvitesController < Api::V1::Accounts::Contacts::BaseController
+  def show
+    authorize @contact, :show?
+    code = channel.group_invite_code(@contact.identifier)
+    render json: invite_response(code)
+  rescue Whatsapp::Providers::WhatsappBaileysService::ProviderUnavailableError => e
+    render json: { error: e.message }, status: :unprocessable_entity
+  end
+
+  def revoke
+    authorize @contact, :update?
+    code = channel.revoke_group_invite(@contact.identifier)
+    render json: invite_response(code)
+  rescue Whatsapp::Providers::WhatsappBaileysService::ProviderUnavailableError => e
+    render json: { error: e.message }, status: :unprocessable_entity
+  end
+
+  private
+
+  def channel
+    @channel ||= @contact.group_channel
+  end
+
+  def invite_response(code)
+    { invite_code: code, invite_url: "https://chat.whatsapp.com/#{code}" }
+  end
+end

app/controllers/api/v1/accounts/contacts/group_join_requests_controller.rb

@@ -0,0 +1,37 @@
+class Api::V1::Accounts::Contacts::GroupJoinRequestsController < Api::V1::Accounts::Contacts::BaseController
+  def index
+    authorize @contact, :show?
+    requests = channel.group_join_requests(@contact.identifier)
+    render json: { payload: requests }
+  rescue Whatsapp::Providers::WhatsappBaileysService::ProviderUnavailableError => e
+    render json: { error: e.message }, status: :unprocessable_entity
+  end
+
+  def handle
+    authorize @contact, :update?
+    channel.handle_group_join_requests(@contact.identifier, handle_params[:participants], handle_params[:request_action])
+    remove_handled_requests(handle_params[:participants])
+    head :ok
+  rescue Whatsapp::Providers::WhatsappBaileysService::ProviderUnavailableError => e
+    render json: { error: e.message }, status: :unprocessable_entity
+  end
+
+  private
+
+  def handle_params
+    params.permit(:request_action, participants: [])
+  end
+
+  def channel
+    @channel ||= @contact.group_channel
+  end
+
+  def remove_handled_requests(participants)
+    return if participants.blank?
+
+    current_requests = @contact.additional_attributes&.dig('pending_join_requests') || []
+    updated_requests = current_requests.reject { |r| participants.include?(r['jid']) }
+    new_attrs = (@contact.additional_attributes || {}).merge('pending_join_requests' => updated_requests)
+    @contact.update!(additional_attributes: new_attrs)
+  end
+end

app/controllers/api/v1/accounts/contacts/group_members_controller.rb

@@ -0,0 +1,155 @@
+class Api::V1::Accounts::Contacts::GroupMembersController < Api::V1::Accounts::Contacts::BaseController
+  DEFAULT_PER_PAGE = 10
+
+  before_action :ensure_group_contact, only: %i[create update destroy]
+
+  def index
+    authorize @contact, :show?
+
+    base_query = GroupMember.active
+                            .where(group_contact: @contact)
+                            .includes(:contact)
+
+    @total_count = base_query.count
+    @page = [(params[:page] || 1).to_i, 1].max
+    @per_page = (params[:per_page] || DEFAULT_PER_PAGE).to_i.clamp(1, 100)
+    @inbox_phone_number = inbox_phone_number
+    @is_inbox_admin = inbox_admin?
+
+    paginated = base_query.order(role: :desc, id: :asc)
+                          .offset((@page - 1) * @per_page)
+                          .limit(@per_page)
+
+    @group_members = pin_own_member_on_first_page(paginated)
+  end
+
+  def create
+    authorize @contact, :update?
+    participants = create_params[:participants]
+    return render json: { error: 'participants_required' }, status: :unprocessable_entity if participants.blank?
+
+    channel.update_group_participants(@contact.identifier, format_participants(participants), 'add')
+    add_group_members(participants)
+    head :ok
+  rescue Whatsapp::Providers::WhatsappBaileysService::ProviderUnavailableError => e
+    render json: { error: e.message }, status: :unprocessable_entity
+  end
+
+  def update
+    authorize @contact, :update?
+    role = update_params[:role]
+    return render json: { error: 'invalid_role' }, status: :unprocessable_entity unless %w[admin member].include?(role)
+
+    member = group_members.find(params[:member_id])
+    action = role == 'admin' ? 'promote' : 'demote'
+    channel.update_group_participants(@contact.identifier, [jid_for_member(member)], action)
+    member.update!(role: role)
+    head :ok
+  rescue Whatsapp::Providers::WhatsappBaileysService::GroupParticipantNotAllowedError
+    render json: { error: 'group_creator_not_modifiable' }, status: :unprocessable_entity
+  rescue Whatsapp::Providers::WhatsappBaileysService::ProviderUnavailableError => e
+    render json: { error: e.message }, status: :unprocessable_entity
+  end
+
+  def destroy
+    authorize @contact, :update?
+
+    member = group_members.find(params[:id])
+    channel.update_group_participants(@contact.identifier, [jid_for_member(member)], 'remove')
+    member.update!(is_active: false)
+    head :ok
+  rescue Whatsapp::Providers::WhatsappBaileysService::GroupParticipantNotAllowedError
+    render json: { error: 'group_creator_not_modifiable' }, status: :unprocessable_entity
+  rescue Whatsapp::Providers::WhatsappBaileysService::ProviderUnavailableError => e
+    render json: { error: e.message }, status: :unprocessable_entity
+  end
+
+  private
+
+  def ensure_group_contact
+    return if @contact.group_type_group? && @contact.identifier.present?
+
+    render json: { error: 'Contact is not a valid group' }, status: :unprocessable_entity
+  end
+
+  def group_members
+    GroupMember.where(group_contact: @contact)
+  end
+
+  def create_params
+    params.permit(participants: [])
+  end
+
+  def update_params
+    params.permit(:role)
+  end
+
+  def channel
+    @channel ||= @contact.group_channel
+  end
+
+  def inbox_phone_number
+    channel&.phone_number
+  end
+
+  def inbox_admin?
+    return false if @inbox_phone_number.blank?
+
+    find_own_member&.role == 'admin'
+  end
+
+  def pin_own_member_on_first_page(paginated)
+    return paginated unless @page == 1 && @inbox_phone_number.present?
+
+    ids = paginated.pluck(:id)
+    own = find_own_member
+    return paginated if own.blank? || ids.include?(own.id)
+
+    # Prepend own member; drop the last one so total per-page stays consistent
+    [own] + paginated.where.not(id: own.id).limit(@per_page - 1).to_a
+  end
+
+  def find_own_member
+    clean = @inbox_phone_number.delete('+')
+    GroupMember.active
+               .where(group_contact: @contact)
+               .joins(:contact)
+               .where('REPLACE(contacts.phone_number, \'+\', \'\') = ? OR RIGHT(REPLACE(contacts.phone_number, \'+\', \'\'), 8) = RIGHT(?, 8)',
+                      clean, clean)
+               .includes(:contact)
+               .first
+  end
+
+  def format_participants(phone_numbers)
+    Array(phone_numbers).map { |phone| "#{phone.to_s.delete('+')}@s.whatsapp.net" }
+  end
+
+  def jid_for_member(member)
+    "#{member.contact.phone_number.to_s.delete('+')}@s.whatsapp.net"
+  end
+
+  def add_group_members(phone_numbers)
+    inbox = @contact.contact_inboxes.first&.inbox
+    Array(phone_numbers).each do |phone|
+      normalized = normalize_phone(phone)
+      next if normalized.blank?
+
+      contact_inbox = ::ContactInboxWithContactBuilder.new(
+        source_id: normalized.delete('+'),
+        inbox: inbox,
+        contact_attributes: { name: normalized, phone_number: normalized }
+      ).perform
+      next if contact_inbox.blank?
+
+      member = GroupMember.find_or_initialize_by(group_contact: @contact, contact: contact_inbox.contact)
+      member.update!(role: :member, is_active: true) unless member.persisted? && member.is_active?
+    end
+  end
+
+  def normalize_phone(phone)
+    cleaned = phone.to_s.strip
+    return nil if cleaned.blank?
+
+    cleaned.start_with?('+') ? cleaned : "+#{cleaned}"
+  end
+end

app/controllers/api/v1/accounts/contacts/group_metadata_controller.rb

@@ -0,0 +1,39 @@
+class Api::V1::Accounts::Contacts::GroupMetadataController < Api::V1::Accounts::Contacts::BaseController
+  def update
+    authorize @contact, :update?
+    update_subject if metadata_params[:subject].present?
+    update_description if metadata_params[:description].present?
+    update_picture if metadata_params[:avatar].present?
+    render json: { id: @contact.id, name: @contact.name, additional_attributes: @contact.additional_attributes }
+  rescue Whatsapp::Providers::WhatsappBaileysService::ProviderUnavailableError => e
+    render json: { error: e.message }, status: :unprocessable_entity
+  end
+
+  private
+
+  def metadata_params
+    params.permit(:subject, :description, :avatar)
+  end
+
+  def update_subject
+    channel.update_group_subject(@contact.identifier, metadata_params[:subject])
+    @contact.update!(name: metadata_params[:subject])
+  end
+
+  def update_description
+    channel.update_group_description(@contact.identifier, metadata_params[:description])
+    attrs = @contact.additional_attributes.merge('description' => metadata_params[:description])
+    @contact.update!(additional_attributes: attrs)
+  end
+
+  def update_picture
+    avatar = metadata_params[:avatar]
+    image_base64 = Base64.strict_encode64(avatar.read)
+    channel.update_group_picture(@contact.identifier, image_base64)
+    @contact.avatar.attach(avatar)
+  end
+
+  def channel
+    @channel ||= @contact.group_channel
+  end
+end

app/controllers/api/v1/accounts/contacts_controller.rb

@@ -13,7 +13,7 @@ class Api::V1::Accounts::ContactsController < Api::V1::Accounts::BaseController
 
   before_action :check_authorization
   before_action :set_current_page, only: [:index, :active, :search, :filter]
-  before_action :fetch_contact, only: [:show, :update, :destroy, :avatar, :contactable_inboxes, :destroy_custom_attributes]
+  before_action :fetch_contact, only: [:show, :update, :destroy, :avatar, :contactable_inboxes, :destroy_custom_attributes, :sync_group]
   before_action :set_include_contact_inboxes, only: [:index, :active, :search, :filter, :show, :update]
 
   def index
@@ -82,6 +82,15 @@ def destroy_custom_attributes
     @contact.save!
   end
 
+  def sync_group
+    authorize @contact, :sync_group?
+    raise ActionController::BadRequest, I18n.t('contacts.sync_group.not_a_group') if @contact.group_type_individual?
+    raise ActionController::BadRequest, I18n.t('contacts.sync_group.no_identifier') if @contact.identifier.blank?
+
+    Contacts::SyncGroupJob.perform_later(@contact)
+    head :accepted
+  end
+
   def create
     ActiveRecord::Base.transaction do
       @contact = Current.account.contacts.new(permitted_params.except(:avatar_url))

app/controllers/api/v1/accounts/conversations_controller.rb

@@ -166,7 +166,15 @@ def update_last_seen_on_conversation(last_seen_at, update_assignee)
     # rubocop:enable Rails/SkipsModelValidations
   end
 
+  def unseen_activity?
+    @conversation.last_activity_at.present? &&
+      (@conversation.agent_last_seen_at.blank? || @conversation.last_activity_at > @conversation.agent_last_seen_at)
+  end
+
   def should_update_last_seen?
+    # Always update when there's unseen activity (e.g. soft-disabled group conversations that don't create messages)
+    return true if unseen_activity?
+
     # Update if at least one relevant timestamp is older than 1 hour or not set
     # This prevents redundant DB writes when agents repeatedly view the same conversation
     agent_needs_update = @conversation.agent_last_seen_at.blank? || @conversation.agent_last_seen_at < 1.hour.ago