Server Moderation Tools

Overview

Kyber provides comprehensive moderation tools for server hosts and assigned moderators. You can kick, ban, run commands, and manage a team of moderators to maintain a healthy community.

Moderation Permissions

Server Host

As the server host, you have full moderation powers:

Kick players
Ban players (permanent or temporary)
Run server commands
Add/remove moderators
View punishment history
Overturn bans

Assigned Moderators

Moderators you assign can:

Kick players
Ban players
Run server commands
View punishment history

Moderators cannot ban the server host or manage other moderators.

Global Moderators

Kyber staff with special entitlements:

Global Server Moderator: Can moderate all servers
Official Server Moderator: Can moderate official Kyber servers only

From source/API/internal/rpc/server_management.go:306-332:

if user.Entitled(models.EntitlementGlobalServerModerator) {
  ids, err = s.store.Servers.GetIDs(ctx)
} else if user.Entitled(models.EntitlementOfficialServerModerator) {
  officialServers, err := s.store.Servers.GetByDoc(ctx, bson.M{"official": true})
  for _, server := range officialServers {
    ids = append(ids, server.ID)
  }
}

Accessing Moderation Tools

In the Launcher

Open Server Moderation

Navigate to the Server Moderation section in the launcher.

View Your Servers

See all servers where you have moderation permissions.

Select Server

Click on a server to access its moderation panel.

Moderate

Use the tools to kick, ban, or manage players.

Server List

Your moderated servers list includes:

Servers you host
Servers where you’re assigned as moderator
Official servers (if you have staff permissions)

Player Management

Kicking Players

Kicking removes a player from the server immediately:

Find Player

Locate the player in the server’s player list.

Click Kick

Click the kick button next to their name.

Provide Reason

Enter a reason for the kick (optional but recommended).

Confirm

The player is immediately disconnected.

From source/API/internal/rpc/server_management.go:217-256, the kick process:

func (s *ServerManagement) KickPlayer(ctx context.Context, req *pbapi.ServerKickPlayerRequest) (*pbcommon.Empty, error) {
  // Verify moderator permissions
  server, _, err := s.isModerator(ctx, req.GetId())
  
  // Cannot kick the host
  if (target.ID == server.HostID) {
    return nil, status.Error(codes.PermissionDenied, "You cannot kick the server host")
  }
  
  // Create punishment record
  err = s.store.Punishments.Create(ctx, &models.PunishmentModel{
    Type:      models.PunishmentTypeKick,
    Issuer:    &server.HostID,
    User:      &target.ID,
    Reason:    util.ToPtr(req.GetReason()),
    IssuedAt:  time.Now(),
  })
  
  // Kick from server
  s.sm.KickPlayer(server.ID, target.ID, req.GetReason())
}

Kicks are logged in the punishment database for tracking repeat offenders.

Banning Players

Bans prevent players from rejoining your server:

Find Player

Locate the player in the server’s player list or ban list.

Click Ban

Click the ban button.

Configure Ban

Set:

Reason: Why the player is banned (required)
Duration: Permanent or temporary (in seconds)

Confirm

The player is kicked and banned from rejoining.

Ban Durations

Permanent Ban:

{
  "reason": "Cheating",
  "duration": null
}

Temporary Ban (1 day):

{
  "reason": "Toxic behavior",
  "duration": 86400
}

Temporary Ban (1 week):

{
  "reason": "Team killing",
  "duration": 604800
}

From source/API/internal/rpc/server_management.go:279-283:

var expiresAt *time.Time
if req.Duration != nil {
  expiresAt = new(time.Time)
  *expiresAt = time.Now().Add(time.Duration(*req.Duration) * time.Second)
}

Unbanning Players

To remove a ban:

View Ban List

Access the punishment list for your server.

Find Ban

Locate the banned player.

Click Unban

Click the unban/overturn button.

Confirm

The ban is marked as overturned and the player can rejoin.

From source/API/internal/rpc/server_management.go:35-58:

func (s *ServerManagement) UnbanPlayer(ctx context.Context, req *pbapi.UnbanPlayerRequest) (*pbcommon.Empty, error) {
  punishment, err := s.store.Punishments.GetBanForServer(ctx, server.HostID, req.GetUserId())
  
  punishment.OverturnedBy = &user.ID
  err = s.store.Punishments.Update(ctx, punishment)
}

Banned players cannot rejoin even if they change their username. Bans are tied to their Kyber account ID.

Punishment System

Punishment Types

From source/API/pkg/models/punishment.go:11-16:

type PunishmentType string

const (
  PunishmentTypeKick PunishmentType = "KICK"
  PunishmentTypeBan  PunishmentType = "BAN"
)

Punishment Data Model

Each punishment record contains:

