refactor: unify user mode processing into shared service layer

Both the HTTP API and IRC wire protocol handlers now call
service.ApplyUserMode/service.QueryUserMode for all user
mode operations. The service layer iterates mode strings
character by character (the correct IRC approach), ensuring
identical behavior regardless of transport.

Removed duplicate mode logic from internal/handlers/utility.go
(buildUserModeString, applyUserModeChange, applyModeChar) and
internal/ircserver/commands.go (buildUmodeString, inline iteration).

Added service-level tests for QueryUserMode, ApplyUserMode
(single-char, multi-char, invalid input, de-oper, +o rejection).

internal/service/service.go

@@ -791,6 +791,109 @@ func (s *Service) QueryChannelMode(
 	return modes + modeParams
 }
 
+// QueryUserMode returns the current user mode string for
+// the given session (e.g. "+ow", "+w", "+").
+func (s *Service) QueryUserMode(
+	ctx context.Context,
+	sessionID int64,
+) string {
+	modes := "+"
+
+	isOper, err := s.db.IsSessionOper(ctx, sessionID)
+	if err == nil && isOper {
+		modes += "o"
+	}
+
+	isWallops, err := s.db.IsSessionWallops(
+		ctx, sessionID,
+	)
+	if err == nil && isWallops {
+		modes += "w"
+	}
+
+	return modes
+}
+
+// ApplyUserMode parses a mode string character by
+// character (e.g. "+wo", "-w") and applies each mode
+// change to the session. Returns the resulting mode string
+// after all changes, or an IRCError on failure.
+func (s *Service) ApplyUserMode(
+	ctx context.Context,
+	sessionID int64,
+	modeStr string,
+) (string, error) {
+	if len(modeStr) < 2 { //nolint:mnd // +/- prefix + ≥1 char
+		return "", &IRCError{
+			Code:    irc.ErrUmodeUnknownFlag,
+			Params:  nil,
+			Message: "Unknown MODE flag",
+		}
+	}
+
+	adding := modeStr[0] == '+'
+
+	for _, ch := range modeStr[1:] {
+		if err := s.applySingleUserMode(
+			ctx, sessionID, ch, adding,
+		); err != nil {
+			return "", err
+		}
+	}
+
+	return s.QueryUserMode(ctx, sessionID), nil
+}
+
+// applySingleUserMode applies one user mode character.
+func (s *Service) applySingleUserMode(
+	ctx context.Context,
+	sessionID int64,
+	modeChar rune,
+	adding bool,
+) error {
+	switch modeChar {
+	case 'w':
+		err := s.db.SetSessionWallops(
+			ctx, sessionID, adding,
+		)
+		if err != nil {
+			s.log.Error(
+				"set wallops mode failed", "error", err,
+			)
+
+			return fmt.Errorf("set wallops: %w", err)
+		}
+	case 'o':
+		// +o cannot be set via MODE; use OPER command.
+		if adding {
+			return &IRCError{
+				Code:    irc.ErrUmodeUnknownFlag,
+				Params:  nil,
+				Message: "Unknown MODE flag",
+			}
+		}
+
+		err := s.db.SetSessionOper(
+			ctx, sessionID, false,
+		)
+		if err != nil {
+			s.log.Error(
+				"clear oper mode failed", "error", err,
+			)
+
+			return fmt.Errorf("clear oper: %w", err)
+		}
+	default:
+		return &IRCError{
+			Code:    irc.ErrUmodeUnknownFlag,
+			Params:  nil,
+			Message: "Unknown MODE flag",
+		}
+	}
+
+	return nil
+}
+
 // broadcastNickChange notifies channel peers of a nick
 // change.
 func (s *Service) broadcastNickChange(

internal/service/service_test.go

@@ -363,3 +363,166 @@ func TestSendChannelMessage_Moderated(t *testing.T) {
 		t.Errorf("operator should be able to send in moderated channel: %v", err)
 	}
 }