Field	Description
ID	Unique punishment identifier
Type	KICK or BAN
Issuer	Server host ID (for server bans)
Moderator ID	The moderator who issued it
User	Banned/kicked player ID
Reason	Why the punishment was issued
Issued At	Timestamp of punishment
Expires At	When temporary bans expire (null for permanent)
Overturned By	Who removed the ban (if applicable)

Active vs Inactive Bans

From source/API/pkg/models/punishment.go:40-42:

func (p *PunishmentModel) IsActive() bool {
  return p.OverturnedBy == nil && (p.ExpiresAt == nil || p.ExpiresAt.After(time.Now()))
}

A ban is active if:

It hasn’t been overturned
AND it’s either permanent OR hasn’t expired yet

Ban Messages

When a banned player tries to join, they see: Temporary Ban:

You are banned until Mon, 02 Jan 2006 15:04:05 MST. 
Reason: Toxic behavior

Permanent Ban:

You are permanently banned. 
Reason: Cheating

Managing Moderators

Adding Moderators

Open Moderator Panel

Navigate to your server’s moderation settings.

Click Add Moderator

Open the add moderator dialog.

Enter User ID

Input the Kyber user ID of the person you want to add.

Confirm

The user is added to your moderator list.

From source/API/internal/rpc/server_management.go:154-179:

func (s *ServerManagement) AddModerator(ctx context.Context, req *pbapi.AddModeratorRequest) (*pbcommon.Empty, error) {
  user := ctx.Value("user").(*models.UserModel)

  if slices.Contains(user.ModeratorUserIDs, req.GetId()) {
    return nil, status.Error(codes.AlreadyExists, "User is already a moderator")
  }

  moderator, err := s.store.Users.GetByID(ctx, req.GetId())
  
  user.ModeratorUserIDs = append(user.ModeratorUserIDs, moderator.ID)
  
  err = s.store.Users.Update(ctx, user.ID, bson.M{"$set": bson.M{"moderator_user_ids": user.ModeratorUserIDs}})
}

Find a user’s ID by having them open their profile in the launcher and sharing it with you.

Removing Moderators

View Moderator List

Open the list of current moderators.

Select Moderator

Find the moderator you want to remove.

Click Remove

Remove them from your moderator team.

Confirm

They immediately lose moderation permissions.

Viewing Moderators

The moderator list shows:

Moderator name
Moderator Kyber ID
When they were added
Recent moderation actions

From source/API/internal/rpc/server_management.go:110-152, moderators are fetched and displayed:

func (s *ServerManagement) GetModerators(ctx context.Context, req *pbapi.ModeratorsRequest) (*pbapi.ModeratorList, error) {
  users, err := s.store.Users.SearchByIDs(ctx, host.ModeratorUserIDs)
  
  cnv := make([]*pbcommon.KyberPlayer, len(users))
  for i, u := range users {
    cnv[i] = &pbcommon.KyberPlayer{
      Id:   u.ID,
      Name: u.Name,
    }
  }
  
  return &pbapi.ModeratorList{Users: cnv}, nil
}

Running Server Commands

Moderators can run administrative commands on the server:

Open Command Console

Access the server command interface.

Enter Command

Type a valid server command.

Execute

The command is sent to the server and logged.

From source/API/internal/rpc/server_management.go:201-214:

func (s *ServerManagement) RunCommand(ctx context.Context, req *pbapi.ServerRunCommandRequest) (*pbcommon.Empty, error) {
  server, user, err := s.isModerator(ctx, req.GetId())
  
  logger.L().Info("User is running command on server", 
    zap.String("user_id", user.ID), 
    zap.String("server_id", server.ID), 
    zap.String("command", req.GetCommand()))

  s.sm.RunCommand(server.ID, req.GetCommand())

  consoleMessage := fmt.Sprintf("[MODERATOR] %s (%s) ran command: %s", user.Name, user.ID, req.GetCommand())
  s.sm.PublishConsoleMessage(server.ID, consoleMessage, false)
}

Common Commands

# Change map/mode
ServerTravel MapPath GameMode

# Adjust ticket counts
SetTicketCount 200

# Broadcast message
ServerMessage "Welcome to the server!"

# Kick by name (if supported)
Kick PlayerName

# Change time limit
SetTimeLimit 600

Server commands are logged with your name and user ID. All moderators can see who ran what command.

Viewing Punishment History

Access the full punishment log for your server:

Punishment List

The punishment list displays:

Player name and ID
Punishment type (kick/ban)
Reason provided
Moderator who issued it
Timestamp
Expiration (for temporary bans)
Overturn status

From source/API/internal/rpc/server_management.go:61-108:

func (s *ServerManagement) GetPunishments(ctx context.Context, req *pbapi.PunishmentsRequest) (*pbapi.PunishmentsResponse, error) {
  server, _, err := s.isModerator(ctx, req.GetServerId())
  
  punishments, err := s.store.Punishments.GetBansForServer(ctx, server.HostID)
  
  // Fetch user data for each punishment
  bannedUserIDs := make([]string, 0)
  for _, punishment := range punishments {
    if !slices.Contains(bannedUserIDs, *punishment.User) {
      bannedUserIDs = append(bannedUserIDs, *punishment.User)
    }
  }
  
  users, err := s.store.Users.SearchByIDs(ctx, bannedUserIDs)
}

Filtering Punishments

Filter the list by:

Active vs overturned bans
Kick vs ban types
Date range
Specific moderators
Player names

Best Practices

Clear Communication

Provide Reasons

Always include specific reasons for kicks and bans

Document Rules

Share server rules in your description or Discord

Warning System

Warn players before kicking for minor infractions

Consistent Enforcement

Apply rules fairly to all players

Moderator Management

Trust your team: Only add moderators you trust
Review actions: Regularly check the punishment log
Communicate: Coordinate with your moderation team
Update regularly: Remove inactive moderators

Punishment Guidelines

Kicks: For minor or first-time offenses

Excessive team killing
Mild toxic behavior
AFKing in important roles

Temporary Bans: For repeat offenders or serious issues

Multiple warnings ignored
Continued toxic behavior
Exploiting glitches

Permanent Bans: For severe violations

Cheating/hacking
Severe harassment
Doxing or threats

Troubleshooting

Can’t Access Moderation Panel

If you can’t access moderation tools:

Verify you’re the server host or assigned moderator
Check that the server is still active
Ensure you’re logged into the correct account
Try refreshing the server list

Moderator Permissions Not Working

From source/API/pkg/models/server.go:128-140:

func (server *ServerModel) CanManage(host *UserModel, user *UserModel) bool {
  if user == nil || server == nil {
    return false
  }

  if !user.Entitled(EntitlementGlobalServerModerator) &&
    user.ID != server.HostID &&
    !slices.Contains(host.ModeratorUserIDs, user.ID) {
    return false
  }

  return true
}

Permissions require:

Valid user account
Active server
Host relationship OR moderator assignment OR global entitlement

Bans Not Working

If banned players can still join:

Check the ban is active (not expired or overturned)
Verify you banned the correct user ID
Ensure the server is properly connected to Kyber API
Check punishment logs for errors

API Integration

For advanced use cases, moderation tools are available via the Kyber API:

Endpoints

service ServerManagement {
  rpc KickPlayer(ServerKickPlayerRequest) returns (Empty);
  rpc BanPlayer(ServerBanPlayerRequest) returns (Empty);
  rpc UnbanPlayer(UnbanPlayerRequest) returns (Empty);
  rpc GetPunishments(PunishmentsRequest) returns (PunishmentsResponse);
  rpc AddModerator(AddModeratorRequest) returns (Empty);
  rpc RemoveModerator(RemoveModeratorRequest) returns (Empty);
  rpc GetModerators(ModeratorsRequest) returns (ModeratorList);
  rpc RunCommand(ServerRunCommandRequest) returns (Empty);
  rpc ModeratedServers(Empty) returns (ServerList);
}

Get Started

Features

Guides

​Overview

​Moderation Permissions

​Server Host

​Assigned Moderators

​Global Moderators

​Accessing Moderation Tools

​In the Launcher

​Server List

​Player Management

​Kicking Players

​Banning Players

​Ban Durations

​Unbanning Players

​Punishment System

​Punishment Types

​Punishment Data Model

​Active vs Inactive Bans

​Ban Messages

​Managing Moderators

​Adding Moderators

​Removing Moderators

​Viewing Moderators

​Running Server Commands

​Common Commands

​Viewing Punishment History

​Punishment List

​Filtering Punishments

​Best Practices

​Clear Communication

Provide Reasons

Document Rules

Warning System

Consistent Enforcement

​Moderator Management

​Punishment Guidelines

​Troubleshooting

​Can’t Access Moderation Panel

​Moderator Permissions Not Working

​Bans Not Working

​API Integration

​Endpoints

​Next Steps

Host a Server

Map Rotations

Build docs developers (and LLMs) love

Overview

Moderation Permissions

Server Host

Assigned Moderators

Global Moderators

Accessing Moderation Tools

In the Launcher

Server List

Player Management

Kicking Players

Banning Players

Ban Durations

Unbanning Players

Punishment System

Punishment Types

Punishment Data Model

Active vs Inactive Bans

Ban Messages

Managing Moderators

Adding Moderators

Removing Moderators

Viewing Moderators

Running Server Commands

Common Commands

Viewing Punishment History

Punishment List

Filtering Punishments

Best Practices

Clear Communication

Moderator Management

Punishment Guidelines

Troubleshooting

Can’t Access Moderation Panel

Moderator Permissions Not Working

Bans Not Working

API Integration

Endpoints

Next Steps