+
+func TestQueryUserMode(t *testing.T) {
+	env := newTestEnv(t)
+	ctx := t.Context()
+
+	sid := createSession(ctx, t, env.db, "alice")
+
+	// Fresh session has no modes.
+	modes := env.svc.QueryUserMode(ctx, sid)
+	if modes != "+" {
+		t.Errorf("expected +, got %s", modes)
+	}
+
+	// Set wallops.
+	_ = env.db.SetSessionWallops(ctx, sid, true)
+
+	modes = env.svc.QueryUserMode(ctx, sid)
+	if modes != "+w" {
+		t.Errorf("expected +w, got %s", modes)
+	}
+
+	// Set oper.
+	_ = env.db.SetSessionOper(ctx, sid, true)
+
+	modes = env.svc.QueryUserMode(ctx, sid)
+	if modes != "+ow" {
+		t.Errorf("expected +ow, got %s", modes)
+	}
+}
+
+func TestApplyUserModeSingleChar(t *testing.T) {
+	env := newTestEnv(t)
+	ctx := t.Context()
+
+	sid := createSession(ctx, t, env.db, "alice")
+
+	// Apply +w.
+	result, err := env.svc.ApplyUserMode(ctx, sid, "+w")
+	if err != nil {
+		t.Fatalf("apply +w: %v", err)
+	}
+
+	if result != "+w" {
+		t.Errorf("expected +w, got %s", result)
+	}
+
+	// Apply -w.
+	result, err = env.svc.ApplyUserMode(ctx, sid, "-w")
+	if err != nil {
+		t.Fatalf("apply -w: %v", err)
+	}
+
+	if result != "+" {
+		t.Errorf("expected +, got %s", result)
+	}
+}
+
+func TestApplyUserModeMultiChar(t *testing.T) {
+	env := newTestEnv(t)
+	ctx := t.Context()
+
+	sid := createSession(ctx, t, env.db, "alice")
+
+	// Set oper first so we can test +wo (w applied, o
+	// rejected because +o is not allowed via MODE).
+	_ = env.db.SetSessionOper(ctx, sid, true)
+
+	// Apply +w alone should work.
+	result, err := env.svc.ApplyUserMode(ctx, sid, "+w")
+	if err != nil {
+		t.Fatalf("apply +w: %v", err)
+	}
+
+	if result != "+ow" {
+		t.Errorf("expected +ow, got %s", result)
+	}
+
+	// Reset wallops.
+	_ = env.db.SetSessionWallops(ctx, sid, false)
+
+	// Multi-char -ow: should de-oper and remove wallops.
+	_ = env.db.SetSessionWallops(ctx, sid, true)
+
+	result, err = env.svc.ApplyUserMode(ctx, sid, "-ow")
+	if err != nil {
+		t.Fatalf("apply -ow: %v", err)
+	}
+
+	if result != "+" {
+		t.Errorf("expected +, got %s", result)
+	}
+
+	// +wo should fail because +o is not allowed.
+	_, err = env.svc.ApplyUserMode(ctx, sid, "+wo")
+
+	var ircErr *service.IRCError
+	if !errors.As(err, &ircErr) {
+		t.Fatalf("expected IRCError, got %v", err)
+	}
+
+	if ircErr.Code != irc.ErrUmodeUnknownFlag {
+		t.Errorf(
+			"expected ErrUmodeUnknownFlag, got %d",
+			ircErr.Code,
+		)
+	}
+}
+
+func TestApplyUserModeInvalidInput(t *testing.T) {
+	env := newTestEnv(t)
+	ctx := t.Context()
+
+	sid := createSession(ctx, t, env.db, "alice")
+
+	// Too short.
+	_, err := env.svc.ApplyUserMode(ctx, sid, "+")
+
+	var ircErr *service.IRCError
+	if !errors.As(err, &ircErr) {
+		t.Fatalf("expected IRCError for short input, got %v", err)
+	}
+
+	// Unknown flag.
+	_, err = env.svc.ApplyUserMode(ctx, sid, "+x")
+	if !errors.As(err, &ircErr) {
+		t.Fatalf("expected IRCError for unknown flag, got %v", err)
+	}
+
+	if ircErr.Code != irc.ErrUmodeUnknownFlag {
+		t.Errorf(
+			"expected ErrUmodeUnknownFlag, got %d",
+			ircErr.Code,
+		)
+	}
+}
+
+func TestApplyUserModeDeoper(t *testing.T) {
+	env := newTestEnv(t)
+	ctx := t.Context()
+
+	sid := createSession(ctx, t, env.db, "alice")
+
+	// Make oper via DB directly.
+	_ = env.db.SetSessionOper(ctx, sid, true)
+
+	// -o should work.
+	result, err := env.svc.ApplyUserMode(ctx, sid, "-o")
+	if err != nil {
+		t.Fatalf("apply -o: %v", err)
+	}
+
+	if result != "+" {
+		t.Errorf("expected +, got %s", result)
+	}
+
+	// +o should fail.
+	_, err = env.svc.ApplyUserMode(ctx, sid, "+o")
+
+	var ircErr *service.IRCError
+	if !errors.As(err, &ircErr) {
+		t.Fatalf("expected IRCError for +o, got %v", err)
+	}
+}