Register the broker wait before the first poll (closes #157)

GET /api/v1/messages read the client output queue and only then
registered with the broker. Notify wakes only the channels registered
at that moment, so a message queued between the empty read and the
registration waited out the whole long-poll timeout. The handler now
registers first and removes its channel on every exit path; the IRC
relay loop registers before each drain in the same way.

The handlers read the queue through a function field that defaults to
Database.PollMessages, so tests can act just after a read: one checks
that a message queued there comes back at once, others that no wait
channel stays registered however a request ends.

Model: opus-5-5

.golangci.yml

@@ -61,10 +61,6 @@ linters:
               desc: >-
                 Test-support code belongs in test files and in packages whose
                 directory name ends in test, not in the shipped binary.
-            - pkg: sneak.berlin/go/neoirc/internal/dbtest
-              desc: >-
-                Test-support code belongs in test files and in packages whose
-                directory name ends in test, not in the shipped binary.
     # Only decisions already recorded in the Go package defaults are
     # listed here. Every entry matches the module path exactly.
     gomodguard_v2:

README.md

@@ -268,15 +268,10 @@ rules). Case-sensitive comparison is unambiguous.
 A single user session can have multiple clients (phone, laptop, terminal).
 
 - Each client gets a **separate server-to-client (S2C) message queue**.
-- The server fans out messages and events from other users to every client queue
-  for that user session.
-- When the user sends a `PRIVMSG`, `NOTICE`, `JOIN`, `PART`, `NICK`, `TOPIC`,
-  `MODE` or `KICK` from one of its clients, the resulting event goes to every
-  client queue of the user's own session, as well as to the other users it is
-  meant for. The one exception is an IRC listener connection that sent the
-  command, which gets nothing queued for it: it has already sent its user the
-  echo, or, for `PRIVMSG` and `NOTICE`, IRC sends none.
-- Replies to a command (numerics) go only to the client that sent it.
+- The server fans out messages and events from other users, and the user's own
+  DMs and the channel messages it sends over the HTTP API, to every client queue
+  for that user session. Replies to a command (numerics) go only to the client
+  that sent it.
 - `GET /api/v1/messages` delivers from the calling client's specific queue,
   identified by the auth cookie.
 - Client queues have **independent expiry/pruning** — one client going offline
@@ -643,10 +638,8 @@ Send a message to a channel or user. This is the primary messaging command.
   message echoed back via the queue).
 - If `to` is a bare nick, the message is a DM. The server fans out to the
   recipient and the sender (so all of the sender's clients see the DM).
-- A `body` that is not an array of strings, or a `meta` that is not an object,
-  gets HTTP 400 `invalid request body`, and nothing is relayed. A missing or
-  empty `body` gets ERR_NOTEXTTOSEND (412). A missing `to` gets ERR_NORECIPIENT
-  (411).
+- `body` must be a non-empty array of strings; otherwise the server sends
+  ERR_NOTEXTTOSEND (412). A missing `to` gets ERR_NORECIPIENT (411).
 - Only channel members can send to a channel. A non-member, a banned user, and
   on a `+m` channel a user with neither `+o` nor `+v`, get ERR_CANNOTSENDTOCHAN
   (404).
@@ -751,7 +744,7 @@ Leave a channel.
 {"command": "PART", "to": "#general", "body": ["goodbye"]}
 ```
 
-**S2C (broadcast to all channel members, including the departing user):**
+**S2C (broadcast to the other channel members):**
 
 ```json
 {
@@ -767,8 +760,9 @@ Leave a channel.
 
 **Behavior:**
 
-- The PART event goes to every channel member, the departing user's own clients
-  included. (An IRC listener connection that sends a PART echoes it itself.)
+- The PART event goes to the other channel members, not to the departing user;
+  the HTTP response confirms the part. (The IRC listener echoes the PART to its
+  own connection.)
 - If the channel is empty after the user leaves, the channel is **deleted**
   (ephemeral channels).
 - If the user is not in the channel, the server returns an error.
@@ -1025,8 +1019,9 @@ On the IRC listener, `MODE #channel <modes> [values...]` takes several letters
 in one string, e.g. `MODE #general +mt-i` or `MODE #general +ov alice bob`. It
 accepts `i`, `m`, `n`, `s`, `t`, `o` and `v` (with a nick) and `H` (with bits
 from 1 to 40 when setting), but not `b`, `k` or `l`. A letter whose value is
-missing is skipped. The changes made are sent to every channel member as one
-`MODE` line, e.g. `+o-v alice bob`; the operator gets that line once.
+missing is skipped. The changes made are echoed to the operator's connection and
+also sent to every channel member, the operator included, as one `MODE` line,
+e.g. `+o-v alice bob`.
 
 **Channel errors:**
 
@@ -1238,7 +1233,7 @@ IRC listener sends the usual 3-digit code. Over the HTTP API, 005 arrives named
 | `001` | RPL_WELCOME          | After session creation or login, on MOTD | `{"command":"RPL_WELCOME","code":1,"to":"alice","body":["Welcome to the network, alice"]}`                                                                                                                   |
 | `002` | RPL_YOURHOST         | After session creation or login, on MOTD | `{"command":"RPL_YOURHOST","code":2,"to":"alice","body":["Your host is neoirc, running version 0.1"]}`                                                                                                       |
 | `003` | RPL_CREATED          | After session creation or login, on MOTD | `{"command":"RPL_CREATED","code":3,"to":"alice","body":["This server was created 2026-02-10"]}`                                                                                                              |
-| `004` | RPL_MYINFO           | After session creation or login, on MOTD | `{"command":"RPL_MYINFO","code":4,"to":"alice","params":["neoirc","0.1","ow","Hbiklmnostv"]}`                                                                                                                |
+| `004` | RPL_MYINFO           | After session creation or login, on MOTD | `{"command":"RPL_MYINFO","code":4,"to":"alice","params":["neoirc","0.1","","ikmnostl"]}`                                                                                                                     |
 | `005` | RPL_ISUPPORT         | After session creation or login, on MOTD | `{"command":"RPL_BOUNCE","code":5,"to":"alice","params":["CHANTYPES=#","NICKLEN=32","PREFIX=(ov)@+","CHANMODES=b,k,Hl,imnst","NETWORK=neoirc","CASEMAPPING=ascii"],"body":["are supported by this server"]}` |
 | `221` | RPL_UMODEIS          | In response to user MODE                 | `{"command":"RPL_UMODEIS","code":221,"to":"alice","body":["+"]}`                                                                                                                                             |
 | `251` | RPL_LUSERCLIENT      | On connect, MOTD or LUSERS               | `{"command":"RPL_LUSERCLIENT","code":251,"to":"alice","body":["There are 5 users and 0 invisible on 1 servers"]}`                                                                                            |
@@ -1751,18 +1746,17 @@ command). **Numeric replies**, for success and for errors, are delivered through
 the message queue (see [Numeric Reply Codes](#numeric-reply-codes-s2c-only)); a
 command that has none, such as a successful `PRIVMSG`, is answered by the HTTP
 response alone, and `PING`'s `PONG` is the HTTP response body. HTTP error codes
-(4xx/5xx) are reserved for transport-level problems: a malformed request (400),
+(4xx/5xx) are reserved for transport-level problems: malformed JSON (400),
 missing/invalid auth cookies (401), and server errors (500).
 
 **HTTP errors (transport-level only):**
 
-| Status | Error                  | When                                                                                              |
-| ------ | ---------------------- | ------------------------------------------------------------------------------------------------- |
-| 400    | `invalid request body` | Malformed JSON, or a body over `MAX_MESSAGE_SIZE` bytes                                           |
-| 400    | `invalid request body` | A `PRIVMSG` or `NOTICE` whose `body` is not an array of strings, or whose `meta` is not an object |
-| 400    | `command required`     | Empty command                                                                                     |
-| 401    | `not registered`       | Missing or invalid auth cookie                                                                    |
-| 500    | `internal error`       | Server-side failure                                                                               |
+| Status | Error                  | When                                                    |
+| ------ | ---------------------- | ------------------------------------------------------- |
+| 400    | `invalid request body` | Malformed JSON, or a body over `MAX_MESSAGE_SIZE` bytes |
+| 400    | `command required`     | Empty command                                           |
+| 401    | `not registered`       | Missing or invalid auth cookie                          |
+| 500    | `internal error`       | Server-side failure                                     |
 
 **IRC numeric error replies (delivered via message queue):**
 
@@ -2614,7 +2608,7 @@ listener.
 | Variable               | Type   | Default                                                                                | Description                                                                                                                                                                                                                                                                             |
 | ---------------------- | ------ | -------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `PORT`                 | int    | `8080`                                                                                 | HTTP listen port                                                                                                                                                                                                                                                                        |
-| `DBURL`                | string | `file:///var/lib/neoirc/state.db?_pragma=journal_mode(WAL)&_pragma=busy_timeout(5000)` | SQLite connection string. For file-based: `file:///path/to/db.db?_pragma=journal_mode(WAL)&_pragma=busy_timeout(5000)`. For in-memory (testing): `file::memory:?cache=shared`. It must not set `foreign_keys`. See [SQLite Considerations](#sqlite-considerations).                     |
+| `DBURL`                | string | `file:///var/lib/neoirc/state.db?_pragma=journal_mode(WAL)&_pragma=busy_timeout(5000)` | SQLite connection string. For file-based: `file:///path/to/db.db?_pragma=journal_mode(WAL)&_pragma=busy_timeout(5000)`. For in-memory (testing): `file::memory:?cache=shared`. See [SQLite Considerations](#sqlite-considerations).                                                     |
 | `DEBUG`                | bool   | `false`                                                                                | Switch logging to debug level                                                                                                                                                                                                                                                           |
 | `MESSAGE_MAX_AGE`      | string | `720h`                                                                                 | Maximum age of messages as a Go duration string (e.g. `720h`, `24h`). Messages older than this are pruned. Default is 30 days.                                                                                                                                                          |
 | `SESSION_IDLE_TIMEOUT` | string | `720h`                                                                                 | Idle timeout as a Go duration string (e.g. `720h`, `24h`). Clients with no authenticated HTTP API request or IRC listener command for this long are removed, and a session left with none is expired and its nick released (see [Data Lifecycle](#data-lifecycle)). Default is 30 days. |
@@ -2726,9 +2720,7 @@ Each line of a multi-line `body` reaches an IRC listener user as its own
 is sent, so it cannot start a line of its own. A mode change made over the HTTP
 API reaches IRC listener members as an IRC `MODE` line with its value as a
 separate parameter, e.g. `MODE #general +k secretpass` or
-`MODE #general +o bob`. An `INVITE` from either transport reaches the invited
-IRC listener user as an IRC `INVITE` line from the inviter, e.g.
-`:alice!alice@* INVITE bob #general`.
+`MODE #general +o bob`.
 
 ### Docker Usage
 
@@ -3345,7 +3337,6 @@ neoirc/
 │   │   └── schema/
 │   │       ├── 000.sql     # schema_migrations bootstrap
 │   │       └── 001_initial.sql
-│   ├── dbtest/             # Gives each test its own database; only tests import it
 │   ├── globals/            # Application-wide metadata
 │   │   └── globals.go
 │   ├── handlers/           # HTTP request handlers

internal/cli/api/client.go

@@ -25,10 +25,7 @@ const (
 	httpErrThreshold = 400
 )
 
-var (
-	errHTTP        = errors.New("HTTP error")
-	errJoinRefused = errors.New("the server refused the join")
-)
+var errHTTP = errors.New("HTTP error")
 
 // Client wraps HTTP calls to the neoirc server API.
 type Client struct {
@@ -209,35 +206,13 @@ func (client *Client) PollMessages(
 	}, nil
 }
 
-// JoinChannel joins a channel. It returns an error unless the
-// server answers that the session joined. When the server
-// refuses the join, it sends the reason to the message queue as
-// an error numeric.
+// JoinChannel joins a channel.
 func (client *Client) JoinChannel(channel string) error {
-	data, err := client.do(
-		http.MethodPost, "/api/v1/messages",
+	return client.SendMessage(
 		&Message{ //nolint:exhaustruct // only command+to needed
 			Command: irc.CmdJoin, To: channel,
 		},
 	)
-	if err != nil {
-		return err
-	}
-
-	var resp struct {
-		Status string `json:"status"`
-	}
-
-	err = json.Unmarshal(data, &resp)
-	if err != nil {
-		return fmt.Errorf("decode join: %w", err)
-	}
-
-	if resp.Status != "joined" {
-		return errJoinRefused
-	}
-
-	return nil
 }
 
 // PartChannel leaves a channel.

internal/cli/app.go

@@ -34,42 +34,28 @@ type App struct {
 
 // Run creates and runs the CLI application.
 func Run() {
-	err := run(NewUI())
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-		os.Exit(1)
-	}
-}
-
-// run starts the client on ui and returns when ui stops. Tests
-// call it with ui on a simulation screen.
-func run(ui *UI) error {
 	app := &App{ //nolint:exhaustruct
-		ui:   ui,
+		ui:   NewUI(),
 		nick: "guest",
 	}
 
 	app.ui.OnInput(app.handleInput)
+	app.ui.SetStatus(app.nick, "", "disconnected")
 
-	// SetStatus and AddStatus wait for the event loop, which
-	// app.ui.Run starts below, so they run on a goroutine. The
-	// nick is read first, as a typed /nick may change app.nick.
-	nick := app.nick
+	app.ui.AddStatus(
+		"Welcome to neoirc-cli — an IRC-style client",
+	)
+	app.ui.AddStatus(
+		"Type [yellow]/connect <server-url>" +
+			"[white] to begin, " +
+			"or [yellow]/help[white] for commands",
+	)
 
-	go func() {
-		app.ui.SetStatus(nick, "", "disconnected")
-
-		app.ui.AddStatus(
-			"Welcome to neoirc-cli — an IRC-style client",
-		)
-		app.ui.AddStatus(
-			"Type [yellow]/connect <server-url>" +
-				"[white] to begin, " +
-				"or [yellow]/help[white] for commands",
-		)
-	}()
-
-	return app.ui.Run()
+	err := app.ui.Run()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+		os.Exit(1)
+	}
 }
 
 func (a *App) handleInput(text string) {
@@ -110,7 +96,20 @@ func (a *App) handleInput(text string) {
 		a.ui.AddStatus(
 			"[red]Send error: " + err.Error(),
 		)
+
+		return
 	}
+
+	timestamp := time.Now().Format(timeFormat)
+
+	a.mu.Lock()
+	nick := a.nick
+	a.mu.Unlock()
+
+	a.ui.AddLine(target, fmt.Sprintf(
+		"[gray]%s [green]<%s>[white] %s",
+		timestamp, nick, text,
+	))
 }
 
 func (a *App) handleCommand(text string) {
@@ -199,21 +198,11 @@ func (a *App) cmdConnect(serverURL string) {
 		return
 	}
 
-	// The poll loop of an earlier connection is stopped in the same
-	// step that replaces the client, so it never polls with the new
-	// one.
 	a.mu.Lock()
 	a.client = client
 	a.nick = resp.Nick
 	a.connected = true
 	a.lastQID = 0
-
-	if a.stopPoll != nil {
-		close(a.stopPoll)
-	}
-
-	stop := make(chan struct{})
-	a.stopPoll = stop
 	a.mu.Unlock()
 
 	a.ui.AddStatus(fmt.Sprintf(
@@ -222,7 +211,9 @@ func (a *App) cmdConnect(serverURL string) {
 	))
 	a.ui.SetStatus(resp.Nick, "", "connected")
 
-	go a.pollLoop(stop)
+	a.stopPoll = make(chan struct{})
+
+	go a.pollLoop()
 }
 
 func (a *App) cmdNick(nick string) {
@@ -310,6 +301,9 @@ func (a *App) cmdJoin(channel string) {
 	a.mu.Unlock()
 
 	a.ui.SwitchToBuffer(channel)
+	a.ui.AddLine(channel,
+		"[yellow]*** Joined "+channel,
+	)
 	a.ui.SetStatus(nick, channel, "connected")
 }
 
@@ -344,6 +338,10 @@ func (a *App) cmdPart(channel string) {
 		return
 	}
 
+	a.ui.AddLine(channel,
+		"[yellow]*** Left "+channel,
+	)
+
 	a.mu.Lock()
 	if a.target == channel {
 		a.target = ""
@@ -370,6 +368,7 @@ func (a *App) cmdMsg(args string) {
 
 	a.mu.Lock()
 	connected := a.connected
+	nick := a.nick
 	a.mu.Unlock()
 
 	if !connected {
@@ -387,7 +386,16 @@ func (a *App) cmdMsg(args string) {
 		a.ui.AddStatus(fmt.Sprintf(
 			"[red]Send failed: %v", err,
 		))
+
+		return
 	}
+
+	timestamp := time.Now().Format(timeFormat)
+
+	a.ui.AddLine(target, fmt.Sprintf(
+		"[gray]%s [green]<%s>[white] %s",
+		timestamp, nick, text,
+	))
 }
 
 func (a *App) cmdQuery(nick string) {
@@ -402,16 +410,10 @@ func (a *App) cmdQuery(nick string) {
 	a.mu.Lock()
 	a.target = nick
 	myNick := a.nick
-	connected := a.connected
 	a.mu.Unlock()
 
-	connStatus := "disconnected"
-	if connected {
-		connStatus = "connected"
-	}
-
 	a.ui.SwitchToBuffer(nick)
-	a.ui.SetStatus(myNick, nick, connStatus)
+	a.ui.SetStatus(myNick, nick, "connected")
 }
 
 func (a *App) cmdTopic(args string) {
@@ -638,37 +640,24 @@ func (a *App) cmdWindow(args string) {
 
 	_, _ = fmt.Sscanf(args, "%d", &bufIndex)
 
+	a.ui.SwitchBuffer(bufIndex)
+
 	a.mu.Lock()
 	nick := a.nick
-	connected := a.connected
 	a.mu.Unlock()
 
-	connStatus := "disconnected"
-	if connected {
-		connStatus = "connected"
-	}
-
-	// Read the name before switching. A message from the server can
-	// add a buffer at any time, but only at the end, so bufIndex
-	// still names this buffer when SwitchBuffer runs.
-	name, found := a.ui.BufferName(bufIndex)
-	if found {
-		a.ui.SwitchBuffer(bufIndex)
-
-		if name != "(status)" {
+	if bufIndex >= 0 && bufIndex < a.ui.BufferCount() {
+		buf := a.ui.buffers[bufIndex]
+		if buf.Name != "(status)" {
 			a.mu.Lock()
-			a.target = name
+			a.target = buf.Name
 			a.mu.Unlock()
 
 			a.ui.SetStatus(
-				nick, name, connStatus,
+				nick, buf.Name, "connected",
 			)
 		} else {
-			a.mu.Lock()
-			a.target = ""
-			a.mu.Unlock()
-
-			a.ui.SetStatus(nick, "", connStatus)
+			a.ui.SetStatus(nick, "", "connected")
 		}
 	}
 }
@@ -716,23 +705,16 @@ func (a *App) cmdHelp() {
 	}
 }
 
-// pollLoop long-polls for messages in the background until stop is
-// closed. A later /connect closes stop under a.mu as it replaces the
-// client and the cursor, so the loop checks stop under a.mu too. A
-// stopped loop then neither polls with the new client nor moves the
-// new cursor.
-func (a *App) pollLoop(stop <-chan struct{}) {
+// pollLoop long-polls for messages in the background.
+func (a *App) pollLoop() {
 	for {
-		a.mu.Lock()
-
 		select {
-		case <-stop:
-			a.mu.Unlock()
-
+		case <-a.stopPoll:
 			return
 		default:
 		}
 
+		a.mu.Lock()
 		client := a.client
 		lastQID := a.lastQID
 		a.mu.Unlock()
@@ -750,24 +732,12 @@ func (a *App) pollLoop(stop <-chan struct{}) {
 			continue
 		}
 
-		// A poll sent before stop was closed answers for the earlier
-		// connection.
-		a.mu.Lock()
-
-		select {
-		case <-stop:
-			a.mu.Unlock()
-
-			return
-		default:
-		}
-
 		if result.LastID > 0 {
+			a.mu.Lock()
 			a.lastQID = result.LastID
+			a.mu.Unlock()
 		}
 
-		a.mu.Unlock()
-
 		for i := range result.Messages {
 			a.handleServerMessage(&result.Messages[i])
 		}
@@ -787,7 +757,7 @@ func (a *App) handleServerMessage(msg *api.Message) {
 	case irc.CmdJoin:
 		a.handleJoinEvent(msg, timestamp)
 	case irc.CmdPart:
-		a.handlePartEvent(msg, timestamp, myNick)
+		a.handlePartEvent(msg, timestamp)
 	case irc.CmdQuit:
 		a.handleQuitEvent(msg, timestamp)
 	case irc.CmdNick:
@@ -815,10 +785,12 @@ func (a *App) handlePrivmsgEvent(
 	lines := msg.BodyLines()
 	text := strings.Join(lines, " ")
 
-	// A direct message shows in the buffer of the other user:
-	// the recipient of one the user sent, else the sender.
+	if msg.From == myNick {
+		return
+	}
+
 	target := msg.To
-	if !strings.HasPrefix(target, "#") && msg.From != myNick {
+	if !strings.HasPrefix(target, "#") {
 		target = msg.From
 	}
 
@@ -841,11 +813,8 @@ func (a *App) handleJoinEvent(
 	))
 }
 
-// handlePartEvent shows a part in the channel's buffer. The
-// user's own part does not mark the channel unread: the user
-// has just left it.
 func (a *App) handlePartEvent(
-	msg *api.Message, timestamp, myNick string,
+	msg *api.Message, timestamp string,
 ) {
 	if msg.To == "" {
 		return
@@ -854,22 +823,17 @@ func (a *App) handlePartEvent(
 	lines := msg.BodyLines()
 	reason := strings.Join(lines, " ")
 
-	line := fmt.Sprintf(
-		"[gray]%s [yellow]*** %s has left %s",
-		timestamp, msg.From, msg.To,
-	)
-
 	if reason != "" {
-		line += " (" + reason + ")"
+		a.ui.AddLine(msg.To, fmt.Sprintf(
+			"[gray]%s [yellow]*** %s has left %s (%s)",
+			timestamp, msg.From, msg.To, reason,
+		))
+	} else {
+		a.ui.AddLine(msg.To, fmt.Sprintf(
+			"[gray]%s [yellow]*** %s has left %s",
+			timestamp, msg.From, msg.To,
+		))
 	}
-
-	if msg.From == myNick {
-		a.ui.AddLineAsRead(msg.To, line)
-
-		return
-	}
-
-	a.ui.AddLine(msg.To, line)
 }
 
 func (a *App) handleQuitEvent(

internal/cli/ui.go

@@ -16,10 +16,7 @@ type Buffer struct {
 	Unread int
 }
 
-// UI manages the terminal interface. Most of its methods wait for
-// the tview event loop to run their update. Code that runs on that
-// loop, such as a key handler, must not call them: it would wait
-// for itself.
+// UI manages the terminal interface.
 type UI struct {
 	app       *tview.Application
 	messages  *tview.TextView
@@ -30,17 +27,7 @@ type UI struct {
 	buffers       []*Buffer
 	currentBuffer int
 
-	// The nick, target and connection state last passed to
-	// SetStatus.
-	nick       string
-	target     string
-	connStatus string
-
 	onInput func(string)
-	// inputDone is closed once the line last passed to onInput
-	// has been handled. Only callOnInput, on the event loop, uses
-	// it.
-	inputDone chan struct{}
 }
 
 // NewUI creates the tview-based IRC-like UI.
@@ -108,19 +95,6 @@ func (ui *UI) AddLine(bufferName, line string) {
 	})
 }
 
-// AddLineAsRead adds a line to the specified buffer, as
-// AddLine does, but does not mark the buffer unread.
-func (ui *UI) AddLineAsRead(bufferName, line string) {
-	ui.app.QueueUpdateDraw(func() {
-		buf := ui.getOrCreateBuffer(bufferName)
-		buf.Lines = append(buf.Lines, line)
-
-		if ui.buffers[ui.currentBuffer] == buf {
-			_, _ = fmt.Fprintln(ui.messages, line)
-		}
-	})
-}
-
 // AddStatus adds a line to the status buffer.
 func (ui *UI) AddStatus(line string) {
 	ts := time.Now().Format("15:04")
@@ -185,32 +159,13 @@ func (ui *UI) SetStatus(
 	nick, target, connStatus string,
 ) {
 	ui.app.QueueUpdateDraw(func() {
-		ui.nick = nick
-		ui.target = target
-		ui.connStatus = connStatus
-
-		ui.refreshStatusBar()
+		ui.renderStatusBar(nick, target, connStatus)
 	})
 }
 
-// BufferName returns the name of the buffer at index bufIndex,
-// and whether there is such a buffer.
-func (ui *UI) BufferName(bufIndex int) (string, bool) {
-	var (
-		name  string
-		found bool
-	)
-
-	ui.app.QueueUpdate(func() {
-		if bufIndex < 0 || bufIndex >= len(ui.buffers) {
-			return
-		}
-
-		name = ui.buffers[bufIndex].Name
-		found = true
-	})
-
-	return name, found
+// BufferCount returns the number of buffers.
+func (ui *UI) BufferCount() int {
+	return len(ui.buffers)
 }
 
 // BufferIndex returns the index of a named buffer.
@@ -236,10 +191,8 @@ func (ui *UI) initMessages() {
 }
 
 func (ui *UI) initStatusBar() {
-	// Colour tags stay off. With them on, tview reads text in
-	// square brackets, such as "[connected]" or part of a nick,
-	// as a tag and drops it.
-	ui.statusBar = tview.NewTextView()
+	ui.statusBar = tview.NewTextView().
+		SetDynamicColors(true)
 	ui.statusBar.SetBackgroundColor(tcell.ColorNavy)
 	ui.statusBar.SetTextColor(tcell.ColorWhite)
 }
@@ -260,7 +213,10 @@ func (ui *UI) initInput() {
 		}
 
 		ui.input.SetText("")
-		ui.callOnInput(text)
+
+		if ui.onInput != nil {
+			ui.onInput(text)
+		}
 	})
 }
 
@@ -271,11 +227,10 @@ func (ui *UI) initKeyCapture() {
 				return event
 			}
 
-			// Alt and a digit runs /window with that digit.
-			// SwitchBuffer alone would leave the target as it was.
 			r := event.Rune()
 			if r >= '0' && r <= '9' {
-				ui.callOnInput("/window " + string(r))
+				idx := int(r - '0')
+				ui.SwitchBuffer(idx)
 
 				return nil
 			}
@@ -285,35 +240,8 @@ func (ui *UI) initKeyCapture() {
 	)
 }
 
-// callOnInput passes text to the input callback on a new
-// goroutine. The key handlers call it on the event loop, and the
-// callback waits for that loop to update the screen, so they must
-// not wait for the callback. The goroutine first waits for the
-// line before it to be handled, which keeps lines in the order
-// they were typed.
-func (ui *UI) callOnInput(text string) {
-	if ui.onInput == nil {
-		return
-	}
-
-	previous := ui.inputDone
-	done := make(chan struct{})
-	ui.inputDone = done
-
-	go func() {
-		if previous != nil {
-			<-previous
-		}
-
-		ui.onInput(text)
-		close(done)
-	}()
-}
-
-// refreshStatusBar redraws the status bar with the nick, target
-// and connection state last passed to SetStatus.
 func (ui *UI) refreshStatusBar() {
-	ui.renderStatusBar(ui.nick, ui.target, ui.connStatus)
+	// Placeholder; full refresh needs nick/target context.
 }
 
 func (ui *UI) renderStatusBar(

internal/config/config.go

@@ -3,12 +3,8 @@ package config
 
 import (
 	"errors"
-	"fmt"
 	"log/slog"
-	"math"
 	"os"
-	"strconv"
-	"time"
 
 	"github.com/spf13/viper"
 	"go.uber.org/fx"
@@ -32,8 +28,6 @@ Type /help for available commands.`
 const DefaultDBURL = "file:///var/lib/neoirc/state.db" +
 	"?_pragma=journal_mode(WAL)&_pragma=busy_timeout(5000)"
 
-var errOutOfRange = errors.New("setting out of range")
-
 // Params defines the dependencies for creating a Config.
 type Params struct {
 	fx.In
@@ -69,8 +63,6 @@ type Config struct {
 }
 
 // New creates a new Config by reading from files and environment variables.
-// It returns an error when a number, true/false or duration setting does
-// not parse or is out of range.
 func New(
 	_ fx.Lifecycle, params Params,
 ) (*Config, error) {
@@ -115,27 +107,29 @@ func New(
 
 	cfg := &Config{
 		DBURL:              viper.GetString("DBURL"),
+		Debug:              viper.GetBool("DEBUG"),
+		Port:               viper.GetInt("PORT"),
 		SentryDSN:          viper.GetString("SENTRY_DSN"),
+		MaintenanceMode:    viper.GetBool("MAINTENANCE_MODE"),
 		MetricsUsername:    viper.GetString("METRICS_USERNAME"),
 		MetricsPassword:    viper.GetString("METRICS_PASSWORD"),
 		MessageMaxAge:      viper.GetString("MESSAGE_MAX_AGE"),
+		MaxMessageSize:     viper.GetInt("MAX_MESSAGE_SIZE"),
 		QueueMaxAge:        viper.GetString("QUEUE_MAX_AGE"),
 		MOTD:               viper.GetString("MOTD"),
 		ServerName:         viper.GetString("SERVER_NAME"),
 		FederationKey:      viper.GetString("FEDERATION_KEY"),
 		SessionIdleTimeout: viper.GetString("SESSION_IDLE_TIMEOUT"),
+		HashcashBits:       viper.GetInt("NEOIRC_HASHCASH_BITS"),
 		OperName:           viper.GetString("NEOIRC_OPER_NAME"),
 		OperPassword:       viper.GetString("NEOIRC_OPER_PASSWORD"),
+		LoginRateLimit:     viper.GetFloat64("LOGIN_RATE_LIMIT"),
+		LoginRateBurst:     viper.GetInt("LOGIN_RATE_BURST"),
 		IRCListenAddr:      viper.GetString("IRC_LISTEN_ADDR"),
 		log:                log,
 		params:             &params,
 	}
 
-	err = parseSettings(cfg)
-	if err != nil {
-		return nil, err
-	}
-
 	// Viper counts an empty environment variable as unset, but an
 	// empty IRC_LISTEN_ADDR must turn the IRC listener off.
 	ircListenAddr, set := os.LookupEnv("IRC_LISTEN_ADDR")
@@ -150,93 +144,3 @@ func New(
 
 	return cfg, nil
 }
-
-// parseSettings reads the number and true/false settings into cfg and
-// checks the duration settings. Each number and duration must be above
-// zero. PORT and NEOIRC_HASHCASH_BITS may also be zero: port 0 lets the
-// system pick a port, and 0 bits turns proof of work off. The error
-// names each setting that does not parse or is out of range.
-func parseSettings(cfg *Config) error {
-	return errors.Join(
-		parseInt("PORT", 0, &cfg.Port),
-		parseInt("MAX_MESSAGE_SIZE", 1, &cfg.MaxMessageSize),
-		parseInt("NEOIRC_HASHCASH_BITS", 0, &cfg.HashcashBits),
-		parseInt("LOGIN_RATE_BURST", 1, &cfg.LoginRateBurst),
-		parseFloat("LOGIN_RATE_LIMIT", &cfg.LoginRateLimit),
-		parseBool("DEBUG", &cfg.Debug),
-		parseBool("MAINTENANCE_MODE", &cfg.MaintenanceMode),
-		checkDuration("MESSAGE_MAX_AGE", cfg.MessageMaxAge),
-		checkDuration("QUEUE_MAX_AGE", cfg.QueueMaxAge),
-		checkDuration("SESSION_IDLE_TIMEOUT", cfg.SessionIdleTimeout),
-	)
-}
-
-// parseInt sets *value to the setting key read as a whole number. It
-// returns an error when the value does not parse or is below minimum.
-func parseInt(key string, minimum int, value *int) error {
-	raw := viper.GetString(key)
-
-	parsed, err := strconv.Atoi(raw)
-	if err != nil {
-		return fmt.Errorf("cannot parse %s: %w", key, err)
-	}
-
-	if parsed < minimum {
-		return fmt.Errorf("%w: %s is %s, but must be at least %d",
-			errOutOfRange, key, raw, minimum)
-	}
-
-	*value = parsed
-
-	return nil
-}
-
-// parseFloat sets *value to the setting key read as a floating-point
-// number. It returns an error when the value does not parse or is not a
-// finite number above zero.
-func parseFloat(key string, value *float64) error {
-	raw := viper.GetString(key)
-
-	parsed, err := strconv.ParseFloat(raw, 64)
-	if err != nil {
-		return fmt.Errorf("cannot parse %s: %w", key, err)
-	}
-
-	if math.IsNaN(parsed) || math.IsInf(parsed, 0) || parsed <= 0 {
-		return fmt.Errorf(
-			"%w: %s is %s, but must be a finite number above zero",
-			errOutOfRange, key, raw)
-	}
-
-	*value = parsed
-
-	return nil
-}
-
-// parseBool sets *value to the setting key read as true or false.
-func parseBool(key string, value *bool) error {
-	parsed, err := strconv.ParseBool(viper.GetString(key))
-	if err != nil {
-		return fmt.Errorf("cannot parse %s: %w", key, err)
-	}
-
-	*value = parsed
-
-	return nil
-}
-
-// checkDuration returns an error naming the setting key when value is
-// not a Go duration above zero.
-func checkDuration(key, value string) error {
-	duration, err := time.ParseDuration(value)
-	if err != nil {
-		return fmt.Errorf("cannot parse %s: %w", key, err)
-	}
-
-	if duration <= 0 {
-		return fmt.Errorf("%w: %s is %s, but must be above zero",
-			errOutOfRange, key, value)
-	}
-
-	return nil
-}

internal/config/config_test.go

@@ -2,7 +2,6 @@ package config_test
 
 import (
 	"os"
-	"strings"
 	"testing"
 	"time"
 
@@ -11,8 +10,7 @@ import (
 	"sneak.berlin/go/neoirc/internal/logger"
 )
 
-// loadConfig runs config.New and returns its result.
-func loadConfig(t *testing.T) (*config.Config, error) {
+func newConfig(t *testing.T) *config.Config {
 	t.Helper()
 
 	globs := &globals.Globals{
@@ -26,15 +24,9 @@ func loadConfig(t *testing.T) (*config.Config, error) {
 		t.Fatal(err)
 	}
 
-	return config.New(
+	cfg, err := config.New(
 		nil, config.Params{Globals: globs, Logger: log},
 	)
-}
-
-func newConfig(t *testing.T) *config.Config {
-	t.Helper()
-
-	cfg, err := loadConfig(t)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -42,145 +34,6 @@ func newConfig(t *testing.T) *config.Config {
 	return cfg
 }
 
-func TestUnsetSettingsKeepDefaults(t *testing.T) {
-	// Viper counts an empty environment variable as unset.
-	t.Setenv("PORT", "")
-	t.Setenv("MAX_MESSAGE_SIZE", "")
-	t.Setenv("NEOIRC_HASHCASH_BITS", "")
-	t.Setenv("LOGIN_RATE_BURST", "")
-	t.Setenv("LOGIN_RATE_LIMIT", "")
-	t.Setenv("DEBUG", "")
-	t.Setenv("MAINTENANCE_MODE", "")
-	t.Setenv("MESSAGE_MAX_AGE", "")
-	t.Setenv("QUEUE_MAX_AGE", "")
-	t.Setenv("SESSION_IDLE_TIMEOUT", "")
-
-	// Each duration setting defaults to 30 days.
-	const thirtyDays = "720h"
-
-	want := settings{
-		Port:               8080,
-		MaxMessageSize:     4096,
-		HashcashBits:       20,
-		LoginRateBurst:     5,
-		LoginRateLimit:     1,
-		Debug:              false,
-		MaintenanceMode:    false,
-		MessageMaxAge:      thirtyDays,
-		QueueMaxAge:        thirtyDays,
-		SessionIdleTimeout: thirtyDays,
-	}
-
-	got := settingsOf(newConfig(t))
-	if got != want {
-		t.Errorf("settings = %+v, want %+v", got, want)
-	}
-}
-
-func TestValidSettingsAreUsed(t *testing.T) {
-	// Each whole number is the lowest value its setting allows, and 1ns
-	// is the shortest duration allowed.
-	t.Setenv("PORT", "0")
-	t.Setenv("MAX_MESSAGE_SIZE", "1")
-	t.Setenv("NEOIRC_HASHCASH_BITS", "0")
-	t.Setenv("LOGIN_RATE_BURST", "1")
-	t.Setenv("LOGIN_RATE_LIMIT", "0.5")
-	t.Setenv("DEBUG", "true")
-	t.Setenv("MAINTENANCE_MODE", "true")
-	t.Setenv("MESSAGE_MAX_AGE", "1ns")
-	t.Setenv("QUEUE_MAX_AGE", "1h30m")
-	t.Setenv("SESSION_IDLE_TIMEOUT", "45m")
-
-	want := settings{
-		Port:               0,
-		MaxMessageSize:     1,
-		HashcashBits:       0,
-		LoginRateBurst:     1,
-		LoginRateLimit:     0.5,
-		Debug:              true,
-		MaintenanceMode:    true,
-		MessageMaxAge:      "1ns",
-		QueueMaxAge:        "1h30m",
-		SessionIdleTimeout: "45m",
-	}
-
-	got := settingsOf(newConfig(t))
-	if got != want {
-		t.Errorf("settings = %+v, want %+v", got, want)
-	}
-}
-
-// settings holds the Config fields whose settings config.New parses.
-type settings struct {
-	Port               int
-	MaxMessageSize     int
-	HashcashBits       int
-	LoginRateBurst     int
-	LoginRateLimit     float64
-	Debug              bool
-	MaintenanceMode    bool
-	MessageMaxAge      string
-	QueueMaxAge        string
-	SessionIdleTimeout string
-}
-
-func settingsOf(cfg *config.Config) settings {
-	return settings{
-		Port:               cfg.Port,
-		MaxMessageSize:     cfg.MaxMessageSize,
-		HashcashBits:       cfg.HashcashBits,
-		LoginRateBurst:     cfg.LoginRateBurst,
-		LoginRateLimit:     cfg.LoginRateLimit,
-		Debug:              cfg.Debug,
-		MaintenanceMode:    cfg.MaintenanceMode,
-		MessageMaxAge:      cfg.MessageMaxAge,
-		QueueMaxAge:        cfg.QueueMaxAge,
-		SessionIdleTimeout: cfg.SessionIdleTimeout,
-	}
-}
-
-func TestBadSettingStopsStartup(t *testing.T) {
-	// For each setting, the first value does not parse and the others
-	// parse but are out of range.
-	tests := []struct {
-		key    string
-		values []string
-	}{
-		{key: "PORT", values: []string{"80a", "-1"}},
-		{key: "MAX_MESSAGE_SIZE", values: []string{"4k", "0", "-4096"}},
-		{key: "NEOIRC_HASHCASH_BITS", values: []string{"twenty", "-1"}},
-		{key: "LOGIN_RATE_BURST", values: []string{"five", "0", "-5"}},
-		{key: "LOGIN_RATE_LIMIT", values: []string{
-			"fast", "0", "-1", "NaN", "Inf", "-Inf",
-		}},
-		{key: "DEBUG", values: []string{"yes"}},
-		{key: "MAINTENANCE_MODE", values: []string{"on"}},
-		{key: "MESSAGE_MAX_AGE", values: []string{"30d", "0", "-1h"}},
-		{key: "QUEUE_MAX_AGE", values: []string{"720", "0s", "-24h"}},
-		{key: "SESSION_IDLE_TIMEOUT", values: []string{"a month", "0", "-1m"}},
-	}
-
-	for _, test := range tests {
-		for _, value := range test.values {
-			t.Run(test.key+"="+value, func(t *testing.T) {
-				t.Setenv(test.key, value)
-
-				_, err := loadConfig(t)
-				if err == nil {
-					t.Fatalf("%s=%q: got no error", test.key, value)
-				}
-
-				msg := err.Error()
-				if !strings.Contains(msg, test.key) ||
-					!strings.Contains(msg, value) {
-					t.Errorf("error %q does not name %s and %q",
-						msg, test.key, value)
-				}
-			})
-		}
-	}
-}
-
 func TestIRCListenAddrUnsetKeepsDefault(t *testing.T) {
 	// t.Setenv puts back whatever value was there after the test.
 	t.Setenv("IRC_LISTEN_ADDR", "")

internal/db/db.go

@@ -5,11 +5,9 @@ import (
 	"context"
 	"database/sql"
 	"embed"
-	"errors"
 	"fmt"
 	"io/fs"
 	"log/slog"
-	"net/url"
 	"sort"
 	"strconv"
 	"strings"
@@ -24,10 +22,6 @@ import (
 
 const minMigrationParts = 2
 
-var errForeignKeysInDBURL = errors.New(
-	"DBURL must not set foreign_keys, which the server always turns on",
-)
-
 // SchemaFiles contains embedded SQL migration files.
 //
 //go:embed schema/*.sql
@@ -96,33 +90,6 @@ func (database *Database) connect(ctx context.Context) error {
 		dbURL = config.DefaultDBURL
 	}
 
-	// SQLite keeps the foreign keys setting per connection. The driver
-	// runs each _pragma parameter on every connection it opens. So the
-	// one added below also covers the connection the pool opens after
-	// a cancelled query breaks the old one. A foreign_keys pragma in
-	// DBURL could undo it, because the driver sorts the pragmas.
-	_, query, hasQuery := strings.Cut(dbURL, "?")
-
-	urlParams, err := url.ParseQuery(query)
-	if err != nil {
-		return fmt.Errorf("parse DBURL: %w", err)
-	}
-
-	for _, pragma := range urlParams["_pragma"] {
-		if strings.Contains(strings.ToLower(pragma), "foreign_keys") {
-			return fmt.Errorf(
-				"%w: _pragma=%s", errForeignKeysInDBURL, pragma,
-			)
-		}
-	}
-
-	separator := "?"
-	if hasQuery {
-		separator = "&"
-	}
-
-	dbURL += separator + "_pragma=foreign_keys(1)"
-
 	database.log.Info(
 		"connecting to database", "url", dbURL,
 	)
@@ -142,6 +109,13 @@ func (database *Database) connect(ctx context.Context) error {
 	database.conn = conn
 	database.log.Info("database connected")
 
+	_, err = database.conn.ExecContext(
+		ctx, "PRAGMA foreign_keys = ON",
+	)
+	if err != nil {
+		return fmt.Errorf("enable foreign keys: %w", err)
+	}
+
 	return database.runMigrations(ctx)
 }
 

internal/db/db_test.go

@@ -1,34 +1,19 @@
 package db_test
 
 import (
-	"context"
-	"errors"
-	"net/url"
 	"path/filepath"
 	"strings"
 	"testing"
-	"time"
 
 	"go.uber.org/fx/fxtest"
 	"sneak.berlin/go/neoirc/internal/config"
 	"sneak.berlin/go/neoirc/internal/db"
-	"sneak.berlin/go/neoirc/internal/dbtest"
 	"sneak.berlin/go/neoirc/internal/globals"
 	"sneak.berlin/go/neoirc/internal/logger"
 )
 
 const wantBusyTimeoutMS = 5000
 
-const (
-	// endlessQuery counts the rows of a recursive query that never
-	// stops, so it runs until its context ends.
-	endlessQuery = `WITH RECURSIVE n(x) AS
-		(SELECT 1 UNION ALL SELECT x + 1 FROM n)
-		SELECT COUNT(*) FROM n`
-
-	endlessQueryTimeout = 100 * time.Millisecond
-)
-
 // TestDefaultDBURLSetsWALAndBusyTimeout opens a file database
 // with the default URL's parameters the way the server does,
 // and checks the journal mode and busy timeout it ends up with.
@@ -88,191 +73,3 @@ func TestDefaultDBURLSetsWALAndBusyTimeout(t *testing.T) {
 		)
 	}
 }
-
-// TestForeignKeysOnAfterCancelledQuery cancels a query while it
-// runs, which makes the pool close its only connection and open a
-// new one. A TEMP table lasts only as long as its connection, so
-// its absence shows the connection was replaced. The test then
-// checks that the file database keeps its tables and that the new
-// connection has foreign keys on.
-func TestForeignKeysOnAfterCancelledQuery(t *testing.T) {
-	t.Parallel()
-
-	_, defaultParams, _ := strings.Cut(config.DefaultDBURL, "?")
-
-	urlParams := map[string]string{
-		"default parameters": "?" + defaultParams,
-		"no parameters":      "",
-	}
-
-	for name, params := range urlParams {
-		t.Run(name, func(t *testing.T) {
-			t.Parallel()
-
-			dbURL := "file://" +
-				filepath.Join(t.TempDir(), "state.db") + params
-
-			database, err := startDatabase(t, dbURL)
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			_, err = database.GetDB().ExecContext(
-				t.Context(), "CREATE TEMP TABLE first_connection (x)",
-			)
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			ctx, cancel := context.WithTimeout(
-				t.Context(), endlessQueryTimeout,
-			)
-			defer cancel()
-
-			_, err = database.GetDB().ExecContext(ctx, endlessQuery)
-			if !errors.Is(err, context.DeadlineExceeded) {
-				t.Fatalf("endless query: err = %v", err)
-			}
-
-			tempTables := queryInt(
-				t, database, "SELECT COUNT(*) FROM sqlite_temp_schema",
-			)
-			if tempTables != 0 {
-				t.Fatal("the pool kept its first connection")
-			}
-
-			migrations := queryInt(
-				t, database, "SELECT COUNT(*) FROM schema_migrations",
-			)
-			if migrations == 0 {
-				t.Error("schema_migrations is empty")
-			}
-
-			foreignKeys := queryInt(t, database, "PRAGMA foreign_keys")
-			if foreignKeys != 1 {
-				t.Errorf("foreign_keys = %d, want 1", foreignKeys)
-			}
-		})
-	}
-}
-
-// TestNewURLKeepsDataAfterCancelledQuery cancels a query on a test
-// database while it runs, which makes the pool close its only
-// connection and open a new one. A TEMP table lasts only as long as
-// its connection, so its absence shows the connection was replaced.
-// The database must still have its tables and rows.
-func TestNewURLKeepsDataAfterCancelledQuery(t *testing.T) {
-	t.Parallel()
-
-	database, err := startDatabase(t, dbtest.NewURL(t))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = database.GetOrCreateChannel(t.Context(), "#test")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = database.GetDB().ExecContext(
-		t.Context(), "CREATE TEMP TABLE first_connection (x)",
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	ctx, cancel := context.WithTimeout(t.Context(), endlessQueryTimeout)
-	defer cancel()
-
-	_, err = database.GetDB().ExecContext(ctx, endlessQuery)
-	if !errors.Is(err, context.DeadlineExceeded) {
-		t.Fatalf("endless query: err = %v", err)
-	}
-
-	tempTables := queryInt(
-		t, database, "SELECT COUNT(*) FROM sqlite_temp_schema",
-	)
-	if tempTables != 0 {
-		t.Fatal("the pool kept its first connection")
-	}
-
-	channels := queryInt(t, database, "SELECT COUNT(*) FROM channels")
-	if channels != 1 {
-		t.Errorf("channels = %d, want 1", channels)
-	}
-}
-
-// TestDBURLSettingForeignKeysFailsStartup checks that the database
-// refuses to start when DBURL sets foreign_keys itself, however it
-// is spelled.
-func TestDBURLSettingForeignKeysFailsStartup(t *testing.T) {
-	t.Parallel()
-
-	pragmas := []string{
-		"foreign_keys(0)",
-		"foreign_keys(off)",
-		"foreign_keys=0",
-		"FOREIGN_KEYS(FALSE)",
-		" Foreign_Keys = 1",
-	}
-
-	for _, pragma := range pragmas {
-		t.Run(pragma, func(t *testing.T) {
-			t.Parallel()
-
-			dbURL := "file://" +
-				filepath.Join(t.TempDir(), "state.db") +
-				"?_pragma=" + url.QueryEscape(pragma)
-
-			_, err := startDatabase(t, dbURL)
-			if err == nil {
-				t.Fatal("the database started")
-			}
-
-			if !strings.Contains(err.Error(), "DBURL") {
-				t.Errorf("error %q does not name DBURL", err)
-			}
-		})
-	}
-}
-
-// startDatabase starts a Database for dbURL the way the server does.
-// It returns the error that stopped it from starting, if any.
-func startDatabase(t *testing.T, dbURL string) (*db.Database, error) {
-	t.Helper()
-
-	lifecycle := fxtest.NewLifecycle(t)
-
-	log, err := logger.New(lifecycle, logger.Params{
-		Globals: &globals.Globals{},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	database, err := db.New(lifecycle, db.Params{
-		Logger: log,
-		Config: &config.Config{DBURL: dbURL},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	t.Cleanup(lifecycle.RequireStop)
-
-	return database, lifecycle.Start(t.Context())
-}
-
-// queryInt runs a query that returns a single number.
-func queryInt(t *testing.T, database *db.Database, query string) int {
-	t.Helper()
-
-	var result int
-
-	err := database.GetDB().QueryRowContext(t.Context(), query).Scan(&result)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	return result
-}

internal/db/export_test.go

@@ -5,16 +5,21 @@ import (
 	"database/sql"
 	"fmt"
 	"log/slog"
-	"testing"
-
-	"sneak.berlin/go/neoirc/internal/dbtest"
+	"sync/atomic"
 )
 
-// NewTestDatabase creates an in-memory database for testing.
-func NewTestDatabase(tb testing.TB) (*Database, error) {
-	tb.Helper()
+//nolint:gochecknoglobals // test counter
+var testDBCounter atomic.Int64
 
-	dsn := dbtest.NewURL(tb) + "&_pragma=foreign_keys(1)"
+// NewTestDatabase creates an in-memory database for testing.
+func NewTestDatabase() (*Database, error) {
+	counter := testDBCounter.Add(1)
+
+	dsn := fmt.Sprintf(
+		"file:testdb%d?mode=memory"+
+			"&cache=shared&_pragma=foreign_keys(1)",
+		counter,
+	)
 
 	conn, err := sql.Open("sqlite", dsn)
 	if err != nil {

internal/db/queries.go

@@ -264,25 +264,6 @@ func (database *Database) GetSessionByNick(
 	return sessionID, nil
 }
 
-// GetSessionNick returns the nick a session holds.
-func (database *Database) GetSessionNick(
-	ctx context.Context,
-	sessionID int64,
-) (string, error) {
-	var nick string
-
-	err := database.conn.QueryRowContext(
-		ctx,
-		"SELECT nick FROM sessions WHERE id = ?",
-		sessionID,
-	).Scan(&nick)
-	if err != nil {
-		return "", fmt.Errorf("get session nick: %w", err)
-	}
-
-	return nick, nil
-}
-
 // SessionHostInfo holds the username, hostname, and IP
 // for a session.
 type SessionHostInfo struct {
@@ -1227,12 +1208,11 @@ func insertMessageInTx(
 	return dbID, msgUUID, nil
 }
 
-// EnqueueToSession adds a message to the queues of all
-// clients of a session except client skipClientID, or of all
-// of them when skipClientID is 0.
+// EnqueueToSession adds a message to all clients of a
+// session's queues.
 func (database *Database) EnqueueToSession(
 	ctx context.Context,
-	sessionID, messageID, skipClientID int64,
+	sessionID, messageID int64,
 ) error {
 	transaction, err := database.conn.BeginTx(ctx, nil)
 	if err != nil {
@@ -1241,9 +1221,7 @@ func (database *Database) EnqueueToSession(
 
 	defer func() { _ = transaction.Rollback() }()
 
-	err = enqueueToSessionInTx(
-		ctx, transaction, sessionID, messageID, skipClientID,
-	)
+	err = enqueueToSessionInTx(ctx, transaction, sessionID, messageID)
 	if err != nil {
 		return err
 	}
@@ -1261,15 +1239,15 @@ func (database *Database) EnqueueToSession(
 func enqueueToSessionInTx(
 	ctx context.Context,
 	transaction *sql.Tx,
-	sessionID, messageID, skipClientID int64,
+	sessionID, messageID int64,
 ) error {
 	_, err := transaction.ExecContext(ctx,
 		`INSERT OR IGNORE INTO client_queues
 		 (client_id, message_id, created_at)
 		 SELECT c.id, ?, ?
 		 FROM clients c
-		 WHERE c.session_id = ? AND c.id != ?`,
-		messageID, time.Now(), sessionID, skipClientID)
+		 WHERE c.session_id = ?`,
+		messageID, time.Now(), sessionID)
 	if err != nil {
 		return fmt.Errorf(
 			"enqueue to session: %w", err,
@@ -1695,7 +1673,7 @@ func quitSessionInTx(
 
 	for _, peerID := range peerIDs {
 		err = enqueueToSessionInTx(
-			ctx, transaction, peerID, messageID, 0,
+			ctx, transaction, peerID, messageID,
 		)
 		if err != nil {
 			return nil, err

internal/db/queries_test.go

@@ -13,7 +13,7 @@ import (
 func setupTestDB(t *testing.T) *db.Database {
 	t.Helper()
 
-	database, err := db.NewTestDatabase(t)
+	database, err := db.NewTestDatabase()
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -675,7 +675,7 @@ func TestPollMessages(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	err = database.EnqueueToSession(ctx, sid, dbID, 0)
+	err = database.EnqueueToSession(ctx, sid, dbID)
 	if err != nil {
 		t.Fatal(err)
 	}

internal/dbtest/dbtest.go

@@ -1,39 +0,0 @@
-// Package dbtest gives each test a database of its own. Only tests
-// may import it.
-package dbtest
-
-import (
-	"crypto/rand"
-	"database/sql"
-	"testing"
-
-	_ "modernc.org/sqlite" // registers the sqlite driver
-)
-
-// NewURL returns the URL of a new, empty in-memory database for one
-// test. SQLite deletes an in-memory database when its last connection
-// closes. A pool closes a connection when a query on it is cancelled
-// while it runs. So this function holds a connection of its own open
-// until the test ends.
-func NewURL(tb testing.TB) string {
-	tb.Helper()
-
-	// A random name, so that no other test can share the database.
-	dbURL := "file:" + rand.Text() + "?mode=memory&cache=shared"
-
-	pool, err := sql.Open("sqlite", dbURL)
-	if err != nil {
-		tb.Fatalf("open test database: %v", err)
-	}
-
-	tb.Cleanup(func() { _ = pool.Close() })
-
-	conn, err := pool.Conn(tb.Context())
-	if err != nil {
-		tb.Fatalf("connect to test database: %v", err)
-	}
-
-	tb.Cleanup(func() { _ = conn.Close() })
-
-	return dbURL
-}

internal/handlers/api.go

@@ -412,7 +412,7 @@ func (hdlr *Handlers) deliverWelcome(
 	// 004 RPL_MYINFO
 	hdlr.enqueueNumeric(
 		ctx, clientID, irc.RplMyInfo, nick,
-		[]string{srvName, version, service.UserModes, "Hbiklmnostv"},
+		[]string{srvName, version, "", "ikmnostl"},
 		"",
 	)
 
@@ -994,7 +994,7 @@ func (hdlr *Handlers) dispatchCommand(
 		hdlr.handlePrivmsg(
 			writer, request,
 			sessionID, clientID, nick,
-			command, target, body, meta,
+			command, target, body, meta, bodyLines,
 		)
 	case irc.CmdJoin:
 		hdlr.handleJoin(
@@ -1139,18 +1139,8 @@ func (hdlr *Handlers) handlePrivmsg(
 	nick, command, target string,
 	body json.RawMessage,
 	meta json.RawMessage,
+	bodyLines func() []string,
 ) {
-	lines, ok := checkBodyAndMeta(body, meta)
-	if !ok {
-		hdlr.respondError(
-			writer, request,
-			"invalid request body",
-			http.StatusBadRequest,
-		)
-
-		return
-	}
-
 	if target == "" {
 		hdlr.enqueueNumeric(
 			request.Context(), clientID,
@@ -1165,6 +1155,7 @@ func (hdlr *Handlers) handlePrivmsg(
 		return
 	}
 
+	lines := bodyLines()
 	if len(lines) == 0 {
 		hdlr.enqueueNumeric(
 			request.Context(), clientID,
@@ -1198,44 +1189,6 @@ func (hdlr *Handlers) handlePrivmsg(
 	)
 }
 
-// checkBodyAndMeta returns the lines in body. It returns false
-// when body is present and is not an array of strings, or meta
-// is present and is not an object. Each line is decoded as any
-// because decoding into []string turns a null line into "". A
-// null body or meta decodes without an error into nil.
-func checkBodyAndMeta(body, meta json.RawMessage) ([]string, bool) {
-	var lines []string
-
-	if body != nil {
-		var values []any
-
-		err := json.Unmarshal(body, &values)
-		if err != nil || values == nil {
-			return nil, false
-		}
-
-		for _, value := range values {
-			line, isString := value.(string)
-			if !isString {
-				return nil, false
-			}
-
-			lines = append(lines, line)
-		}
-	}
-
-	if meta != nil {
-		var fields map[string]any
-
-		err := json.Unmarshal(meta, &fields)
-		if err != nil || fields == nil {
-			return nil, false
-		}
-	}
-
-	return lines, true
-}
-
 // respondIRCError enqueues a numeric error reply, notifies
 // the broker, and sends HTTP 200 with {"status":"error"}.
 func (hdlr *Handlers) respondIRCError(
@@ -1304,11 +1257,9 @@ func (hdlr *Handlers) handleChannelMsg(
 ) {
 	ctx := request.Context()
 
-	// Delegate validation + fan-out to service layer. The
-	// fan-out includes the sender's own session, so all
-	// their clients see the message in long-poll responses.
-	uuid, err := hdlr.svc.SendChannelMessage(
-		ctx, sessionID, 0, nick,
+	// Delegate validation + fan-out to service layer.
+	dbID, uuid, err := hdlr.svc.SendChannelMessage(
+		ctx, sessionID, nick,
 		command, target, body, meta,
 	)
 	if hdlr.handleServiceError(
@@ -1318,6 +1269,13 @@ func (hdlr *Handlers) handleChannelMsg(
 		return
 	}
 
+	// HTTP echo: enqueue to sender so all their clients
+	// see the message in long-poll responses.
+	_ = hdlr.params.Database.EnqueueToSession(
+		ctx, sessionID, dbID,
+	)
+	hdlr.broker.Notify(sessionID)
+
 	hdlr.respondJSON(writer, request,
 		map[string]string{"id": uuid, statusKey: "sent"},
 		http.StatusOK)
@@ -1332,7 +1290,7 @@ func (hdlr *Handlers) handleDirectMsg(
 	meta json.RawMessage,
 ) {
 	result, err := hdlr.svc.SendDirectMessage(
-		request.Context(), sessionID, 0, nick,
+		request.Context(), sessionID, nick,
 		command, target, body, meta,
 	)
 	if hdlr.handleServiceError(
@@ -1403,7 +1361,7 @@ func (hdlr *Handlers) executeJoin(
 	nick, channel, suppliedKey string,
 ) {
 	result, err := hdlr.svc.JoinChannel(
-		request.Context(), sessionID, 0, nick,
+		request.Context(), sessionID, nick,
 		channel, suppliedKey,
 	)
 	if hdlr.handleServiceError(
@@ -1587,7 +1545,7 @@ func (hdlr *Handlers) handlePart(
 	}
 
 	err := hdlr.svc.PartChannel(
-		request.Context(), sessionID, 0,
+		request.Context(), sessionID,
 		nick, channel, reason,
 	)
 	if hdlr.handleServiceError(
@@ -1658,7 +1616,7 @@ func (hdlr *Handlers) executeNickChange(
 	nick, newNick string,
 ) {
 	err := hdlr.svc.ChangeNick(
-		request.Context(), sessionID, 0, nick, newNick,
+		request.Context(), sessionID, nick, newNick,
 	)
 	if hdlr.handleServiceError(
 		writer, request,
@@ -1713,7 +1671,7 @@ func (hdlr *Handlers) handleTopic(
 	topic := strings.Join(lines, " ")
 
 	err := hdlr.svc.SetTopic(
-		request.Context(), sessionID, 0,
+		request.Context(), sessionID,
 		nick, channel, topic,
 	)
 	if hdlr.handleServiceError(
@@ -2199,7 +2157,7 @@ func (hdlr *Handlers) applyUserMode(
 
 	modeText := modeArgs[0] + " " + targetNick
 	hdlr.svc.BroadcastMode(
-		request.Context(), 0, nick, channel, chID,
+		request.Context(), nick, channel, chID,
 		modeText,
 	)
 
@@ -2245,7 +2203,7 @@ func (hdlr *Handlers) setChannelFlag(
 	}
 
 	hdlr.svc.BroadcastMode(
-		request.Context(), 0, nick, channel, chID,
+		request.Context(), nick, channel, chID,
 		modeStr,
 	)
 
@@ -3692,7 +3650,7 @@ func (hdlr *Handlers) handleKick(
 	}
 
 	err := hdlr.svc.KickUser(
-		request.Context(), sessionID, 0, nick,
+		request.Context(), sessionID, nick,
 		channel, targetNick, reason,
 	)
 	if hdlr.handleServiceError(
@@ -3765,7 +3723,7 @@ func (hdlr *Handlers) fanOut(
 
 	for _, sid := range sessionIDs {
 		enqErr := hdlr.params.Database.EnqueueToSession(
-			request.Context(), sid, dbID, 0,
+			request.Context(), sid, dbID,
 		)
 		if enqErr != nil {
 			hdlr.log.Error("enqueue failed",

internal/handlers/utility_test.go

@@ -1,3 +1,4 @@
+//nolint:paralleltest // global viper, as in api_test.go
 package handlers_test
 
 import (
@@ -71,8 +72,6 @@ func numericBody(
 }
 
 func TestUserhost(t *testing.T) {
-	t.Parallel()
-
 	tserver := newTestServer(t)
 
 	token := tserver.createSession("alice")
@@ -110,8 +109,6 @@ func TestUserhost(t *testing.T) {
 }
 
 func TestVersionAdminInfoTime(t *testing.T) {
-	t.Parallel()
-
 	tserver := newTestServer(t)
 
 	token := tserver.createSession("frank")
@@ -150,8 +147,6 @@ func TestVersionAdminInfoTime(t *testing.T) {
 }
 
 func TestKill(t *testing.T) {
-	t.Parallel()
-
 	tserver := newTestServerWithOper(t)
 
 	victimToken := tserver.createSession("victim")
@@ -218,8 +213,6 @@ func TestKill(t *testing.T) {
 }
 
 func TestWallops(t *testing.T) {
-	t.Parallel()
-
 	tserver := newTestServerWithOper(t)
 
 	receiverToken := tserver.createSession("receiver")
@@ -265,8 +258,6 @@ func TestWallops(t *testing.T) {
 }
 
 func TestUserMode(t *testing.T) {
-	t.Parallel()
-
 	const (
 		nick  = "alice"
 		other = "other"

internal/ircserver/commands.go

@@ -81,10 +81,10 @@ func (c *Conn) handleNick(
 	}
 
 	oldMask := c.hostmask()
-	oldNick := c.currentNick()
+	oldNick := c.nick
 
 	err := c.svc.ChangeNick(
-		ctx, c.sessionID, c.clientID, oldNick, newNick,
+		ctx, c.sessionID, oldNick, newNick,
 	)
 	if err != nil {
 		c.sendIRCError(err)
@@ -92,10 +92,9 @@ func (c *Conn) handleNick(
 		return
 	}
 
-	// Take the nick the session holds, not newNick: another
-	// client of the session may have changed it again since
-	// ChangeNick stored newNick.
-	c.loadSessionNick(ctx)
+	c.mu.Lock()
+	c.nick = newNick
+	c.mu.Unlock()
 
 	// Echo NICK change to the client on wire.
 	c.send(FormatMessage(oldMask, "NICK", newNick))
@@ -129,8 +128,8 @@ func (c *Conn) handlePrivmsg(
 	body, _ := json.Marshal([]string{text}) //nolint:errchkjson
 
 	if strings.HasPrefix(target, "#") {
-		_, err := c.svc.SendChannelMessage(
-			ctx, c.sessionID, c.clientID, c.currentNick(),
+		_, _, err := c.svc.SendChannelMessage(
+			ctx, c.sessionID, c.nick,
 			msg.Command, target, body, nil,
 		)
 		if err != nil {
@@ -138,7 +137,7 @@ func (c *Conn) handlePrivmsg(
 		}
 	} else {
 		result, err := c.svc.SendDirectMessage(
-			ctx, c.sessionID, c.clientID, c.currentNick(),
+			ctx, c.sessionID, c.nick,
 			msg.Command, target, body, nil,
 		)
 		if err != nil {
@@ -200,7 +199,7 @@ func (c *Conn) joinChannel(
 	channel, key string,
 ) {
 	result, err := c.svc.JoinChannel(
-		ctx, c.sessionID, c.clientID, c.currentNick(), channel, key,
+		ctx, c.sessionID, c.nick, channel, key,
 	)
 	if err != nil {
 		c.sendIRCError(err)
@@ -338,7 +337,7 @@ func (c *Conn) partChannel(
 	channel, reason string,
 ) {
 	err := c.svc.PartChannel(
-		ctx, c.sessionID, c.clientID, c.currentNick(), channel, reason,
+		ctx, c.sessionID, c.nick, channel, reason,
 	)
 	if err != nil {
 		c.sendIRCError(err)
@@ -371,7 +370,6 @@ func (c *Conn) handleQuit(msg *Message) {
 
 	c.mu.Lock()
 	c.closed = true
-	c.quitReason = reason
 	c.mu.Unlock()
 }
 
@@ -403,7 +401,7 @@ func (c *Conn) handleTopic(
 	newTopic := msg.Params[1]
 
 	err := c.svc.SetTopic(
-		ctx, c.sessionID, c.clientID, c.currentNick(), channel, newTopic,
+		ctx, c.sessionID, c.nick, channel, newTopic,
 	)
 	if err != nil {
 		c.sendIRCError(err)
@@ -710,7 +708,7 @@ func (c *Conn) applyChannelModes(
 		c.send(FormatMessage(c.hostmask(), "MODE", params...))
 
 		c.svc.BroadcastMode(
-			ctx, c.clientID, c.currentNick(), channel, chID, modeReply,
+			ctx, c.nick, channel, chID, modeReply,
 		)
 	}
 }
@@ -1187,7 +1185,7 @@ func (c *Conn) handleKick(
 	}
 
 	err := c.svc.KickUser(
-		ctx, c.sessionID, c.clientID, c.currentNick(),
+		ctx, c.sessionID, c.nick,
 		channel, targetNick, reason,
 	)
 	if err != nil {
@@ -1227,12 +1225,9 @@ func (c *Conn) handlePassPostReg(
 		return
 	}
 
-	// The IRC listener cannot add a connection to an existing
-	// session; only the HTTP API login can.
-	c.sendFromServer("NOTICE", c.currentNick(),
-		"Password set. Another client can log in to this "+
-			"session over the HTTP API: POST /api/v1/login "+
-			"with your nick and this password.",
+	c.sendFromServer("NOTICE", c.nick,
+		"Password set. You can reconnect using "+
+			"PASS <password> with your nick.",
 	)
 }
 
@@ -1254,7 +1249,7 @@ func (c *Conn) handleInvite(
 	channel := msg.Params[1]
 
 	targetID, err := c.svc.InviteUser(
-		ctx, c.sessionID, c.currentNick(), targetNick, channel,
+		ctx, c.sessionID, c.nick, targetNick, channel,
 	)
 	if err != nil {
 		c.sendIRCError(err)
@@ -1266,13 +1261,14 @@ func (c *Conn) handleInvite(
 		irc.RplInviting, targetNick, channel,
 	)
 
-	// Queue the INVITE to the target with the body the HTTP
-	// API uses.
-	body, _ := json.Marshal([]string{channel}) //nolint:errchkjson
+	// Send INVITE notice to target via service fan-out.
+	body, _ := json.Marshal( //nolint:errchkjson
+		[]string{"You have been invited to " + channel},
+	)
 
 	_, _, _ = c.svc.FanOut( //nolint:dogsled // fire-and-forget broadcast
-		ctx, "INVITE", c.currentNick(), targetNick, targetID, 0,
-		nil, body, nil, []int64{targetID}, 0,
+		ctx, "INVITE", c.nick, targetNick, targetID, 0,
+		nil, body, nil, []int64{targetID},
 	)
 }
 

internal/ircserver/conn.go

@@ -69,11 +69,6 @@ type Conn struct {
 	lastQueueID int64
 	closed      bool
 	killed      bool
-
-	// quitReason is the reason in the QUIT that peers are
-	// sent when the connection ends. The client's QUIT
-	// replaces it.
-	quitReason string
 }
 
 func newConn(
@@ -92,15 +87,14 @@ func newConn(
 	}
 
 	conn := &Conn{ //nolint:exhaustruct // zero-value defaults
-		conn:       tcpConn,
-		log:        log,
-		database:   database,
-		brk:        brk,
-		cfg:        cfg,
-		svc:        svc,
-		serverSfx:  srvName,
-		remoteIP:   host,
-		quitReason: "Connection closed",
+		conn:      tcpConn,
+		log:       log,
+		database:  database,
+		brk:       brk,
+		cfg:       cfg,
+		svc:       svc,
+		serverSfx: srvName,
+		remoteIP:  host,
 	}
 
 	conn.commands = conn.buildCommandMap()
@@ -284,7 +278,6 @@ func (c *Conn) cleanup(ctx context.Context) {
 	wasKilled := c.killed
 	sessID := c.sessionID
 	nick := c.nick
-	quitReason := c.quitReason
 	c.closed = true
 	c.mu.Unlock()
 
@@ -294,7 +287,9 @@ func (c *Conn) cleanup(ctx context.Context) {
 		// KILL has already sent the QUIT and deleted the
 		// session.
 		if !wasKilled {
-			c.svc.BroadcastQuit(ctx, sessID, nick, quitReason)
+			c.svc.BroadcastQuit(
+				ctx, sessID, nick, "Connection closed",
+			)
 		}
 	}
 
@@ -318,22 +313,6 @@ func (c *Conn) currentNick() string {
 	return c.nick
 }
 
-// loadSessionNick sets c.nick to the nick the connection's
-// session holds in the database, read by session ID. The
-// connection's own NICK and the relay passing on a NICK line
-// both call it, and it reads and sets the nick under c.mu, so
-// whichever runs last leaves the connection on its session's
-// nick. If the read fails, c.nick is left as it is.
-func (c *Conn) loadSessionNick(ctx context.Context) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	nick, err := c.database.GetSessionNick(ctx, c.sessionID)
-	if err == nil {
-		c.nick = nick
-	}
-}
-
 // send writes a formatted IRC line to the connection.
 func (c *Conn) send(line string) {
 	c.sendWithin(writeTimeout, line)
@@ -366,7 +345,7 @@ func (c *Conn) sendNumeric(
 	code irc.IRCMessageType,
 	params ...string,
 ) {
-	nick := c.currentNick()
+	nick := c.nick
 	if nick == "" {
 		nick = "*"
 	}
@@ -390,11 +369,9 @@ func (c *Conn) sendFromServer(
 // hostmask returns the client's full hostmask
 // (nick!user@host).
 func (c *Conn) hostmask() string {
-	nick := c.currentNick()
-
 	user := c.username
 	if user == "" {
-		user = nick
+		user = c.nick
 	}
 
 	host := c.hostname
@@ -402,7 +379,7 @@ func (c *Conn) hostmask() string {
 		host = c.remoteIP
 	}
 
-	return nick + "!" + user + "@" + host
+	return c.nick + "!" + user + "@" + host
 }
 
 // handleMessage dispatches a parsed IRC message using
@@ -610,7 +587,7 @@ func (c *Conn) deliverWelcome() {
 	)
 	c.sendNumeric(
 		irc.RplMyInfo,
-		c.serverSfx, "neoirc", service.UserModes, "Himnostv",
+		c.serverSfx, "neoirc", "", "mnst",
 	)
 	c.sendNumeric(
 		irc.RplIsupport,
@@ -680,7 +657,7 @@ func (c *Conn) checkPasswordLength(pw string) bool {
 		return true
 	}
 
-	c.sendFromServer("NOTICE", c.currentNick(),
+	c.sendFromServer("NOTICE", c.nick,
 		"Password must be 8 to 72 bytes",
 	)
 

internal/ircserver/export_test.go

@@ -71,11 +71,6 @@ func (s *Server) Listener() net.Listener {
 	return s.listener
 }
 
-// Service returns the service the server's connections use.
-func (s *Server) Service() *service.Service {
-	return s.svc
-}
-
 // PingTimes returns how long the server's connections wait
 // with nothing read before they are sent a PING, and after it
 // before they are closed.

internal/ircserver/integration_test.go

@@ -1373,42 +1373,6 @@ func TestIntegrationInviteUserOnChannel(t *testing.T) {
 	)
 }
 
-// TestIntegrationInviteLine checks that an IRC listener user
-// invited by an IRC listener user, and then over the HTTP
-// API, gets an INVITE line from the inviter for the channel
-// each time.
-func TestIntegrationInviteLine(t *testing.T) {
-	t.Parallel()
-
-	env := newTestEnv(t)
-
-	alice := env.dial(t)
-	alice.register("alice")
-	alice.joinAndDrain("#inv")
-
-	bob := env.dial(t)
-	bob.register("bob")
-
-	alice.sendAndExpect("INVITE bob #inv", " 341 ")
-
-	got := bob.readLine()
-	want := ":alice!alice@* INVITE bob #inv"
-
-	if got != want {
-		t.Errorf("from the IRC listener: got %q, want %q", got, want)
-	}
-
-	// The HTTP API queues an INVITE with the channel as its body.
-	env.queueMessage(t, "bob", "INVITE", "carol", "bob", []string{"#inv"})
-
-	got = bob.readLine()
-	want = ":carol!carol@* INVITE bob #inv"
-
-	if got != want {
-		t.Errorf("over the HTTP API: got %q, want %q", got, want)
-	}
-}
-
 // TestIntegrationModeSecretList checks that LIST shows a +s
 // channel only to its members.
 func TestIntegrationModeSecretList(t *testing.T) {

internal/ircserver/relay.go

@@ -32,12 +32,8 @@ func (c *Conn) relayMessages(ctx context.Context) {
 		// still signals waitCh.
 		waitCh := c.brk.Wait(c.sessionID)
 
-		// Drain any available messages. The drain ignores the
-		// cancel that comes when the connection ends, because a
-		// query cancelled while it runs leaves the SQLite
-		// connection marked broken, and the pool closes it. The
-		// loop still stops on ctx.
-		delivered := c.drainQueue(context.WithoutCancel(ctx))
+		// Drain any available messages.
+		delivered := c.drainQueue(ctx)
 
 		if delivered {
 			c.brk.Remove(c.sessionID, waitCh)
@@ -96,7 +92,7 @@ func (c *Conn) drainQueue(ctx context.Context) bool {
 //
 //nolint:cyclop // dispatch table
 func (c *Conn) deliverIRCMessage(
-	ctx context.Context,
+	_ context.Context,
 	msg *db.IRCMessage,
 ) {
 	command := msg.Command
@@ -124,7 +120,7 @@ func (c *Conn) deliverIRCMessage(
 	case command == irc.CmdPart:
 		c.deliverPart(msg, text)
 	case command == irc.CmdNick:
-		c.deliverNickChange(ctx, msg, text)
+		c.deliverNickChange(msg, text)
 	case command == irc.CmdQuit:
 		c.deliverQuitMsg(msg, text)
 	case command == irc.CmdTopic:
@@ -202,6 +198,15 @@ func (c *Conn) deliverTextMessage(
 	from := msg.From
 	target := msg.To
 
+	c.mu.Lock()
+	nick := c.nick
+	c.mu.Unlock()
+
+	// Don't echo our own messages back.
+	if from == nick {
+		return
+	}
+
 	prefix := from
 	if !strings.Contains(prefix, "!") {
 		prefix = from + "!" + from + "@*"
@@ -214,6 +219,16 @@ func (c *Conn) deliverTextMessage(
 
 // deliverJoin sends a JOIN notification.
 func (c *Conn) deliverJoin(msg *db.IRCMessage) {
+	c.mu.Lock()
+	nick := c.nick
+	c.mu.Unlock()
+
+	// Don't echo our own JOINs (we already sent them
+	// during joinChannel).
+	if msg.From == nick {
+		return
+	}
+
 	prefix := msg.From + "!" + msg.From + "@*"
 	channel := msg.To
 
@@ -222,6 +237,14 @@ func (c *Conn) deliverJoin(msg *db.IRCMessage) {
 
 // deliverPart sends a PART notification.
 func (c *Conn) deliverPart(msg *db.IRCMessage, text string) {
+	c.mu.Lock()
+	nick := c.nick
+	c.mu.Unlock()
+
+	if msg.From == nick {
+		return
+	}
+
 	prefix := msg.From + "!" + msg.From + "@*"
 	channel := msg.To
 
@@ -234,17 +257,18 @@ func (c *Conn) deliverPart(msg *db.IRCMessage, text string) {
 	}
 }
 
-// deliverNickChange sends a NICK change notification. The
-// change may be its own session's, made from another client,
-// so the connection first takes the nick its session holds
-// now. It does not go by the line's old nick: the connection
-// may have taken that nick after another user gave it up.
+// deliverNickChange sends a NICK change notification.
 func (c *Conn) deliverNickChange(
-	ctx context.Context,
 	msg *db.IRCMessage,
 	newNick string,
 ) {
-	c.loadSessionNick(ctx)
+	c.mu.Lock()
+	nick := c.nick
+	c.mu.Unlock()
+
+	if msg.From == nick {
+		return
+	}
 
 	prefix := msg.From + "!" + msg.From + "@*"
 
@@ -256,6 +280,14 @@ func (c *Conn) deliverQuitMsg(
 	msg *db.IRCMessage,
 	text string,
 ) {
+	c.mu.Lock()
+	nick := c.nick
+	c.mu.Unlock()
+
+	if msg.From == nick {
+		return
+	}
+
 	prefix := msg.From + "!" + msg.From + "@*"
 
 	if text != "" {
@@ -308,24 +340,16 @@ func (c *Conn) deliverKickMsg(
 	}
 }
 
-// deliverInviteMsg sends an INVITE line from the inviter
-// for the channel named in text, or nothing when text names
-// no channel.
+// deliverInviteMsg sends an INVITE notification.
 func (c *Conn) deliverInviteMsg(
-	msg *db.IRCMessage,
+	_ *db.IRCMessage,
 	text string,
 ) {
-	if text == "" {
-		return
-	}
-
 	c.mu.Lock()
 	nick := c.nick
 	c.mu.Unlock()
 
-	prefix := msg.From + "!" + msg.From + "@*"
-
-	c.send(FormatMessage(prefix, "INVITE", nick, text))
+	c.sendFromServer("NOTICE", nick, text)
 }
 
 // deliverWallops sends a WALLOPS notification.

internal/ircserver/relay_test.go

@@ -1,7 +1,6 @@
 package ircserver_test
 
 import (
-	"context"
 	"encoding/json"
 	"slices"
 	"strings"
@@ -9,7 +8,6 @@ import (
 	"time"
 
 	"sneak.berlin/go/neoirc/internal/ircserver"
-	"sneak.berlin/go/neoirc/internal/service"
 )
 
 // queueMessage queues a message for the user with nick
@@ -41,7 +39,7 @@ func (env *testEnv) queueMessage(
 		t.Fatalf("get session of %s: %v", recipient, err)
 	}
 
-	err = env.database.EnqueueToSession(ctx, sessionID, msgID, 0)
+	err = env.database.EnqueueToSession(ctx, sessionID, msgID)
 	if err != nil {
 		t.Fatalf("enqueue: %v", err)
 	}
@@ -213,38 +211,6 @@ func TestRelayModeParameters(t *testing.T) {
 	}
 }
 
-// TestRelayInviteWithoutChannel checks that an INVITE whose
-// body names no channel sends the invited IRC listener user
-// no INVITE line.
-func TestRelayInviteWithoutChannel(t *testing.T) {
-	t.Parallel()
-
-	env := newTestEnv(t)
-
-	bob := env.dial(t)
-	bob.register("bob")
-
-	// A nil body is stored as JSON null, which is not an array.
-	for _, body := range [][]string{nil, {}, {""}} {
-		env.queueMessage(t, "bob", "INVITE", "carol", "bob", body)
-	}
-
-	// The relay sends a user's queue in order, so this arrives
-	// after anything sent for the INVITEs above.
-	env.queueMessage(t, "bob", "PRIVMSG", "carol", "bob",
-		[]string{"the end"})
-
-	lines := bob.readUntil(func(l string) bool {
-		return strings.HasSuffix(l, " :the end")
-	})
-
-	for _, line := range lines {
-		if strings.Contains(line, " INVITE ") {
-			t.Errorf("got %q, want no INVITE line", line)
-		}
-	}
-}
-
 // TestRelayLineBreaks checks that a CR, LF or NUL in a stored
 // body line, key or mask never reaches an IRC listener user
 // as a line break, so no extra line arrives, and that a body
@@ -316,7 +282,7 @@ func TestRelayNickDiffersOnlyInCase(t *testing.T) {
 		{"JOIN #case", ":Alice!Alice@* JOIN #case"},
 		{"NICK Alicia", ":Alice!Alice@* NICK Alicia"},
 		{"NICK Alice", ":Alicia!Alicia@* NICK Alice"}, // back for QUIT
-		{"QUIT", ":Alice!Alice@* QUIT :Quit: Client quit"},
+		{"QUIT", ":Alice!Alice@* QUIT :Quit: Connection closed"},
 	} {
 		capitalAlice.send(step.line)
 
@@ -326,372 +292,3 @@ func TestRelayNickDiffersOnlyInCase(t *testing.T) {
 		}
 	}
 }
-
-// TestRelayOwnChangeOnce checks that an IRC listener user who
-// sets a topic, changes a channel mode or kicks gets one TOPIC,
-// MODE or KICK line for it, and so does the other member.
-func TestRelayOwnChangeOnce(t *testing.T) {
-	t.Parallel()
-
-	for _, step := range []struct {
-		command, line string
-	}{
-		{"TOPIC", "TOPIC #dup :new topic"},
-		{"MODE", "MODE #dup +m"},
-		{"KICK", "KICK #dup carl :bye"},
-	} {
-		t.Run(step.command, func(t *testing.T) {
-			t.Parallel()
-
-			env := newTestEnv(t)
-
-			alice := env.dial(t)
-			alice.register("alice")
-			alice.joinAndDrain("#dup")
-
-			carl := env.dial(t)
-			carl.register("carl")
-			carl.joinAndDrain("#dup")
-
-			alice.send(step.line)
-
-			// The reply to alice's next command comes after her
-			// command has finished, so her own copy comes before it.
-			beforePong := alice.sendAndExpect("PING :done", "PONG")
-
-			// The relay sends a user's queue in order, so a message
-			// queued now arrives after any relayed copy.
-			for nick, client := range map[string]*testClient{
-				"alice": alice, "carl": carl,
-			} {
-				env.queueMessage(
-					t, nick, "PRIVMSG", "dave", nick,
-					[]string{"after the change"},
-				)
-
-				lines := client.readUntil(func(l string) bool {
-					return strings.HasSuffix(l, " :after the change")
-				})
-
-				if client == alice {
-					lines = slices.Concat(beforePong, lines)
-				}
-
-				var changes []string
-
-				for _, line := range lines {
-					if strings.Contains(line, " "+step.command+" #dup ") {
-						changes = append(changes, line)
-					}
-				}
-
-				if len(changes) != 1 {
-					t.Errorf("%s got %q, want one %s line",
-						nick, changes, step.command)
-				}
-			}
-		})
-	}
-}
-
-// TestRelayOwnSessionOnce checks that a command a user makes
-// from one client of their session reaches each of the
-// session's clients once: an IRC listener connection and an
-// HTTP API client. The connection that sent a command gets
-// only its own echo, and none for PRIVMSG and NOTICE, which
-// IRC does not echo.
-//
-//nolint:funlen // table-driven test
-func TestRelayOwnSessionOnce(t *testing.T) {
-	t.Parallel()
-
-	hello := json.RawMessage(`["hello"]`)
-
-	for _, step := range []struct {
-		// line is the command as alice sends it on the IRC
-		// listener.
-		line string
-		// api makes the same command for her session the way
-		// the HTTP API does.
-		api func(
-			ctx context.Context, svc *service.Service, sessionID int64,
-		) error
-		// echoes is how many copies alice's connection gets of
-		// line when it sends line itself.
-		echoes int
-	}{
-		{"PRIVMSG #chan :hello", func(
-			ctx context.Context, svc *service.Service, sessionID int64,
-		) error {
-			_, err := svc.SendChannelMessage(
-				ctx, sessionID, 0, "alice", "PRIVMSG", "#chan", hello, nil,
-			)
-
-			return err
-		}, 0},
-		{"NOTICE bob :hello", func(
-			ctx context.Context, svc *service.Service, sessionID int64,
-		) error {
-			_, err := svc.SendDirectMessage(
-				ctx, sessionID, 0, "alice", "NOTICE", "bob", hello, nil,
-			)
-
-			return err
-		}, 0},
-		{"JOIN #other", func(
-			ctx context.Context, svc *service.Service, sessionID int64,
-		) error {
-			_, err := svc.JoinChannel(ctx, sessionID, 0, "alice", "#other", "")
-
-			return err
-		}, 1},
-		{"PART #chan :bye", func(
-			ctx context.Context, svc *service.Service, sessionID int64,
-		) error {
-			return svc.PartChannel(ctx, sessionID, 0, "alice", "#chan", "bye")
-		}, 1},
-		{"NICK alice2", func(
-			ctx context.Context, svc *service.Service, sessionID int64,
-		) error {
-			return svc.ChangeNick(ctx, sessionID, 0, "alice", "alice2")
-		}, 1},
-		{"TOPIC #chan :new topic", func(
-			ctx context.Context, svc *service.Service, sessionID int64,
-		) error {
-			return svc.SetTopic(
-				ctx, sessionID, 0, "alice", "#chan", "new topic",
-			)
-		}, 1},
-		{"MODE #chan +m", func(
-			ctx context.Context, svc *service.Service, sessionID int64,
-		) error {
-			chID, err := svc.ValidateChannelOp(ctx, sessionID, "#chan")
-			if err != nil {
-				return err
-			}
-
-			err = svc.SetChannelFlag(ctx, chID, 'm', true)
-			if err != nil {
-				return err
-			}
-
-			svc.BroadcastMode(ctx, 0, "alice", "#chan", chID, "+m")
-
-			return nil
-		}, 1},
-		{"KICK #chan bob :bye", func(
-			ctx context.Context, svc *service.Service, sessionID int64,
-		) error {
-			return svc.KickUser(
-				ctx, sessionID, 0, "alice", "#chan", "bob", "bye",
-			)
-		}, 1},
-	} {
-		command := strings.Fields(step.line)[0]
-
-		t.Run(command+" from IRC", func(t *testing.T) {
-			t.Parallel()
-
-			ircCopies, httpCopies := ownSessionCopies(t, step.line, nil)
-			if ircCopies != step.echoes || httpCopies != 1 {
-				t.Errorf("connection got %d, HTTP client got %d, want %d and 1",
-					ircCopies, httpCopies, step.echoes)
-			}
-		})
-
-		t.Run(command+" from the HTTP API", func(t *testing.T) {
-			t.Parallel()
-
-			ircCopies, httpCopies := ownSessionCopies(t, step.line, step.api)
-			if ircCopies != 1 || httpCopies != 1 {
-				t.Errorf("connection got %d, HTTP client got %d, want 1 and 1",
-					ircCopies, httpCopies)
-			}
-		})
-	}
-}
-
-// ownSessionCopies sets up alice with aliceWithHTTPClient. It
-// makes the command line from her connection, or with api from
-// the HTTP API client when api is not nil, and returns how many
-// copies of it her connection and her HTTP API client got.
-func ownSessionCopies(
-	t *testing.T,
-	line string,
-	api func(ctx context.Context, svc *service.Service, sessionID int64) error,
-) (int, int) {
-	t.Helper()
-
-	ctx := t.Context()
-	env := newTestEnv(t)
-	alice, _, sessionID, httpClientID := aliceWithHTTPClient(t, env)
-
-	var lines []string
-
-	if api == nil {
-		alice.send(line)
-
-		// Her echo comes before the reply to her next command.
-		lines = alice.sendAndExpect("PING :done", "PONG")
-	} else {
-		err := api(ctx, env.srv.Service(), sessionID)
-		if err != nil {
-			t.Fatalf("%s over the HTTP API: %v", line, err)
-		}
-	}
-
-	msgs, _, err := env.database.PollMessages(ctx, httpClientID, 0, 0)
-	if err != nil {
-		t.Fatalf("poll the HTTP API client: %v", err)
-	}
-
-	httpCopies := 0
-
-	for _, msg := range msgs {
-		if msg.Command == strings.Fields(line)[0] {
-			httpCopies++
-		}
-	}
-
-	// The relay sends a queue in order, so this arrives after any
-	// copy. It is queued by session, as NICK changes her nick.
-	endID, _, err := env.database.InsertMessage(
-		ctx, "PRIVMSG", "dave", "alice", 0, 0,
-		nil, json.RawMessage(`["the end"]`), nil,
-	)
-	if err != nil {
-		t.Fatalf("insert message: %v", err)
-	}
-
-	err = env.database.EnqueueToSession(ctx, sessionID, endID, 0)
-	if err != nil {
-		t.Fatalf("enqueue: %v", err)
-	}
-
-	env.brk.Notify(sessionID)
-
-	lines = append(lines, alice.readUntil(func(l string) bool {
-		return strings.HasSuffix(l, " :the end")
-	})...)
-
-	// A copy starts with the command and its first parameter.
-	start := " " + strings.Join(strings.Fields(line)[:2], " ")
-	ircCopies := strings.Count(strings.Join(lines, "\n"), start)
-
-	return ircCopies, httpCopies
-}
-
-// aliceWithHTTPClient connects alice to the IRC listener and
-// has her join #chan, which bob is on too, then adds an HTTP API
-// client to her session with the password her connection set,
-// as POST /api/v1/login does. It returns her connection, bob's
-// connection, her session and her HTTP API client.
-func aliceWithHTTPClient(
-	t *testing.T, env *testEnv,
-) (*testClient, *testClient, int64, int64) {
-	t.Helper()
-
-	const password = "alicepass"
-
-	alice := env.dial(t)
-	alice.send("PASS " + password)
-	alice.register("alice")
-	// Registration stores the password before the JOIN runs.
-	alice.joinAndDrain("#chan")
-
-	bob := env.dial(t)
-	bob.register("bob")
-	bob.joinAndDrain("#chan")
-
-	sessionID, httpClientID, _, err := env.database.LoginUser(
-		t.Context(), "alice", password, "127.0.0.1", "localhost",
-	)
-	if err != nil {
-		t.Fatalf("log in as alice: %v", err)
-	}
-
-	return alice, bob, sessionID, httpClientID
-}
-
-// TestRelayNickChangeFromHTTPAPI checks that once alice's nick
-// is changed from her HTTP API client, her IRC listener
-// connection uses the new nick: what she then sends from it
-// reaches bob under the new nick.
-func TestRelayNickChangeFromHTTPAPI(t *testing.T) {
-	t.Parallel()
-
-	env := newTestEnv(t)
-	alice, bob, sessionID, _ := aliceWithHTTPClient(t, env)
-
-	bob.joinAndDrain("#other")
-
-	// As the HTTP API does.
-	err := env.srv.Service().ChangeNick(
-		t.Context(), sessionID, 0, "alice", "alice2",
-	)
-	if err != nil {
-		t.Fatalf("change nick over the HTTP API: %v", err)
-	}
-
-	// Her connection has taken the new nick once it has sent her
-	// the change.
-	const change = ":alice!alice@* NICK alice2"
-
-	alice.readUntil(func(l string) bool { return l == change })
-	bob.readUntil(func(l string) bool { return l == change })
-
-	for _, step := range []struct {
-		line, want string
-	}{
-		{"PRIVMSG #chan :hi there", ":alice2!alice2@* PRIVMSG #chan :hi there"},
-		{"JOIN #other", ":alice2!alice2@* JOIN #other"},
-		{"NICK alice3", ":alice2!alice2@* NICK alice3"},
-	} {
-		alice.send(step.line)
-
-		got := bob.readLine()
-		if got != step.want {
-			t.Errorf("%s: got %q, want %q", step.line, got, step.want)
-		}
-	}
-}
-
-// TestRelayNickChangeKeepsTakenNick checks that an IRC
-// listener connection which takes a nick another user has
-// given up keeps it when that user's change reaches it
-// afterwards: what it then sends goes out under the nick its
-// session holds.
-func TestRelayNickChangeKeepsTakenNick(t *testing.T) {
-	t.Parallel()
-
-	env := newTestEnv(t)
-
-	bob := env.dial(t)
-	bob.register("bob")
-	bob.sendAndExpect("NICK bob2", " NICK bob2")
-
-	alice := env.dial(t)
-	alice.register("alice")
-	alice.sendAndExpect("NICK bob", " NICK bob")
-	alice.joinAndDrain("#chan")
-
-	bob.joinAndDrain("#chan")
-
-	// Bob's change reaches alice only now, as it does when she
-	// takes his old nick before her connection has passed the
-	// change on. She holds bob now, so it is queued to bob.
-	env.queueMessage(t, "bob", "NICK", "bob", "", []string{"bob2"})
-
-	alice.readUntil(func(l string) bool {
-		return l == ":bob!bob@* NICK bob2"
-	})
-
-	alice.send("PRIVMSG #chan :hi there")
-
-	const want = ":bob!bob@* PRIVMSG #chan :hi there"
-
-	got := bob.readLine()
-	if got != want {
-		t.Errorf("got %q, want %q", got, want)
-	}
-}

internal/ircserver/server_test.go

@@ -3,15 +3,14 @@ package ircserver_test
 import (
 	"bufio"
 	"context"
+	"crypto/rand"
 	"database/sql"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"log/slog"
 	"net"
 	"os"
 	"runtime"
-	"slices"
 	"strings"
 	"sync/atomic"
 	"testing"
@@ -21,11 +20,9 @@ import (
 	"sneak.berlin/go/neoirc/internal/broker"
 	"sneak.berlin/go/neoirc/internal/config"
 	"sneak.berlin/go/neoirc/internal/db"
-	"sneak.berlin/go/neoirc/internal/dbtest"
 	"sneak.berlin/go/neoirc/internal/globals"
 	"sneak.berlin/go/neoirc/internal/ircserver"
 	"sneak.berlin/go/neoirc/internal/logger"
-	"sneak.berlin/go/neoirc/pkg/irc"
 
 	_ "modernc.org/sqlite"
 )
@@ -110,7 +107,14 @@ func newTestEnvWithResolver(
 ) *testEnv {
 	t.Helper()
 
-	conn, err := sql.Open("sqlite", dbtest.NewURL(t))
+	// A random name, so that no other test environment, not
+	// even an earlier run of the same test, can share it.
+	dsn := fmt.Sprintf(
+		"file:%s?mode=memory&cache=shared",
+		rand.Text(),
+	)
+
+	conn, err := sql.Open("sqlite", dsn)
 	if err != nil {
 		t.Fatalf("open db: %v", err)
 	}
@@ -140,6 +144,20 @@ func newTestEnvWithResolver(
 
 	brk := broker.New()
 
+	var listenConfig net.ListenConfig
+
+	listener, err := listenConfig.Listen(t.Context(), "tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("listen: %v", err)
+	}
+
+	addr := listener.Addr().String()
+
+	err = listener.Close()
+	if err != nil {
+		t.Fatalf("close listener: %v", err)
+	}
+
 	log := slog.New(slog.NewTextHandler(
 		os.Stderr,
 		&slog.HandlerOptions{Level: slog.LevelError}, //nolint:exhaustruct
@@ -149,9 +167,7 @@ func newTestEnvWithResolver(
 		log, cfg, database, brk, interval, deadline, resolve,
 	)
 
-	// Port 0 makes the system pick a free port. dial reads it
-	// back from the server's listener.
-	err = srv.Start("127.0.0.1:0")
+	err = srv.Start(addr)
 	if err != nil {
 		t.Fatalf("start irc server: %v", err)
 	}
@@ -489,22 +505,6 @@ func TestWelcomeContainsNick(t *testing.T) {
 	}
 }
 
-// TestMyInfoListsModes checks that RPL_MYINFO lists the user
-// modes o and w, then the channel modes MODE accepts on the
-// IRC listener. It compares the whole line, so a missing or
-// extra mode fails it.
-func TestMyInfoListsModes(t *testing.T) {
-	t.Parallel()
-
-	env := newTestEnv(t)
-	lines := env.dial(t).register("carol")
-
-	want := ":test.irc 004 carol test.irc neoirc ow Himnostv"
-	if !slices.Contains(lines, want) {
-		t.Errorf("no line %q in %v", want, lines)
-	}
-}
-
 func TestPingPong(t *testing.T) {
 	t.Parallel()
 
@@ -645,6 +645,8 @@ func TestNewPingTimes(t *testing.T) {
 func TestIdleCleanupKeepsActiveUser(t *testing.T) {
 	t.Parallel()
 
+	const idleTimeout = 500 * time.Millisecond
+
 	env := newTestEnv(t)
 
 	active := env.dial(t)
@@ -653,17 +655,13 @@ func TestIdleCleanupKeepsActiveUser(t *testing.T) {
 	idle := env.dial(t)
 	idle.register("idle")
 
-	// Both users were last seen before cutoff, and only active
-	// sends a command after it, so the result does not depend
-	// on how long the PONG takes to arrive.
-	cutoff := time.Now()
-
+	time.Sleep(idleTimeout)
 	active.sendAndExpect("PING :still here", "PONG")
 
 	// The idle cleanup in internal/handlers removes exactly
 	// the users this returns.
 	stale, err := env.database.GetStaleOrphanSessions(
-		t.Context(), cutoff,
+		t.Context(), time.Now().Add(-idleTimeout),
 	)
 	if err != nil {
 		t.Fatalf("get stale sessions: %v", err)
@@ -875,112 +873,6 @@ func TestQuit(t *testing.T) {
 	assertContains(t, lines, "goodbye", "QUIT reason")
 }
 
-// TestQuitReasonReachesPeers checks the reason that an IRC
-// listener user's channel peers see in its QUIT, on both the
-// IRC listener and the HTTP API. It is the reason the user
-// gave, Client quit for a QUIT without one, or Connection
-// closed when the connection ends without a QUIT.
-func TestQuitReasonReachesPeers(t *testing.T) {
-	t.Parallel()
-
-	for _, step := range []struct {
-		name, quit, want string
-	}{
-		{"QUIT with a reason", "QUIT :gone home", "gone home"},
-		{"QUIT without a reason", irc.CmdQuit, "Client quit"},
-		{"connection closed without QUIT", "", "Connection closed"},
-	} {
-		t.Run(step.name, func(t *testing.T) {
-			t.Parallel()
-
-			ircLine, apiBody := quitSeenByPeers(t, step.quit)
-
-			want := ":quitter!quitter@* QUIT :Quit: " + step.want
-			if ircLine != want {
-				t.Errorf("IRC peer got %q, want %q", ircLine, want)
-			}
-
-			if len(apiBody) != 1 || apiBody[0] != step.want {
-				t.Errorf("HTTP API peer got %q, want [%q]", apiBody, step.want)
-			}
-		})
-	}
-}
-
-// quitSeenByPeers starts a server on which quitter, ircpeer on
-// the IRC listener and apipeer on the HTTP API share a channel.
-// quitter sends the line quit, or closes its connection when
-// quit is empty. It returns the QUIT line ircpeer is sent and
-// the body of the QUIT apipeer is sent.
-func quitSeenByPeers(t *testing.T, quit string) (string, []string) {
-	t.Helper()
-
-	env := newTestEnv(t)
-	ctx := t.Context()
-
-	ircPeer := env.dial(t)
-	ircPeer.register("ircpeer")
-	ircPeer.joinAndDrain("#bye")
-
-	apiPeerID, apiPeerClientID, _, err := env.database.CreateSession(
-		ctx, "apipeer", "apipeer", "", "",
-	)
-	if err != nil {
-		t.Fatalf("create peer session: %v", err)
-	}
-
-	channelID, err := env.database.GetChannelByName(ctx, "#bye")
-	if err != nil {
-		t.Fatalf("get channel: %v", err)
-	}
-
-	err = env.database.JoinChannel(ctx, channelID, apiPeerID)
-	if err != nil {
-		t.Fatalf("join peer: %v", err)
-	}
-
-	quitter := env.dial(t)
-	quitter.register("quitter")
-	quitter.joinAndDrain("#bye")
-
-	if quit == "" {
-		err = quitter.conn.Close()
-		if err != nil {
-			t.Fatalf("close: %v", err)
-		}
-	} else {
-		quitter.send(quit)
-	}
-
-	lines := ircPeer.readUntil(func(l string) bool {
-		return strings.Contains(l, " QUIT ")
-	})
-
-	// The QUIT is queued to both peers at once, so apipeer has
-	// it by now.
-	msgs, _, err := env.database.PollMessages(ctx, apiPeerClientID, 0, 0)
-	if err != nil {
-		t.Fatalf("poll peer: %v", err)
-	}
-
-	for _, msg := range msgs {
-		if msg.Command == irc.CmdQuit && msg.From == "quitter" {
-			var body []string
-
-			err = json.Unmarshal(msg.Body, &body)
-			if err != nil {
-				t.Fatalf("decode QUIT body %s: %v", msg.Body, err)
-			}
-
-			return lines[len(lines)-1], body
-		}
-	}
-
-	t.Fatalf("apipeer was not sent the QUIT: %v", msgs)
-
-	return "", nil
-}
-
 // TestStopEndsSessions checks that stopping the server ends
 // a registered connection's session before Stop returns, as
 // closing the connection does: the session, its client and
@@ -1250,9 +1142,6 @@ func TestAwaySetAndClear(t *testing.T) {
 	assertContains(t, clearLines, " 305 ", "RPL_UNAWAY")
 }
 
-// TestHandlePassPostRegistration checks the NOTICE that
-// confirms PASS after registration. It points to the HTTP API
-// login, the only way to add a client to an existing session.
 func TestHandlePassPostRegistration(t *testing.T) {
 	t.Parallel()
 
@@ -1265,11 +1154,7 @@ func TestHandlePassPostRegistration(t *testing.T) {
 	)
 
 	assertContains(
-		t, lines,
-		" NOTICE passuser :Password set. Another client can log "+
-			"in to this session over the HTTP API: "+
-			"POST /api/v1/login with your nick and this password.",
-		"password confirmation",
+		t, lines, "Password set", "password confirmation",
 	)
 }
 

internal/server/export_test.go

@@ -15,12 +15,6 @@ func NewTestSPAServer() *Server {
 	return srv
 }
 
-// Listener returns the listener the start hook bound for the
-// HTTP server.
-func (srv *Server) Listener() net.Listener {
-	return srv.listener
-}
-
 // ServeUntilShutdown runs serveUntilShutdown, which serves the
 // HTTP server on listener, and returns when it does.
 func (srv *Server) ServeUntilShutdown(listener net.Listener) {

internal/server/server.go

@@ -50,7 +50,6 @@ type Server struct {
 	sentryEnabled bool
 	log           *slog.Logger
 	httpServer    *http.Server
-	listener      net.Listener
 	router        *chi.Mux
 	params        Params
 	mw            *middleware.Middleware
@@ -180,8 +179,6 @@ func (srv *Server) startHTTP(ctx context.Context) error {
 		return fmt.Errorf("http listen: %w", err)
 	}
 
-	srv.listener = listener
-
 	srv.httpServer = &http.Server{ //nolint:exhaustruct // optional fields
 		Addr:           listenAddr,
 		ReadTimeout:    httpReadTimeout,

internal/server/server_test.go

@@ -5,6 +5,7 @@
 package server_test
 
 import (
+	"crypto/rand"
 	"fmt"
 	"net"
 	"net/http"
@@ -18,7 +19,6 @@ import (
 	"sneak.berlin/go/neoirc/internal/broker"
 	"sneak.berlin/go/neoirc/internal/config"
 	"sneak.berlin/go/neoirc/internal/db"
-	"sneak.berlin/go/neoirc/internal/dbtest"
 	"sneak.berlin/go/neoirc/internal/globals"
 	"sneak.berlin/go/neoirc/internal/handlers"
 	"sneak.berlin/go/neoirc/internal/healthcheck"
@@ -45,9 +45,10 @@ const (
 // for a long poll the HTTP server is serving to finish, and
 // that the poll gets its response.
 func TestStopWaitsForRequestInProgress(t *testing.T) {
-	var srv *server.Server
+	port := freePort(t)
+	addr := net.JoinHostPort("127.0.0.1", strconv.Itoa(port))
 
-	app, brk, database := startApp(t, fx.Populate(&srv))
+	app, brk, database := startApp(t, port)
 
 	sessionID, _, token, err := database.CreateSession(
 		t.Context(), "poller", "poller", "", "",
@@ -56,12 +57,9 @@ func TestStopWaitsForRequestInProgress(t *testing.T) {
 		t.Fatalf("create session: %v", err)
 	}
 
-	tcpAddr, ok := srv.Listener().Addr().(*net.TCPAddr)
-	if !ok {
-		t.Fatalf("listener address %v is not TCP", srv.Listener().Addr())
-	}
-
-	addr := net.JoinHostPort("127.0.0.1", strconv.Itoa(tcpAddr.Port))
+	waitUntil(t, "the HTTP server to listen", func() bool {
+		return canConnect(t, addr)
+	})
 
 	statuses := make(chan int, 1)
 
@@ -147,7 +145,7 @@ func TestStartFailsWhenHTTPPortIsTaken(t *testing.T) {
 func TestServeFailureStopsApp(t *testing.T) {
 	var srv *server.Server
 
-	app, _, _ := startApp(t, fx.Populate(&srv))
+	app, _, _ := startApp(t, freePort(t), fx.Populate(&srv))
 
 	shutdowns := app.Wait()
 
@@ -170,7 +168,7 @@ func TestServeFailureStopsApp(t *testing.T) {
 func TestServeAfterStopDoesNotStopApp(t *testing.T) {
 	var srv *server.Server
 
-	app, _, _ := startApp(t, fx.Populate(&srv))
+	app, _, _ := startApp(t, freePort(t), fx.Populate(&srv))
 
 	shutdowns := app.Wait()
 
@@ -188,15 +186,16 @@ func TestServeAfterStopDoesNotStopApp(t *testing.T) {
 	}
 }
 
-// startApp starts the app newApp builds, with the HTTP port
-// set to 0, so the system gives the server a free port.
+// startApp starts the app newApp builds, with the HTTP server
+// listening on port.
 func startApp(
 	t *testing.T,
+	port int,
 	options ...fx.Option,
 ) (*fxtest.App, *broker.Broker, *db.Database) {
 	t.Helper()
 
-	app, brk, database := newApp(t, 0, options...)
+	app, brk, database := newApp(t, port, options...)
 
 	app.RequireStart()
 
@@ -242,7 +241,10 @@ func newApp(
 			stats.New,
 		),
 		fx.Decorate(func(cfg *config.Config) *config.Config {
-			cfg.DBURL = dbtest.NewURL(t)
+			// A random name, so that no other test can share it.
+			cfg.DBURL = fmt.Sprintf(
+				"file:%s?mode=memory&cache=shared", rand.Text(),
+			)
 			cfg.Port = port
 
 			return cfg
@@ -255,6 +257,21 @@ func newApp(
 	return app, brk, database
 }
 
+// freePort returns a TCP port that nothing was listening on a
+// moment ago.
+func freePort(t *testing.T) int {
+	t.Helper()
+
+	listener := closedListener(t)
+
+	tcpAddr, ok := listener.Addr().(*net.TCPAddr)
+	if !ok {
+		t.Fatalf("listener address %v is not TCP", listener.Addr())
+	}
+
+	return tcpAddr.Port
+}
+
 // closedListener returns a TCP listener that has already been
 // closed, so that accepting a connection on it fails.
 func closedListener(t *testing.T) net.Listener {
@@ -277,6 +294,22 @@ func closedListener(t *testing.T) net.Listener {
 	return listener
 }
 
+// canConnect reports whether addr accepts a TCP connection.
+func canConnect(t *testing.T, addr string) bool {
+	t.Helper()
+
+	var dialer net.Dialer
+
+	conn, err := dialer.DialContext(t.Context(), "tcp", addr)
+	if err != nil {
+		return false
+	}
+
+	_ = conn.Close()
+
+	return true
+}
+
 // waitUntil calls done every checkStep until it returns true,
 // and fails the test if it does not within testTimeout.
 func waitUntil(t *testing.T, what string, done func() bool) {

internal/service/service.go

@@ -312,7 +312,7 @@ func (s *Service) SendWallops(
 
 	_, _, err = s.FanOut(
 		ctx, irc.CmdWallops, nick, "*", 0, 0,
-		nil, body, nil, recipients, 0,
+		nil, body, nil, recipients,
 	)
 	if err != nil {
 		return fmt.Errorf("wallops: %w", err)
@@ -347,19 +347,12 @@ type DirectMsgResult struct {
 // session IDs, notifying each via the broker. toSessionID
 // and toChannelID are the recipient InsertMessage records
 // for history, 0 when there is none.
-//
-// skipClientID is the client whose queue the message is
-// not added to: the IRC listener connection that sent the
-// command, which has already shown it to its user. The HTTP
-// API passes 0, as its clients see their own commands
-// through their queues.
 func (s *Service) FanOut(
 	ctx context.Context,
 	command, from, to string,
 	toSessionID, toChannelID int64,
 	params, body, meta json.RawMessage,
 	sessionIDs []int64,
-	skipClientID int64,
 ) (int64, string, error) {
 	dbID, msgUUID, err := s.db.InsertMessage(
 		ctx, command, from, to,
@@ -370,40 +363,58 @@ func (s *Service) FanOut(
 	}
 
 	for _, sid := range sessionIDs {
-		_ = s.db.EnqueueToSession(ctx, sid, dbID, skipClientID)
+		_ = s.db.EnqueueToSession(ctx, sid, dbID)
 		s.broker.Notify(sid)
 	}
 
 	return dbID, msgUUID, nil
 }
 
+// excludeSession returns a copy of ids without the given
+// session.
+func excludeSession(
+	ids []int64,
+	exclude int64,
+) []int64 {
+	out := make([]int64, 0, len(ids))
+
+	for _, id := range ids {
+		if id != exclude {
+			out = append(out, id)
+		}
+	}
+
+	return out
+}
+
 // SendChannelMessage checks membership, bans and
 // moderation, then the hashcash stamp of a PRIVMSG to a +H
-// channel, then fans out a message to all channel members,
-// the sender's session included, skipping client
-// skipClientID as FanOut does. The stamp is checked after
-// the other checks so that a message they refuse does not
-// spend it. Returns the message UUID and any error.
+// channel, then fans out a message to all channel members
+// except the sender. The stamp is checked after the other
+// checks so that a message they refuse does not spend it.
+// Returns the database row ID, message UUID, and any error.
+// The dbID lets callers enqueue the same message to the
+// sender when echo is needed (HTTP transport).
 func (s *Service) SendChannelMessage(
 	ctx context.Context,
-	sessionID, skipClientID int64,
+	sessionID int64,
 	nick, command, channel string,
 	body, meta json.RawMessage,
-) (string, error) {
+) (int64, string, error) {
 	noSuchChannel := &IRCError{
 		irc.ErrNoSuchChannel, []string{channel}, msgNoSuchChannel,
 	}
 
 	chID, err := s.db.GetChannelByName(ctx, channel)
 	if err != nil {
-		return "", noSuchChannel
+		return 0, "", noSuchChannel
 	}
 
 	isMember, _ := s.db.IsChannelMember(
 		ctx, chID, sessionID,
 	)
 	if !isMember {
-		return "", &IRCError{
+		return 0, "", &IRCError{
 			irc.ErrCannotSendToChan,
 			[]string{channel},
 			"Cannot send to channel",
@@ -415,7 +426,7 @@ func (s *Service) SendChannelMessage(
 		ctx, chID, sessionID,
 	)
 	if banErr == nil && isBanned {
-		return "", &IRCError{
+		return 0, "", &IRCError{
 			irc.ErrCannotSendToChan,
 			[]string{channel},
 			"Cannot send to channel (+b)",
@@ -432,7 +443,7 @@ func (s *Service) SendChannelMessage(
 		)
 
 		if !isOp && !isVoiced {
-			return "", &IRCError{
+			return 0, "", &IRCError{
 				irc.ErrCannotSendToChan,
 				[]string{channel},
 				"Cannot send to channel (+m)",
@@ -445,35 +456,35 @@ func (s *Service) SendChannelMessage(
 			ctx, chID, channel, body, meta,
 		)
 		if err != nil {
-			return "", err
+			return 0, "", err
 		}
 	}
 
 	memberIDs, _ := s.db.GetChannelMemberIDs(ctx, chID)
+	recipients := excludeSession(memberIDs, sessionID)
 
-	_, uuid, fanErr := s.FanOut(
+	dbID, uuid, fanErr := s.FanOut(
 		ctx, command, nick, channel, 0, chID,
-		nil, body, meta, memberIDs, skipClientID,
+		nil, body, meta, recipients,
 	)
 	// The channel was deleted after the lookup above.
 	if db.IsForeignKeyConstraintError(fanErr) {
-		return "", noSuchChannel
+		return 0, "", noSuchChannel
 	}
 
 	if fanErr != nil {
-		return "", fanErr
+		return 0, "", fanErr
 	}
 
-	return uuid, nil
+	return dbID, uuid, nil
 }
 
 // SendDirectMessage validates the target and sends a
-// direct message to the target and the sender's session,
-// skipping client skipClientID as FanOut does, and returns
-// the message UUID and any away message set on the target.
+// direct message, returning the message UUID and any away
+// message set on the target.
 func (s *Service) SendDirectMessage(
 	ctx context.Context,
-	sessionID, skipClientID int64,
+	sessionID int64,
 	nick, command, target string,
 	body, meta json.RawMessage,
 ) (*DirectMsgResult, error) {
@@ -495,7 +506,7 @@ func (s *Service) SendDirectMessage(
 
 	_, uuid, fanErr := s.FanOut(
 		ctx, command, nick, target, targetSID, 0,
-		nil, body, meta, recipients, skipClientID,
+		nil, body, meta, recipients,
 	)
 	// The target's session was deleted after the lookup above.
 	if db.IsForeignKeyConstraintError(fanErr) {
@@ -511,12 +522,11 @@ func (s *Service) SendDirectMessage(
 
 // JoinChannel creates or joins a channel, making the
 // first joiner the operator. Fans out the JOIN to all
-// channel members, skipping client skipClientID as FanOut
-// does. A channel name that validChannelRe does not match
-// gets ERR_NOSUCHCHANNEL.
+// channel members. A channel name that validChannelRe
+// does not match gets ERR_NOSUCHCHANNEL.
 func (s *Service) JoinChannel(
 	ctx context.Context,
-	sessionID, skipClientID int64,
+	sessionID int64,
 	nick, channel, suppliedKey string,
 ) (*JoinResult, error) {
 	if !validChannelRe.MatchString(channel) {
@@ -539,7 +549,7 @@ func (s *Service) JoinChannel(
 
 	_, _, _ = s.FanOut( //nolint:dogsled // fire-and-forget broadcast
 		ctx, irc.CmdJoin, nick, channel, 0, chID,
-		nil, body, nil, memberIDs, skipClientID,
+		nil, body, nil, memberIDs,
 	)
 
 	return &JoinResult{
@@ -548,12 +558,12 @@ func (s *Service) JoinChannel(
 	}, nil
 }
 
-// PartChannel validates membership, broadcasts PART to all
-// channel members, skipping client skipClientID as FanOut
-// does, removes the user, and cleans up empty channels.
+// PartChannel validates membership, broadcasts PART to
+// remaining members, removes the user, and cleans up empty
+// channels.
 func (s *Service) PartChannel(
 	ctx context.Context,
-	sessionID, skipClientID int64,
+	sessionID int64,
 	nick, channel, reason string,
 ) error {
 	chID, err := s.db.GetChannelByName(ctx, channel)
@@ -577,11 +587,12 @@ func (s *Service) PartChannel(
 	}
 
 	memberIDs, _ := s.db.GetChannelMemberIDs(ctx, chID)
+	recipients := excludeSession(memberIDs, sessionID)
 	body, _ := json.Marshal([]string{reason}) //nolint:errchkjson
 
 	_, _, _ = s.FanOut( //nolint:dogsled // fire-and-forget broadcast
 		ctx, irc.CmdPart, nick, channel, 0, chID,
-		nil, body, nil, memberIDs, skipClientID,
+		nil, body, nil, recipients,
 	)
 
 	s.db.PartChannelAndDeleteIfEmpty(ctx, chID, sessionID) //nolint:errcheck,gosec
@@ -590,11 +601,10 @@ func (s *Service) PartChannel(
 }
 
 // SetTopic validates membership and topic-lock, sets the
-// topic, and broadcasts the change to all channel members,
-// skipping client skipClientID as FanOut does.
+// topic, and broadcasts the change.
 func (s *Service) SetTopic(
 	ctx context.Context,
-	sessionID, skipClientID int64,
+	sessionID int64,
 	nick, channel, topic string,
 ) error {
 	chID, err := s.db.GetChannelByName(ctx, channel)
@@ -643,19 +653,18 @@ func (s *Service) SetTopic(
 
 	_, _, _ = s.FanOut( //nolint:dogsled // fire-and-forget broadcast
 		ctx, irc.CmdTopic, nick, channel, 0, chID,
-		nil, body, nil, memberIDs, skipClientID,
+		nil, body, nil, memberIDs,
 	)
 
 	return nil
 }
 
 // KickUser validates operator status and target
-// membership, broadcasts the KICK to all channel members,
-// skipping client skipClientID as FanOut does, removes the
-// target, and cleans up empty channels.
+// membership, broadcasts the KICK, removes the target,
+// and cleans up empty channels.
 func (s *Service) KickUser(
 	ctx context.Context,
-	sessionID, skipClientID int64,
+	sessionID int64,
 	nick, channel, targetNick, reason string,
 ) error {
 	chID, err := s.db.GetChannelByName(ctx, channel)
@@ -708,7 +717,7 @@ func (s *Service) KickUser(
 
 	_, _, _ = s.FanOut( //nolint:dogsled // fire-and-forget broadcast
 		ctx, irc.CmdKick, nick, channel, 0, chID,
-		params, body, nil, memberIDs, skipClientID,
+		params, body, nil, memberIDs,
 	)
 
 	s.db.PartChannelAndDeleteIfEmpty(ctx, chID, targetSID) //nolint:errcheck,gosec
@@ -789,11 +798,10 @@ func (s *Service) InviteUser(
 }
 
 // ChangeNick changes a user's nickname and broadcasts the
-// change to the user's own session and all users sharing
-// channels, skipping client skipClientID as FanOut does.
+// change to all users sharing channels.
 func (s *Service) ChangeNick(
 	ctx context.Context,
-	sessionID, skipClientID int64,
+	sessionID int64,
 	oldNick, newNick string,
 ) error {
 	err := s.db.ChangeNick(ctx, sessionID, newNick)
@@ -814,9 +822,7 @@ func (s *Service) ChangeNick(
 		}
 	}
 
-	s.broadcastNickChange(
-		ctx, sessionID, skipClientID, oldNick, newNick,
-	)
+	s.broadcastNickChange(ctx, sessionID, oldNick, newNick)
 
 	return nil
 }
@@ -1036,10 +1042,9 @@ func (s *Service) SetChannelFlag(
 }
 
 // BroadcastMode fans out a MODE change to all channel
-// members, skipping client skipClientID as FanOut does.
+// members.
 func (s *Service) BroadcastMode(
 	ctx context.Context,
-	skipClientID int64,
 	nick, channel string,
 	chID int64,
 	modeText string,
@@ -1049,7 +1054,7 @@ func (s *Service) BroadcastMode(
 
 	_, _, _ = s.FanOut( //nolint:dogsled // fire-and-forget broadcast
 		ctx, irc.CmdMode, nick, channel, 0, chID,
-		nil, body, nil, memberIDs, skipClientID,
+		nil, body, nil, memberIDs,
 	)
 }
 
@@ -1169,12 +1174,6 @@ func (s *Service) ApplyUserMode(
 	return s.QueryUserMode(ctx, sessionID)
 }
 
-// UserModes lists the user modes the server supports, as
-// RPL_MYINFO sends them: o (server operator) and w
-// (receives WALLOPS). parseUserModeString must accept the
-// same letters.
-const UserModes = "ow"
-
 // parseUserModeString parses a user mode string such as
 // "+w", "-o" or "+w-o" into the new value of each flag it
 // names, or nil for a flag it does not name; a later letter
@@ -1307,12 +1306,11 @@ func (s *Service) checkChannelHashcash(
 	return nil
 }
 
-// broadcastNickChange notifies the user's own session,
-// except client skipClientID, and channel peers of a nick
+// broadcastNickChange notifies channel peers of a nick
 // change.
 func (s *Service) broadcastNickChange(
 	ctx context.Context,
-	sessionID, skipClientID int64,
+	sessionID int64,
 	oldNick, newNick string,
 ) {
 	channels, err := s.db.GetSessionChannels(
@@ -1334,7 +1332,7 @@ func (s *Service) broadcastNickChange(
 	}
 
 	// Notify the user themselves (for multi-client sync).
-	_ = s.db.EnqueueToSession(ctx, sessionID, dbID, skipClientID)
+	_ = s.db.EnqueueToSession(ctx, sessionID, dbID)
 	s.broker.Notify(sessionID)
 	notified[sessionID] = true
 
@@ -1353,7 +1351,7 @@ func (s *Service) broadcastNickChange(
 
 			notified[mid] = true
 
-			_ = s.db.EnqueueToSession(ctx, mid, dbID, 0)
+			_ = s.db.EnqueueToSession(ctx, mid, dbID)
 			s.broker.Notify(mid)
 		}
 	}

internal/service/service_test.go

@@ -6,6 +6,7 @@ package service_test
 
 import (
 	"context"
+	"crypto/rand"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -22,7 +23,6 @@ import (
 	"sneak.berlin/go/neoirc/internal/broker"
 	"sneak.berlin/go/neoirc/internal/config"
 	"sneak.berlin/go/neoirc/internal/db"
-	"sneak.berlin/go/neoirc/internal/dbtest"
 	"sneak.berlin/go/neoirc/internal/globals"
 	"sneak.berlin/go/neoirc/internal/hashcash"
 	"sneak.berlin/go/neoirc/internal/logger"
@@ -46,7 +46,13 @@ type testEnv struct {
 func newTestEnv(t *testing.T) *testEnv {
 	t.Helper()
 
-	dbURL := dbtest.NewURL(t)
+	// A random name, so that no other test can share it, not
+	// even one that has finished but still holds its database
+	// open.
+	dbURL := fmt.Sprintf(
+		"file:%s?mode=memory&cache=shared",
+		rand.Text(),
+	)
 
 	var (
 		database *db.Database
@@ -162,7 +168,7 @@ func TestFanOut(t *testing.T) {
 	dbID, uuid, err := env.svc.FanOut(
 		ctx, irc.CmdPrivmsg, "alice", "#test", 0, 0,
 		nil, body, nil,
-		[]int64{sid1, sid2}, 0,
+		[]int64{sid1, sid2},
 	)
 	if err != nil {
 		t.Fatalf("FanOut: %v", err)
@@ -184,7 +190,7 @@ func TestJoinChannel(t *testing.T) {
 	sid := createSession(ctx, t, env.db, "alice")
 
 	result, err := env.svc.JoinChannel(
-		ctx, sid, 0, "alice", "#general", "",
+		ctx, sid, "alice", "#general", "",
 	)
 	if err != nil {
 		t.Fatalf("JoinChannel: %v", err)
@@ -202,7 +208,7 @@ func TestJoinChannel(t *testing.T) {
 	sid2 := createSession(ctx, t, env.db, "bob")
 
 	result2, err := env.svc.JoinChannel(
-		ctx, sid2, 0, "bob", "#general", "",
+		ctx, sid2, "bob", "#general", "",
 	)
 	if err != nil {
 		t.Fatalf("JoinChannel bob: %v", err)
@@ -224,14 +230,14 @@ func TestPartChannel(t *testing.T) {
 	sid := createSession(ctx, t, env.db, "alice")
 
 	_, err := env.svc.JoinChannel(
-		ctx, sid, 0, "alice", "#general", "",
+		ctx, sid, "alice", "#general", "",
 	)
 	if err != nil {
 		t.Fatalf("JoinChannel: %v", err)
 	}
 
 	err = env.svc.PartChannel(
-		ctx, sid, 0, "alice", "#general", "bye",
+		ctx, sid, "alice", "#general", "bye",
 	)
 	if err != nil {
 		t.Fatalf("PartChannel: %v", err)
@@ -239,7 +245,7 @@ func TestPartChannel(t *testing.T) {
 
 	// Parting a non-existent channel returns error.
 	err = env.svc.PartChannel(
-		ctx, sid, 0, "alice", "#nonexistent", "",
+		ctx, sid, "alice", "#nonexistent", "",
 	)
 	if err == nil {
 		t.Error("expected error for non-existent channel")
@@ -303,7 +309,7 @@ func joinConcurrently(
 
 		joins[i] = func() error {
 			result, err := env.svc.JoinChannel(
-				ctx, sessionID, 0, nick, channel, "",
+				ctx, sessionID, nick, channel, "",
 			)
 			results[i] = result
 
@@ -329,7 +335,7 @@ func TestConcurrentJoinsRespectUserLimit(t *testing.T) {
 		opSID := createSession(ctx, t, env.db, opNick)
 
 		created, err := env.svc.JoinChannel(
-			ctx, opSID, 0, opNick, channel, "",
+			ctx, opSID, opNick, channel, "",
 		)
 		if err != nil {
 			t.Fatalf("join %s: %v", opNick, err)
@@ -442,7 +448,7 @@ func TestJoinConcurrentWithLastPart(t *testing.T) {
 		joinerSID := createSession(ctx, t, env.db, joinerNick)
 
 		_, err := env.svc.JoinChannel(
-			ctx, leaverSID, 0, leaverNick, channel, "",
+			ctx, leaverSID, leaverNick, channel, "",
 		)
 		if err != nil {
 			t.Fatalf("join %s: %v", leaverNick, err)
@@ -451,12 +457,12 @@ func TestJoinConcurrentWithLastPart(t *testing.T) {
 		errs := runConcurrently(
 			func() error {
 				return env.svc.PartChannel(
-					ctx, leaverSID, 0, leaverNick, channel, "",
+					ctx, leaverSID, leaverNick, channel, "",
 				)
 			},
 			func() error {
 				_, joinErr := env.svc.JoinChannel(
-					ctx, joinerSID, 0, joinerNick, channel, "",
+					ctx, joinerSID, joinerNick, channel, "",
 				)
 
 				return joinErr
@@ -507,7 +513,7 @@ func TestJoinConcurrentWithLastQuit(t *testing.T) {
 		joinerSID := createSession(ctx, t, env.db, joinerNick)
 
 		created, err := env.svc.JoinChannel(
-			ctx, leaverSID, 0, leaverNick, channel, "",
+			ctx, leaverSID, leaverNick, channel, "",
 		)
 		if err != nil {
 			t.Fatalf("join %s: %v", leaverNick, err)
@@ -539,7 +545,7 @@ func TestJoinConcurrentWithLastQuit(t *testing.T) {
 					)
 
 					joined, joinErr = env.svc.JoinChannel(
-						ctx, joinerSID, 0, joinerNick, channel, "",
+						ctx, joinerSID, joinerNick, channel, "",
 					)
 					if !errors.As(joinErr, &ircErr) ||
 						ircErr.Code != irc.ErrBadChannelKey {
@@ -586,7 +592,7 @@ func TestQuitQueuedAheadOfNewNickHoldersJoin(t *testing.T) {
 		quitterSID := createSession(ctx, t, env.db, nick)
 
 		for _, channel := range []string{crowd, shared} {
-			_, err := env.svc.JoinChannel(ctx, quitterSID, 0, nick, channel, "")
+			_, err := env.svc.JoinChannel(ctx, quitterSID, nick, channel, "")
 			if err != nil {
 				t.Fatalf("join %s: %v", channel, err)
 			}
@@ -596,7 +602,7 @@ func TestQuitQueuedAheadOfNewNickHoldersJoin(t *testing.T) {
 			memberNick := fmt.Sprintf("crowd%dx%d", trial, member)
 			memberSID := createSession(ctx, t, env.db, memberNick)
 
-			_, err := env.svc.JoinChannel(ctx, memberSID, 0, memberNick, crowd, "")
+			_, err := env.svc.JoinChannel(ctx, memberSID, memberNick, crowd, "")
 			if err != nil {
 				t.Fatalf("join %s: %v", memberNick, err)
 			}
@@ -611,7 +617,7 @@ func TestQuitQueuedAheadOfNewNickHoldersJoin(t *testing.T) {
 			t.Fatalf("create session %s: %v", watcherNick, err)
 		}
 
-		_, err = env.svc.JoinChannel(ctx, watcherSID, 0, watcherNick, shared, "")
+		_, err = env.svc.JoinChannel(ctx, watcherSID, watcherNick, shared, "")
 		if err != nil {
 			t.Fatalf("join %s: %v", watcherNick, err)
 		}
@@ -672,7 +678,7 @@ func takeNickAndJoin(
 			return err
 		}
 
-		_, err = env.svc.JoinChannel(ctx, sessionID, 0, nick, channel, "")
+		_, err = env.svc.JoinChannel(ctx, sessionID, nick, channel, "")
 
 		return err
 	}
@@ -704,7 +710,7 @@ func TestJoinUsesUpInvite(t *testing.T) {
 	opSID := createSession(ctx, t, env.db, "op")
 	guestSID := createSession(ctx, t, env.db, "guest")
 
-	created, err := env.svc.JoinChannel(ctx, opSID, 0, "op", channel, "")
+	created, err := env.svc.JoinChannel(ctx, opSID, "op", channel, "")
 	if err != nil {
 		t.Fatalf("join op: %v", err)
 	}
@@ -719,17 +725,17 @@ func TestJoinUsesUpInvite(t *testing.T) {
 		t.Fatalf("invite guest: %v", err)
 	}
 
-	_, err = env.svc.JoinChannel(ctx, guestSID, 0, "guest", channel, "")
+	_, err = env.svc.JoinChannel(ctx, guestSID, "guest", channel, "")
 	if err != nil {
 		t.Fatalf("invited join: %v", err)
 	}
 
-	err = env.svc.PartChannel(ctx, guestSID, 0, "guest", channel, "")
+	err = env.svc.PartChannel(ctx, guestSID, "guest", channel, "")
 	if err != nil {
 		t.Fatalf("part guest: %v", err)
 	}
 
-	_, err = env.svc.JoinChannel(ctx, guestSID, 0, "guest", channel, "")
+	_, err = env.svc.JoinChannel(ctx, guestSID, "guest", channel, "")
 
 	var ircErr *service.IRCError
 	if !errors.As(err, &ircErr) || ircErr.Code != irc.ErrInviteOnlyChan {
@@ -748,7 +754,7 @@ func TestJoinRefusedByHostmaskBan(t *testing.T) {
 
 	opSID := createSession(ctx, t, env.db, "op")
 
-	created, err := env.svc.JoinChannel(ctx, opSID, 0, "op", channel, "")
+	created, err := env.svc.JoinChannel(ctx, opSID, "op", channel, "")
 	if err != nil {
 		t.Fatalf("join op: %v", err)
 	}
@@ -767,7 +773,7 @@ func TestJoinRefusedByHostmaskBan(t *testing.T) {
 		t.Fatalf("create session guest: %v", err)
 	}
 
-	_, err = env.svc.JoinChannel(ctx, guestSID, 0, "guest", channel, "")
+	_, err = env.svc.JoinChannel(ctx, guestSID, "guest", channel, "")
 
 	var ircErr *service.IRCError
 	if !errors.As(err, &ircErr) || ircErr.Code != irc.ErrBannedFromChan {
@@ -787,17 +793,17 @@ func TestPartDeletesChannelOnlyWhenEmpty(t *testing.T) {
 	aliceSID := createSession(ctx, t, env.db, "alice")
 	bobSID := createSession(ctx, t, env.db, "bob")
 
-	_, err := env.svc.JoinChannel(ctx, aliceSID, 0, "alice", channel, "")
+	_, err := env.svc.JoinChannel(ctx, aliceSID, "alice", channel, "")
 	if err != nil {
 		t.Fatalf("join alice: %v", err)
 	}
 
-	_, err = env.svc.JoinChannel(ctx, bobSID, 0, "bob", channel, "")
+	_, err = env.svc.JoinChannel(ctx, bobSID, "bob", channel, "")
 	if err != nil {
 		t.Fatalf("join bob: %v", err)
 	}
 
-	err = env.svc.PartChannel(ctx, aliceSID, 0, "alice", channel, "")
+	err = env.svc.PartChannel(ctx, aliceSID, "alice", channel, "")
 	if err != nil {
 		t.Fatalf("part alice: %v", err)
 	}
@@ -812,7 +818,7 @@ func TestPartDeletesChannelOnlyWhenEmpty(t *testing.T) {
 		t.Fatal("bob is not on the channel after alice parted")
 	}
 
-	err = env.svc.PartChannel(ctx, bobSID, 0, "bob", channel, "")
+	err = env.svc.PartChannel(ctx, bobSID, "bob", channel, "")
 	if err != nil {
 		t.Fatalf("part bob: %v", err)
 	}
@@ -833,12 +839,12 @@ func TestKickOfLastMemberDeletesChannel(t *testing.T) {
 
 	sid := createSession(ctx, t, env.db, "alice")
 
-	_, err := env.svc.JoinChannel(ctx, sid, 0, "alice", channel, "")
+	_, err := env.svc.JoinChannel(ctx, sid, "alice", channel, "")
 	if err != nil {
 		t.Fatalf("join alice: %v", err)
 	}
 
-	err = env.svc.KickUser(ctx, sid, 0, "alice", channel, "alice", "")
+	err = env.svc.KickUser(ctx, sid, "alice", channel, "alice", "")
 	if err != nil {
 		t.Fatalf("kick alice: %v", err)
 	}
@@ -857,14 +863,14 @@ func TestSendChannelMessage(t *testing.T) {
 	sid2 := createSession(ctx, t, env.db, "bob")
 
 	_, err := env.svc.JoinChannel(
-		ctx, sid1, 0, "alice", "#chat", "",
+		ctx, sid1, "alice", "#chat", "",
 	)
 	if err != nil {
 		t.Fatalf("join alice: %v", err)
 	}
 
 	_, err = env.svc.JoinChannel(
-		ctx, sid2, 0, "bob", "#chat", "",
+		ctx, sid2, "bob", "#chat", "",
 	)
 	if err != nil {
 		t.Fatalf("join bob: %v", err)
@@ -872,14 +878,18 @@ func TestSendChannelMessage(t *testing.T) {
 
 	body, _ := json.Marshal([]string{"hello world"}) //nolint:errchkjson
 
-	uuid, err := env.svc.SendChannelMessage(
-		ctx, sid1, 0, "alice",
+	dbID, uuid, err := env.svc.SendChannelMessage(
+		ctx, sid1, "alice",
 		irc.CmdPrivmsg, "#chat", body, nil,
 	)
 	if err != nil {
 		t.Fatalf("SendChannelMessage: %v", err)
 	}
 
+	if dbID == 0 {
+		t.Error("expected non-zero dbID")
+	}
+
 	if uuid == "" {
 		t.Error("expected non-empty UUID")
 	}
@@ -887,8 +897,8 @@ func TestSendChannelMessage(t *testing.T) {
 	// Non-member cannot send.
 	sid3 := createSession(ctx, t, env.db, "charlie")
 
-	_, err = env.svc.SendChannelMessage(
-		ctx, sid3, 0, "charlie",
+	_, _, err = env.svc.SendChannelMessage(
+		ctx, sid3, "charlie",
 		irc.CmdPrivmsg, "#chat", body, nil,
 	)
 	if err == nil {
@@ -904,14 +914,14 @@ func TestBroadcastQuit(t *testing.T) {
 	sid2 := createSession(ctx, t, env.db, "bob")
 
 	_, err := env.svc.JoinChannel(
-		ctx, sid1, 0, "alice", "#room", "",
+		ctx, sid1, "alice", "#room", "",
 	)
 	if err != nil {
 		t.Fatalf("join alice: %v", err)
 	}
 
 	_, err = env.svc.JoinChannel(
-		ctx, sid2, 0, "bob", "#room", "",
+		ctx, sid2, "bob", "#room", "",
 	)
 	if err != nil {
 		t.Fatalf("join bob: %v", err)
@@ -953,7 +963,7 @@ func TestSendDirectMessageTargetQuits(t *testing.T) {
 	body, _ := json.Marshal([]string{"hi"}) //nolint:errchkjson
 
 	_, err = env.svc.SendDirectMessage(
-		ctx, sid, 0, "alice", irc.CmdPrivmsg, "bob", body, nil,
+		ctx, sid, "alice", irc.CmdPrivmsg, "bob", body, nil,
 	)
 
 	var ircErr *service.IRCError
@@ -973,7 +983,7 @@ func TestSendChannelMessageChannelDeleted(t *testing.T) {
 
 	sid := createSession(ctx, t, env.db, "alice")
 
-	_, err := env.svc.JoinChannel(ctx, sid, 0, "alice", "#gone", "")
+	_, err := env.svc.JoinChannel(ctx, sid, "alice", "#gone", "")
 	if err != nil {
 		t.Fatalf("join alice: %v", err)
 	}
@@ -990,8 +1000,8 @@ func TestSendChannelMessageChannelDeleted(t *testing.T) {
 
 	body, _ := json.Marshal([]string{"hi"}) //nolint:errchkjson
 
-	_, err = env.svc.SendChannelMessage(
-		ctx, sid, 0, "alice", irc.CmdPrivmsg, "#gone", body, nil,
+	_, _, err = env.svc.SendChannelMessage(
+		ctx, sid, "alice", irc.CmdPrivmsg, "#gone", body, nil,
 	)
 
 	var ircErr *service.IRCError
@@ -1009,14 +1019,14 @@ func TestSendChannelMessage_Moderated(t *testing.T) {
 	sid2 := createSession(ctx, t, env.db, "bob")
 
 	result, err := env.svc.JoinChannel(
-		ctx, sid1, 0, "alice", "#modchat", "",
+		ctx, sid1, "alice", "#modchat", "",
 	)
 	if err != nil {
 		t.Fatalf("join alice: %v", err)
 	}
 
 	_, err = env.svc.JoinChannel(
-		ctx, sid2, 0, "bob", "#modchat", "",
+		ctx, sid2, "bob", "#modchat", "",
 	)
 	if err != nil {
 		t.Fatalf("join bob: %v", err)
@@ -1029,8 +1039,8 @@ func TestSendChannelMessage_Moderated(t *testing.T) {
 	body, _ := json.Marshal([]string{"test"}) //nolint:errchkjson
 
 	// Bob (non-op, non-voiced) should fail to send.
-	_, err = env.svc.SendChannelMessage(
-		ctx, sid2, 0, "bob",
+	_, _, err = env.svc.SendChannelMessage(
+		ctx, sid2, "bob",
 		irc.CmdPrivmsg, "#modchat", body, nil,
 	)
 	if err == nil {
@@ -1038,8 +1048,8 @@ func TestSendChannelMessage_Moderated(t *testing.T) {
 	}
 
 	// Alice (operator) should succeed.
-	_, err = env.svc.SendChannelMessage(
-		ctx, sid1, 0, "alice",
+	_, _, err = env.svc.SendChannelMessage(
+		ctx, sid1, "alice",
 		irc.CmdPrivmsg, "#modchat", body, nil,
 	)
 	if err != nil {
@@ -1064,7 +1074,7 @@ func TestRefusedChannelMessageLeavesStampUnspent(t *testing.T) {
 		refuse func(ctx context.Context, env *testEnv, chID, bobSID int64) error
 	}{
 		{"not a member", func(ctx context.Context, env *testEnv, _, bobSID int64) error {
-			return env.svc.PartChannel(ctx, bobSID, 0, "bob", channel, "")
+			return env.svc.PartChannel(ctx, bobSID, "bob", channel, "")
 		}},
 		{"banned", func(ctx context.Context, env *testEnv, chID, _ int64) error {
 			return env.db.AddChannelBan(ctx, chID, "bob!*@*", "alice")
@@ -1084,12 +1094,12 @@ func TestRefusedChannelMessageLeavesStampUnspent(t *testing.T) {
 			aliceSID := createSession(ctx, t, env.db, "alice")
 			bobSID := createSession(ctx, t, env.db, "bob")
 
-			joined, err := env.svc.JoinChannel(ctx, aliceSID, 0, "alice", channel, "")
+			joined, err := env.svc.JoinChannel(ctx, aliceSID, "alice", channel, "")
 			if err != nil {
 				t.Fatalf("join alice: %v", err)
 			}
 
-			_, err = env.svc.JoinChannel(ctx, bobSID, 0, "bob", channel, "")
+			_, err = env.svc.JoinChannel(ctx, bobSID, "bob", channel, "")
 			if err != nil {
 				t.Fatalf("join bob: %v", err)
 			}
@@ -1109,8 +1119,8 @@ func TestRefusedChannelMessageLeavesStampUnspent(t *testing.T) {
 			)
 			meta, _ := json.Marshal(map[string]string{"hashcash": stamp})
 
-			_, err = env.svc.SendChannelMessage(
-				ctx, bobSID, 0, "bob", irc.CmdPrivmsg, channel, body, meta,
+			_, _, err = env.svc.SendChannelMessage(
+				ctx, bobSID, "bob", irc.CmdPrivmsg, channel, body, meta,
 			)
 
 			var ircErr *service.IRCError
@@ -1119,8 +1129,8 @@ func TestRefusedChannelMessageLeavesStampUnspent(t *testing.T) {
 				t.Fatalf("bob: want ERR_CANNOTSENDTOCHAN, got %v", err)
 			}
 
-			_, err = env.svc.SendChannelMessage(
-				ctx, aliceSID, 0, "alice", irc.CmdPrivmsg, channel, body, meta,
+			_, _, err = env.svc.SendChannelMessage(
+				ctx, aliceSID, "alice", irc.CmdPrivmsg, channel, body, meta,
 			)
 			if err != nil {
 				t.Fatalf("alice with the same stamp: %v", err)

schema/README.md

@@ -1,101 +1,98 @@
-# Message schemas
+# Message Schemas
 
-This directory holds JSON Schema files (draft 2020-12) for the messages that the
-neoirc HTTP API carries. `message.json` describes the fields that every message
-can have. `commands/` has files for some commands. `numerics/` has files for
-some of the numeric replies. A numeric reply is a server reply named by a
-three-digit number, such as `001`. `README.md` at the repository root documents
-the protocol.
+JSON Schema definitions (draft 2020-12) for the neoirc protocol. Messages use
+**IRC command names and numeric reply codes** (RFC 1459/2812) encoded as JSON
+over HTTP.
 
-The server can also run an IRC listener for ordinary IRC clients. The IRC
-listener sends plain IRC lines, which these files do not describe.
+## Envelope
 
-## Message fields
-
-Every message is one JSON object, which `message.json` calls the envelope. These
-are the fields it can have:
-
-- `command`: the IRC command name, such as `PRIVMSG`, or the name of a numeric
-  reply, such as `RPL_WELCOME`. Always present.
-- `code`: the number of a numeric reply, such as `1` for `RPL_WELCOME`. Absent
-  on other messages.
-- `id`: the message's UUID, a unique ID that the server assigns.
-- `from`: the sender's nick, or the server name on a numeric reply or a `PONG`.
-- `to`: the target, such as a channel name starting with `#` or a nick.
-- `params`: an array of strings with the message's other parameters, in order.
-  `KICK` events and many numeric replies have it. The HTTP API ignores `params`
-  sent by a client.
-- `body`: an array of strings. It is never a bare string. In a `PRIVMSG` or
-  `NOTICE`, each string is one line of text.
-- `ts`: the time the server stored the message. It is an RFC 3339 time in UTC,
-  such as `2026-10-27T12:00:00.123Z`.
-- `meta`: an object of extra data, such as a hashcash stamp in `meta.hashcash`.
-  A hashcash stamp is a short string that takes a computer some work to make. A
-  `PRIVMSG` to a channel with mode `+H` needs one. The HTTP API relays the
-  `meta` of a `PRIVMSG` or `NOTICE` unchanged. It drops the `meta` of every
-  other command.
-
-Here is one `PRIVMSG` as the IRC listener sends it and as the HTTP API sends it.
-The JSON leaves out `id`, `ts` and `meta`:
+Every message is a JSON object with a `command` field. The format maps directly
+to IRC wire format:
 
 ```
-IRC:  :alice!alice@* PRIVMSG #general :hello world
-JSON: {"command": "PRIVMSG", "from": "alice", "to": "#general", "body": ["hello world"]}
+IRC:  :nick PRIVMSG #channel :hello world
+JSON: {"command": "PRIVMSG", "from": "nick", "to": "#channel", "body": ["hello world"]}
+
+IRC:  :server 353 nick = #channel :user1 @op1 +voice1
+JSON: {"command": "353", "to": "nick", "params": ["=", "#channel"], "body": ["user1 @op1 +voice1"]}
+
+Multiline:  {"command": "PRIVMSG", "to": "#ch", "body": ["line 1", "line 2"]}
+Structured: {"command": "PUBKEY", "body": {"alg": "ed25519", "key": "base64..."}}
 ```
 
-In the JSON, a numeric reply has its name in `command` and its number in `code`.
-This `353` reply lists the members of `#general`. The JSON again leaves out
-`id`, `ts` and `meta`:
+Common fields (see `message.json` for full schema):
 
-```
-{"command": "RPL_NAMREPLY", "code": 353, "from": "neoirc", "to": "alice",
- "params": ["=", "#general"], "body": ["@op1!op1@host1 alice!alice@host2"]}
-```
+| Field     | Type            | Description                                          |
+| --------- | --------------- | ---------------------------------------------------- |
+| `id`      | string (uuid)   | Server-assigned message UUID                         |
+| `command` | string          | IRC command or 3-digit numeric code                  |
+| `from`    | string          | Source nick or server name (IRC prefix)              |
+| `to`      | string          | Target: #channel or nick                             |
+| `params`  | string[]        | Middle parameters (mainly for numerics)              |
+| `body`    | array \| object | Structured body — never a raw string (see below)     |
+| `ts`      | string          | ISO 8601 timestamp (server-assigned, not in raw IRC) |
+| `meta`    | object          | Extensible metadata (signatures, hashes, etc.)       |
 
-A `PRIVMSG` whose `body` has two strings is a two-line message:
+**Structured bodies:** `body` is always an array of strings (for text) or an
+object (for structured data like PUBKEY). Never a raw string. This enables:
 
-```
-{"command": "PRIVMSG", "to": "#general", "body": ["line one", "line two"]}
-```
+- Multiline messages without escape sequences
+- Deterministic canonicalization via RFC 8785 JCS for signing
+- Structured data where needed
 
-## Files
+## Commands
 
-Most command files describe both the message a client sends and the message the
-server sends. Their field descriptions say where the two differ. The examples in
-the files leave out `id`, `ts` and `meta`.
+IRC commands used for client↔server and server↔server communication.
 
-Commands, in `commands/`:
+| Command   | File                    | RFC         | Description                |
+| --------- | ----------------------- | ----------- | -------------------------- |
+| `PRIVMSG` | `commands/PRIVMSG.json` | 1459 §4.4.1 | Message to channel or user |
+| `NOTICE`  | `commands/NOTICE.json`  | 1459 §4.4.2 | Notice (no auto-reply)     |
+| `JOIN`    | `commands/JOIN.json`    | 1459 §4.2.1 | Join a channel             |
+| `PART`    | `commands/PART.json`    | 1459 §4.2.2 | Leave a channel            |
+| `QUIT`    | `commands/QUIT.json`    | 1459 §4.1.6 | User disconnected          |
+| `NICK`    | `commands/NICK.json`    | 1459 §4.1.2 | Change nickname            |
+| `TOPIC`   | `commands/TOPIC.json`   | 1459 §4.2.4 | Get/set channel topic      |
+| `MODE`    | `commands/MODE.json`    | 1459 §4.2.3 | Set channel/user modes     |
+| `KICK`    | `commands/KICK.json`    | 1459 §4.2.8 | Kick user from channel     |
+| `PING`    | `commands/PING.json`    | 1459 §4.6.2 | Keepalive                  |
+| `PONG`    | `commands/PONG.json`    | 1459 §4.6.3 | Keepalive response         |
+| `PUBKEY`  | `commands/PUBKEY.json`  | (extension) | Announce/relay signing key |
 
-- `PRIVMSG.json`: a message to a channel or a user.
-- `NOTICE.json`: a notice, which is a message that a client must not answer
-  automatically.
-- `JOIN.json`: joining a channel.
-- `PART.json`: leaving a channel.
-- `QUIT.json`: leaving the server.
-- `NICK.json`: changing nick.
-- `TOPIC.json`: setting a channel's topic.
-- `MODE.json`: querying or changing a channel's modes or the user's own modes.
-- `KICK.json`: a channel operator removing a user from a channel.
-- `PING.json`: a check that the server still answers.
-- `PONG.json`: the answer to a `PING`, which is the HTTP response to it.
+## Numeric Replies
 
-Numeric replies, in `numerics/`:
+Three-digit codes for server responses, per IRC convention.
 
-- `001.json`: `RPL_WELCOME`, which welcomes the user.
-- `002.json`: `RPL_YOURHOST`, the server's name and version.
-- `003.json`: `RPL_CREATED`, the date the server last started.
-- `004.json`: `RPL_MYINFO`, the server's name, its version and its lists of
-  modes.
-- `322.json`: `RPL_LIST`, one channel in the answer to `LIST`.
-- `323.json`: `RPL_LISTEND`, the end of the answer to `LIST`.
-- `332.json`: `RPL_TOPIC`, a channel's topic.
-- `353.json`: `RPL_NAMREPLY`, a channel's members.
-- `366.json`: `RPL_ENDOFNAMES`, the end of the member list.
-- `372.json`: `RPL_MOTD`, one line of the message of the day.
-- `375.json`: `RPL_MOTDSTART`, the start of the message of the day.
-- `376.json`: `RPL_ENDOFMOTD`, the end of the message of the day.
-- `401.json`: `ERR_NOSUCHNICK`, the nick does not exist.
-- `403.json`: `ERR_NOSUCHCHANNEL`, the channel does not exist.
-- `433.json`: `ERR_NICKNAMEINUSE`, the nick is taken.
-- `442.json`: `ERR_NOTONCHANNEL`, the user is not on that channel.
-- `482.json`: `ERR_CHANOPRIVSNEEDED`, the user is not a channel operator.
+### Success / Informational (0xx–3xx)
+
+| Code  | Name           | File                | Description                    |
+| ----- | -------------- | ------------------- | ------------------------------ |
+| `001` | RPL_WELCOME    | `numerics/001.json` | Welcome after session creation |
+| `002` | RPL_YOURHOST   | `numerics/002.json` | Server host info               |
+| `003` | RPL_CREATED    | `numerics/003.json` | Server creation date           |
+| `004` | RPL_MYINFO     | `numerics/004.json` | Server info and modes          |
+| `322` | RPL_LIST       | `numerics/322.json` | Channel list entry             |
+| `323` | RPL_LISTEND    | `numerics/323.json` | End of channel list            |
+| `332` | RPL_TOPIC      | `numerics/332.json` | Channel topic                  |
+| `353` | RPL_NAMREPLY   | `numerics/353.json` | Channel member list            |
+| `366` | RPL_ENDOFNAMES | `numerics/366.json` | End of NAMES list              |
+| `372` | RPL_MOTD       | `numerics/372.json` | MOTD line                      |
+| `375` | RPL_MOTDSTART  | `numerics/375.json` | Start of MOTD                  |
+| `376` | RPL_ENDOFMOTD  | `numerics/376.json` | End of MOTD                    |
+
+### Errors (4xx)
+
+| Code  | Name                 | File                | Description             |
+| ----- | -------------------- | ------------------- | ----------------------- |
+| `401` | ERR_NOSUCHNICK       | `numerics/401.json` | No such nick/channel    |
+| `403` | ERR_NOSUCHCHANNEL    | `numerics/403.json` | No such channel         |
+| `433` | ERR_NICKNAMEINUSE    | `numerics/433.json` | Nickname already in use |
+| `442` | ERR_NOTONCHANNEL     | `numerics/442.json` | Not on that channel     |
+| `482` | ERR_CHANOPRIVSNEEDED | `numerics/482.json` | Not channel operator    |
+
+## Federation (S2S)
+
+Server-to-server messages use the same command format. Federated servers relay
+messages with an additional `origin` field in `meta` to track the source server.
+The PING/PONG commands serve as inter-server keepalives. State sync after link
+establishment uses a burst of JOIN, NICK, TOPIC, and MODE commands.

schema/commands/JOIN.json

@@ -2,25 +2,15 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/commands/JOIN.json",
   "title": "JOIN",
-  "description": "Join a channel. A client sends it to join a channel, which the server creates if it does not exist. The server sends it to every member of the channel when a user joins, the new member included. RFC 1459 §4.2.1.",
+  "description": "Join a channel. C2S: request to join. S2C: notification that a user joined. RFC 1459 §4.2.1.",
   "$ref": "../message.json",
   "properties": {
     "command": { "const": "JOIN" },
-    "from": { "type": "string", "description": "The nick that joined. The server sets it." },
-    "to": {
-      "type": "string",
-      "description": "The channel name: # and then 1 to 63 of a-z, A-Z, 0-9, _ and -. The server adds the # if a client leaves it out.",
-      "pattern": "^#?[a-zA-Z0-9_-]{1,63}$"
-    },
-    "body": {
-      "type": "array",
-      "items": { "type": "string" },
-      "description": "From a client: the channel key as the first string, which a channel with mode +k needs. From the server: the channel name. After a login, and for GET /api/v1/state?initChannelState=1, the server queues a JOIN for each of the session's channels. That JOIN has an empty body."
-    }
+    "from": { "type": "string", "description": "Nick that joined (S2C)." },
+    "to": { "type": "string", "description": "Channel name.", "pattern": "^#[a-zA-Z0-9_-]+$" }
   },
   "required": ["command", "to"],
   "examples": [
-    { "command": "JOIN", "to": "#general" },
-    { "command": "JOIN", "from": "alice", "to": "#general", "body": ["#general"] }
+    { "command": "JOIN", "from": "alice", "to": "#general" }
   ]
 }

schema/commands/KICK.json

@@ -2,33 +2,28 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/commands/KICK.json",
   "title": "KICK",
-  "description": "Remove a user from a channel. A client sends it, and only a channel operator may. The server sends it to every member of the channel, the removed user included. RFC 1459 §4.2.8.",
+  "description": "Kick a user from a channel. RFC 1459 §4.2.8.",
   "$ref": "../message.json",
   "properties": {
     "command": { "const": "KICK" },
-    "from": { "type": "string", "description": "The nick that removed the user. The server sets it." },
-    "to": {
-      "type": "string",
-      "description": "The channel name. The server adds the # if a client leaves it out.",
-      "pattern": "^#?[a-zA-Z0-9_-]{1,63}$"
-    },
+    "from": { "type": "string", "description": "Nick that performed the kick." },
+    "to": { "type": "string", "description": "Channel name.", "pattern": "^#[a-zA-Z0-9_-]+$" },
     "params": {
       "type": "array",
       "items": { "type": "string" },
-      "description": "The removed nick. Only the server sends it.",
+      "description": "Kicked nick. e.g. [\"alice\"].",
       "minItems": 1,
       "maxItems": 1
     },
     "body": {
       "type": "array",
       "items": { "type": "string" },
-      "description": "From a client: the nick to remove, then an optional reason. From the server: the reason, as one string.",
-      "minItems": 1
+      "description": "Optional kick reason.",
+      "maxItems": 1
     }
   },
-  "required": ["command", "to", "body"],
+  "required": ["command", "to", "params"],
   "examples": [
-    { "command": "KICK", "to": "#general", "body": ["troll", "Behave"] },
     { "command": "KICK", "from": "op1", "to": "#general", "params": ["troll"], "body": ["Behave"] }
   ]
 }

schema/commands/MODE.json

@@ -2,29 +2,28 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/commands/MODE.json",
   "title": "MODE",
-  "description": "Query or change a channel's modes or the user's own modes. A client sends it. The server sends it to every member of the channel when a channel mode changes. A +H or -H sent over the HTTP API is the exception. The server answers it with RPL_CHANNELMODEIS (324) and sends no MODE. RFC 1459 §4.2.3.",
+  "description": "Set or query channel/user modes. RFC 1459 §4.2.3.",
   "$ref": "../message.json",
   "properties": {
     "command": { "const": "MODE" },
     "from": {
       "type": "string",
-      "description": "The nick that changed the mode. The server sets it."
+      "description": "Nick that set the mode (S2C only)."
     },
     "to": {
       "type": "string",
-      "description": "A channel name, which starts with #, or the user's own nick."
+      "description": "Channel name.",
+      "pattern": "^#[a-zA-Z0-9_-]+$"
     },
-    "body": {
+    "params": {
       "type": "array",
       "items": { "type": "string" },
-      "description": "From a client: the mode change and then its value, as separate strings, such as \"+o\" and \"bob\". A MODE without a body is a query. From the server: the change and its value, as one string, such as \"+o bob\", or as separate strings, such as \"+k\" and \"secret\".",
-      "examples": [["+o", "bob"], ["-m"], ["+o bob"], ["+k", "secret"]]
+      "description": "Mode string and optional target nick. e.g. [\"+o\", \"alice\"].",
+      "examples": [["+o", "alice"], ["-m"], ["+v", "bob"]]
     }
   },
-  "required": ["command", "to"],
+  "required": ["command", "to", "params"],
   "examples": [
-    { "command": "MODE", "to": "#general", "body": ["+o", "bob"] },
-    { "command": "MODE", "from": "op1", "to": "#general", "body": ["+o bob"] },
-    { "command": "MODE", "from": "op1", "to": "#general", "body": ["+k", "secret"] }
+    { "command": "MODE", "from": "op1", "to": "#general", "params": ["+o", "alice"] }
   ]
 }

schema/commands/NICK.json

@@ -2,21 +2,21 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/commands/NICK.json",
   "title": "NICK",
-  "description": "Change nick. A client sends it to change its nick. The server sends it to the user's own clients and to the users who share a channel with the user. RFC 1459 §4.1.2.",
+  "description": "Change nickname. C2S: request new nick. S2C: notification of nick change. RFC 1459 §4.1.2.",
   "$ref": "../message.json",
   "properties": {
     "command": { "const": "NICK" },
-    "from": { "type": "string", "description": "The old nick. The server sets it." },
+    "from": { "type": "string", "description": "Old nick (S2C)." },
     "body": {
       "type": "array",
       "items": { "type": "string" },
-      "description": "The new nick, as the first string. The server sends one string.",
-      "minItems": 1
+      "description": "New nick (single-element array).",
+      "minItems": 1,
+      "maxItems": 1
     }
   },
   "required": ["command", "body"],
   "examples": [
-    { "command": "NICK", "body": ["newnick"] },
     { "command": "NICK", "from": "oldnick", "body": ["newnick"] }
   ]
 }

schema/commands/NOTICE.json

@@ -2,21 +2,20 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/commands/NOTICE.json",
   "title": "NOTICE",
-  "description": "A notice: a message to a channel or a user that a client must not answer automatically. The server relays it as it relays a PRIVMSG. A NOTICE to a channel with mode +H needs no hashcash stamp. RFC 1459 §4.4.2.",
+  "description": "Send a notice. Like PRIVMSG but must not trigger automatic replies. RFC 1459 §4.4.2.",
   "$ref": "../message.json",
   "properties": {
     "command": { "const": "NOTICE" },
-    "from": { "type": "string", "description": "The sender's nick. The server sets it." },
-    "to": { "type": "string", "description": "A channel name, which starts with #, or a nick." },
+    "from": { "type": "string" },
+    "to": { "type": "string", "description": "Target: #channel, nick, or * (global)." },
     "body": {
       "type": "array",
       "items": { "type": "string" },
-      "description": "The lines of the notice, one string per line.",
-      "minItems": 1
+      "description": "Notice text lines."
     }
   },
   "required": ["command", "to", "body"],
   "examples": [
-    { "command": "NOTICE", "from": "alice", "to": "#general", "body": ["Back in five minutes"] }
+    { "command": "NOTICE", "from": "server.example.com", "to": "*", "body": ["Server restarting in 5 minutes"] }
   ]
 }

schema/commands/PART.json

@@ -2,20 +2,17 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/commands/PART.json",
   "title": "PART",
-  "description": "Leave a channel. A client sends it to leave. The server sends it to every member of the channel when a user leaves, the leaving user included. RFC 1459 §4.2.2.",
+  "description": "Leave a channel. C2S: request to leave. S2C: notification that a user left. RFC 1459 §4.2.2.",
   "$ref": "../message.json",
   "properties": {
     "command": { "const": "PART" },
-    "from": { "type": "string", "description": "The nick that left. The server sets it." },
-    "to": {
-      "type": "string",
-      "description": "The channel name. The server adds the # if a client leaves it out.",
-      "pattern": "^#?[a-zA-Z0-9_-]{1,63}$"
-    },
+    "from": { "type": "string", "description": "Nick that left (S2C)." },
+    "to": { "type": "string", "description": "Channel name.", "pattern": "^#[a-zA-Z0-9_-]+$" },
     "body": {
       "type": "array",
       "items": { "type": "string" },
-      "description": "The reason for leaving. A client may send one as the first string. The server always sends one string, which is empty when no reason was given."
+      "description": "Optional part reason.",
+      "maxItems": 1
     }
   },
   "required": ["command", "to"],

schema/commands/PING.json

@@ -2,13 +2,19 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/commands/PING.json",
   "title": "PING",
-  "description": "A check that the server still answers. A client sends it. The server ignores every field but 'command'. Its answer is a PONG in the HTTP response. RFC 1459 §4.6.2.",
+  "description": "Keepalive. C2S or S2S. Server responds with PONG. RFC 1459 §4.6.2.",
   "$ref": "../message.json",
   "properties": {
-    "command": { "const": "PING" }
+    "command": { "const": "PING" },
+    "body": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Opaque token to be echoed in PONG (single-element array).",
+      "maxItems": 1
+    }
   },
   "required": ["command"],
   "examples": [
-    { "command": "PING" }
+    { "command": "PING", "body": ["1707580000"] }
   ]
 }

schema/commands/PONG.json

@@ -2,14 +2,20 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/commands/PONG.json",
   "title": "PONG",
-  "description": "The answer to a PING. The server sends it as the HTTP response to the PING, with only 'command' and 'from'. A client's PONG gets ERR_UNKNOWNCOMMAND (421). RFC 1459 §4.6.3.",
+  "description": "Keepalive response. S2C or S2S. RFC 1459 §4.6.3.",
   "$ref": "../message.json",
   "properties": {
     "command": { "const": "PONG" },
-    "from": { "type": "string", "description": "The server name." }
+    "from": { "type": "string", "description": "Responding server name." },
+    "body": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Echoed token from PING (single-element array).",
+      "maxItems": 1
+    }
   },
-  "required": ["command", "from"],
+  "required": ["command"],
   "examples": [
-    { "command": "PONG", "from": "neoirc" }
+    { "command": "PONG", "from": "server.example.com", "body": ["1707580000"] }
   ]
 }

schema/commands/PRIVMSG.json

@@ -2,16 +2,16 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/commands/PRIVMSG.json",
   "title": "PRIVMSG",
-  "description": "A message to a channel or a user. A client sends it. The server relays it to every member of the channel, or to the user, and to the sender's own clients. RFC 1459 §4.4.1.",
+  "description": "Send a message to a channel or user. C2S: client sends to server. S2C: server relays to recipients. RFC 1459 §4.4.1.",
   "$ref": "../message.json",
   "properties": {
     "command": { "const": "PRIVMSG" },
-    "from": { "type": "string", "description": "The sender's nick. The server sets it." },
-    "to": { "type": "string", "description": "A channel name, which starts with #, or a nick.", "examples": ["#general", "alice"] },
+    "from": { "type": "string", "description": "Sender nick (set by server on relay)." },
+    "to": { "type": "string", "description": "Target: #channel or nick.", "examples": ["#general", "alice"] },
     "body": {
       "type": "array",
       "items": { "type": "string" },
-      "description": "The lines of the message, one string per line.",
+      "description": "Message lines. One string per line.",
       "minItems": 1
     }
   },
@@ -19,6 +19,6 @@
   "examples": [
     { "command": "PRIVMSG", "from": "bob", "to": "#general", "body": ["hello world"] },
     { "command": "PRIVMSG", "from": "bob", "to": "#general", "body": ["line one", "line two"] },
-    { "command": "PRIVMSG", "from": "bob", "to": "alice", "body": ["hey"] }
+    { "command": "PRIVMSG", "from": "bob", "to": "alice", "body": ["hey"], "meta": { "sig": "base64...", "alg": "ed25519" } }
   ]
 }

schema/commands/PUBKEY.json

@@ -0,0 +1,37 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://sneak.berlin/go/neoirc/schema/commands/PUBKEY.json",
+  "title": "PUBKEY",
+  "description": "Announce or relay a user's public signing key. C2S: client announces key to channel or server. S2C: server relays to channel members. Protocol extension (not in RFC 1459). Body is a structured object (not an array) containing the key material.",
+  "$ref": "../message.json",
+  "properties": {
+    "command": { "const": "PUBKEY" },
+    "from": { "type": "string", "description": "Nick announcing the key (set by server on relay)." },
+    "to": {
+      "type": "string",
+      "description": "Target: #channel to announce to channel members, or omit for server-wide announcement."
+    },
+    "body": {
+      "type": "object",
+      "description": "Key material.",
+      "properties": {
+        "alg": {
+          "type": "string",
+          "description": "Key algorithm.",
+          "enum": ["ed25519"]
+        },
+        "key": {
+          "type": "string",
+          "description": "Base64-encoded public key."
+        }
+      },
+      "required": ["alg", "key"],
+      "additionalProperties": false
+    }
+  },
+  "required": ["command", "body"],
+  "examples": [
+    { "command": "PUBKEY", "from": "alice", "body": { "alg": "ed25519", "key": "base64-encoded-pubkey" } },
+    { "command": "PUBKEY", "from": "alice", "to": "#general", "body": { "alg": "ed25519", "key": "base64-encoded-pubkey" } }
+  ]
+}

schema/commands/QUIT.json

@@ -2,20 +2,20 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/commands/QUIT.json",
   "title": "QUIT",
-  "description": "A user left the server. A client sends it to end its session. The server sends it to the users who shared a channel with the user who left. RFC 1459 §4.1.6.",
+  "description": "User disconnected. S2C only. RFC 1459 §4.1.6.",
   "$ref": "../message.json",
   "properties": {
     "command": { "const": "QUIT" },
-    "from": { "type": "string", "description": "The nick that quit. The server sets it." },
+    "from": { "type": "string", "description": "Nick that quit." },
     "body": {
       "type": "array",
       "items": { "type": "string" },
-      "description": "The reason for leaving. A client may send one as the first string, and the server uses 'Client quit' when it does not. The server always sends one string."
+      "description": "Optional quit reason.",
+      "maxItems": 1
     }
   },
-  "required": ["command"],
+  "required": ["command", "from"],
   "examples": [
-    { "command": "QUIT", "body": ["Gone for the day"] },
-    { "command": "QUIT", "from": "alice", "body": ["Connection closed"] }
+    { "command": "QUIT", "from": "alice", "body": ["Connection reset"] }
   ]
 }

schema/commands/TOPIC.json

@@ -2,24 +2,20 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/commands/TOPIC.json",
   "title": "TOPIC",
-  "description": "Set a channel's topic. A client sends it to set the topic. The server sends it to every member of the channel when the topic changes. RFC 1459 §4.2.4.",
+  "description": "Get or set channel topic. C2S: set topic (body present) or query (body absent). S2C: topic change notification. RFC 1459 §4.2.4.",
   "$ref": "../message.json",
   "properties": {
     "command": { "const": "TOPIC" },
-    "from": { "type": "string", "description": "The nick that set the topic. The server sets it." },
-    "to": {
-      "type": "string",
-      "description": "The channel name. The server adds the # if a client leaves it out.",
-      "pattern": "^#?[a-zA-Z0-9_-]{1,63}$"
-    },
+    "from": { "type": "string", "description": "Nick that changed the topic (S2C)." },
+    "to": { "type": "string", "description": "Channel name.", "pattern": "^#[a-zA-Z0-9_-]+$" },
     "body": {
       "type": "array",
       "items": { "type": "string" },
-      "description": "The new topic. The server joins a client's strings with spaces, and sends the topic as one string. [\"\"] clears the topic.",
-      "minItems": 1
+      "description": "New topic text (single-element array). Empty array clears the topic.",
+      "maxItems": 1
     }
   },
-  "required": ["command", "to", "body"],
+  "required": ["command", "to"],
   "examples": [
     { "command": "TOPIC", "from": "alice", "to": "#general", "body": ["Welcome to the channel"] }
   ]

schema/message.json

@@ -2,55 +2,67 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/message.json",
   "title": "IRC Message Envelope",
-  "description": "Every message in the HTTP API is one JSON object with these fields. Only 'command' is always present.",
+  "description": "Base envelope for all messages. Mirrors IRC wire format (RFC 1459/2812) encoded as JSON over HTTP. The 'command' field carries either an IRC command name (PRIVMSG, JOIN, etc.) or a three-digit numeric reply code (001, 353, 433, etc.).",
   "type": "object",
   "properties": {
     "id": {
       "type": "string",
       "format": "uuid",
-      "description": "The message's UUID, which the server assigns. Present on every message the server queues for a client."
+      "description": "Server-assigned message UUID. Present on all server-originated messages."
     },
     "command": {
       "type": "string",
-      "description": "An IRC command name, such as PRIVMSG, or the name of a numeric reply, such as RPL_WELCOME. The server reads a client's command in any case and sends it in upper case.",
-      "examples": ["PRIVMSG", "JOIN", "RPL_WELCOME", "ERR_NICKNAMEINUSE"]
-    },
-    "code": {
-      "type": "integer",
-      "minimum": 1,
-      "maximum": 999,
-      "description": "The number of a numeric reply, such as 1 for RPL_WELCOME. Absent on other messages."
+      "description": "IRC command name (PRIVMSG, JOIN, NICK, etc.) or three-digit numeric reply code (001, 353, 433, etc.).",
+      "examples": ["PRIVMSG", "JOIN", "001", "353", "433"]
     },
     "from": {
       "type": "string",
-      "description": "The sender's nick, or the server name on a numeric reply or a PONG. The server sets it and ignores it from a client."
+      "description": "Source — nick for user messages, server name for server messages. Equivalent to IRC prefix."
     },
     "to": {
       "type": "string",
-      "description": "The target: a channel name, such as #general, or a nick. A WALLOPS has * here."
+      "description": "Target — channel (#name) or nick. Equivalent to first IRC parameter for most commands."
     },
     "params": {
       "type": "array",
       "items": { "type": "string" },
-      "description": "The message's other parameters, in order. KICK events and many numeric replies have it. The server ignores it from a client."
+      "description": "Additional parameters (used primarily by numeric replies). Equivalent to IRC middle parameters."
     },
     "body": {
-      "type": "array",
-      "items": { "type": "string" },
-      "description": "An array of strings, never a bare string. In a PRIVMSG or NOTICE, each string is one line of text."
+      "oneOf": [
+        {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Array of strings (one per line for text messages)."
+        },
+        {
+          "type": "object",
+          "description": "Structured data (e.g. PUBKEY key material).",
+          "additionalProperties": true
+        }
+      ],
+      "description": "Message body. MUST be an array or object, never a raw string. Arrays represent lines of text; objects carry structured data. This enables deterministic canonicalization (RFC 8785 JCS) for signing."
     },
     "ts": {
       "type": "string",
       "format": "date-time",
-      "description": "The time the server stored the message, as an RFC 3339 time in UTC."
+      "description": "Server-assigned timestamp (ISO 8601). Not present in original IRC; added for HTTP transport."
     },
     "meta": {
       "type": "object",
-      "description": "An object of extra data. Every message the server queues for a client has meta, which is {} when there is none. The server keeps a client's meta only on a PRIVMSG or NOTICE, and relays it unchanged.",
+      "description": "Extensible metadata. Used for signatures (meta.sig, meta.alg), hashes (meta.hash), and client extensions.",
       "properties": {
-        "hashcash": {
+        "sig": {
           "type": "string",
-          "description": "A hashcash stamp. A PRIVMSG to a channel with mode +H needs one."
+          "description": "Base64-encoded cryptographic signature over the canonical message form."
+        },
+        "alg": {
+          "type": "string",
+          "description": "Signature algorithm (e.g. 'ed25519')."
+        },
+        "hash": {
+          "type": "string",
+          "description": "Hash of the canonical message form (e.g. 'sha256:base64...')."
         }
       },
       "additionalProperties": true

schema/numerics/001.json

@@ -2,45 +2,32 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/numerics/001.json",
   "title": "001 RPL_WELCOME",
-  "description": "Welcomes the user. Sent after a session is created, after a login, and in answer to MOTD. RFC 2812 §5.1.",
+  "description": "Welcome message sent after successful session creation. RFC 2812 \u00a75.1.",
   "$ref": "../message.json",
   "properties": {
     "command": {
-      "const": "RPL_WELCOME"
-    },
-    "code": {
-      "const": 1
-    },
-    "from": {
-      "type": "string",
-      "description": "The server name."
+      "const": "001"
     },
     "to": {
       "type": "string",
-      "description": "The user's nick."
+      "description": "Target nick."
     },
     "body": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "One string: 'Welcome to the network, ' and the user's nick.",
-      "minItems": 1,
-      "maxItems": 1
+      "description": "Welcome text lines."
     }
   },
   "required": [
     "command",
-    "code",
-    "from",
     "to",
     "body"
   ],
   "examples": [
     {
-      "command": "RPL_WELCOME",
-      "code": 1,
-      "from": "neoirc",
+      "command": "001",
       "to": "alice",
       "body": [
         "Welcome to the network, alice"

schema/numerics/002.json

@@ -2,48 +2,34 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/numerics/002.json",
   "title": "002 RPL_YOURHOST",
-  "description": "The server's name and version. Sent right after RPL_WELCOME. RFC 2812 §5.1.",
+  "description": "Server host info sent after session creation. RFC 2812 \u00a75.1.",
   "$ref": "../message.json",
   "properties": {
     "command": {
-      "const": "RPL_YOURHOST"
-    },
-    "code": {
-      "const": 2
-    },
-    "from": {
-      "type": "string",
-      "description": "The server name."
+      "const": "002"
     },
     "to": {
-      "type": "string",
-      "description": "The user's nick."
+      "type": "string"
     },
     "body": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "One string: 'Your host is ', the server name, ', running version ' and the version.",
-      "minItems": 1,
-      "maxItems": 1
+      "description": "Host info lines."
     }
   },
   "required": [
     "command",
-    "code",
-    "from",
     "to",
     "body"
   ],
   "examples": [
     {
-      "command": "RPL_YOURHOST",
-      "code": 2,
-      "from": "neoirc",
+      "command": "002",
       "to": "alice",
       "body": [
-        "Your host is neoirc, running version dev"
+        "Your host is neoirc.example.com, running version 0.1.0"
       ]
     }
   ]

schema/numerics/003.json

@@ -2,45 +2,31 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/numerics/003.json",
   "title": "003 RPL_CREATED",
-  "description": "The date the server last started. Sent right after RPL_YOURHOST. RFC 2812 §5.1.",
+  "description": "Server creation date. RFC 2812 \u00a75.1.",
   "$ref": "../message.json",
   "properties": {
     "command": {
-      "const": "RPL_CREATED"
-    },
-    "code": {
-      "const": 3
-    },
-    "from": {
-      "type": "string",
-      "description": "The server name."
+      "const": "003"
     },
     "to": {
-      "type": "string",
-      "description": "The user's nick."
+      "type": "string"
     },
     "body": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "One string: 'This server was created ' and the start date as YYYY-MM-DD.",
-      "minItems": 1,
-      "maxItems": 1
+      "description": "Text lines."
     }
   },
   "required": [
     "command",
-    "code",
-    "from",
     "to",
     "body"
   ],
   "examples": [
     {
-      "command": "RPL_CREATED",
-      "code": 3,
-      "from": "neoirc",
+      "command": "003",
       "to": "alice",
       "body": [
         "This server was created 2026-02-01"

schema/numerics/004.json

@@ -2,64 +2,37 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/numerics/004.json",
   "title": "004 RPL_MYINFO",
-  "description": "The server's name, its version, and its lists of user and channel modes. Sent right after RPL_CREATED. RFC 2812 §5.1.",
+  "description": "Server info (name, version, available modes). RFC 2812 \u00a75.1.",
   "$ref": "../message.json",
   "properties": {
     "command": {
-      "const": "RPL_MYINFO"
-    },
-    "code": {
-      "const": 4
-    },
-    "from": {
-      "type": "string",
-      "description": "The server name."
+      "const": "004"
     },
     "to": {
-      "type": "string",
-      "description": "The user's nick."
+      "type": "string"
     },
     "params": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "The server name, the version, the user modes 'ow' and the channel modes 'Hbiklmnostv'.",
-      "minItems": 4,
-      "maxItems": 4
-    },
-    "body": {
-      "type": "array",
-      "items": {
-        "type": "string"
-      },
-      "description": "One empty string.",
-      "minItems": 1,
-      "maxItems": 1
+      "description": "[server_name, version, user_modes, channel_modes]."
     }
   },
   "required": [
     "command",
-    "code",
-    "from",
     "to",
-    "params",
-    "body"
+    "params"
   ],
   "examples": [
     {
-      "command": "RPL_MYINFO",
-      "code": 4,
-      "from": "neoirc",
+      "command": "004",
       "to": "alice",
       "params": [
-        "neoirc",
-        "dev",
-        "ow",
-        "Hbiklmnostv"
-      ],
-      "body": [
-        ""
+        "neoirc.example.com",
+        "0.1.0",
+        "o",
+        "imnst+ov"
       ]
     }
   ]

schema/numerics/322.json

@@ -2,55 +2,38 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/numerics/322.json",
   "title": "322 RPL_LIST",
-  "description": "One channel in the answer to LIST. The answer has one per channel, except a secret channel, one with mode +s, that the user is not on. RFC 1459 §6.2.",
+  "description": "Channel list entry. One per channel in response to LIST. RFC 1459 \u00a76.2.",
   "$ref": "../message.json",
   "properties": {
     "command": {
-      "const": "RPL_LIST"
-    },
-    "code": {
-      "const": 322
-    },
-    "from": {
-      "type": "string",
-      "description": "The server name."
+      "const": "322"
     },
     "to": {
-      "type": "string",
-      "description": "The user's nick."
+      "type": "string"
     },
     "params": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "The channel name and its number of members.",
-      "minItems": 2,
-      "maxItems": 2
+      "description": "[channel, visible_count]."
     },
     "body": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "One string: the channel's topic, empty when it has none.",
-      "minItems": 1,
-      "maxItems": 1
+      "description": "Channel topic."
     }
   },
   "required": [
     "command",
-    "code",
-    "from",
     "to",
-    "params",
-    "body"
+    "params"
   ],
   "examples": [
     {
-      "command": "RPL_LIST",
-      "code": 322,
-      "from": "neoirc",
+      "command": "322",
       "to": "alice",
       "params": [
         "#general",

schema/numerics/323.json

@@ -2,49 +2,26 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/numerics/323.json",
   "title": "323 RPL_LISTEND",
-  "description": "The end of the answer to LIST. RFC 1459 §6.2.",
+  "description": "End of channel list. RFC 1459 \u00a76.2.",
   "$ref": "../message.json",
   "properties": {
     "command": {
-      "const": "RPL_LISTEND"
-    },
-    "code": {
-      "const": 323
-    },
-    "from": {
-      "type": "string",
-      "description": "The server name."
+      "const": "323"
     },
     "to": {
-      "type": "string",
-      "description": "The user's nick."
+      "type": "string"
     },
     "body": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "One string: 'End of /LIST'.",
-      "minItems": 1,
+      "description": "End of /LIST",
       "maxItems": 1
     }
   },
   "required": [
     "command",
-    "code",
-    "from",
-    "to",
-    "body"
-  ],
-  "examples": [
-    {
-      "command": "RPL_LISTEND",
-      "code": 323,
-      "from": "neoirc",
-      "to": "alice",
-      "body": [
-        "End of /LIST"
-      ]
-    }
+    "to"
   ]
 }

schema/numerics/332.json

@@ -2,55 +2,39 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/numerics/332.json",
   "title": "332 RPL_TOPIC",
-  "description": "A channel's topic. Sent to a client after it sets the topic, and after it joins a channel that has one. Also sent for each of a session's channels that has one after a login, and for GET /api/v1/state?initChannelState=1. RFC 1459 §6.2.",
+  "description": "Channel topic (sent on JOIN or TOPIC query). RFC 1459 \u00a76.2.",
   "$ref": "../message.json",
   "properties": {
     "command": {
-      "const": "RPL_TOPIC"
-    },
-    "code": {
-      "const": 332
-    },
-    "from": {
-      "type": "string",
-      "description": "The server name."
+      "const": "332"
     },
     "to": {
-      "type": "string",
-      "description": "The user's nick."
+      "type": "string"
     },
     "params": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "The channel name.",
-      "minItems": 1,
-      "maxItems": 1
+      "description": "[channel]."
     },
     "body": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "One string: the topic.",
-      "minItems": 1,
-      "maxItems": 1
+      "description": "Topic text."
     }
   },
   "required": [
     "command",
-    "code",
-    "from",
     "to",
     "params",
     "body"
   ],
   "examples": [
     {
-      "command": "RPL_TOPIC",
-      "code": 332,
-      "from": "neoirc",
+      "command": "332",
       "to": "alice",
       "params": [
         "#general"

schema/numerics/353.json

@@ -2,62 +2,46 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/numerics/353.json",
   "title": "353 RPL_NAMREPLY",
-  "description": "A channel's members. Sent to a client after it joins a channel, and in answer to NAMES. Also sent for each of a session's channels after a login, and for GET /api/v1/state?initChannelState=1. RFC 1459 §6.2.",
+  "description": "Channel member list. Sent on JOIN or NAMES query. RFC 1459 \u00a76.2.",
   "$ref": "../message.json",
   "properties": {
     "command": {
-      "const": "RPL_NAMREPLY"
-    },
-    "code": {
-      "const": 353
-    },
-    "from": {
-      "type": "string",
-      "description": "The server name."
+      "const": "353"
     },
     "to": {
-      "type": "string",
-      "description": "The user's nick."
+      "type": "string"
     },
     "params": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "'=' and the channel name. The server always sends '='.",
-      "minItems": 2,
-      "maxItems": 2
+      "description": "[channel_type, channel]. channel_type: = (public), * (private), @ (secret)."
     },
     "body": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "One string: the members as nick!user@host, separated by spaces. '@' comes before a channel operator and '+' before a voiced member. The host is '*' when the server does not know it.",
-      "minItems": 1,
-      "maxItems": 1
+      "description": "Space-separated list of nicks. Prefixed with @ for ops, + for voiced."
     }
   },
   "required": [
     "command",
-    "code",
-    "from",
     "to",
     "params",
     "body"
   ],
   "examples": [
     {
-      "command": "RPL_NAMREPLY",
-      "code": 353,
-      "from": "neoirc",
+      "command": "353",
       "to": "alice",
       "params": [
         "=",
         "#general"
       ],
       "body": [
-        "@op1!op1@host1 alice!alice@host2 +bob!bob@host3"
+        "@op1 alice bob +voiced1"
       ]
     }
   ]

schema/numerics/366.json

@@ -2,62 +2,34 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/numerics/366.json",
   "title": "366 RPL_ENDOFNAMES",
-  "description": "The end of a channel's member list. It comes after the RPL_NAMREPLY for the channel. RFC 1459 §6.2.",
+  "description": "End of NAMES list. RFC 1459 \u00a76.2.",
   "$ref": "../message.json",
   "properties": {
     "command": {
-      "const": "RPL_ENDOFNAMES"
-    },
-    "code": {
-      "const": 366
-    },
-    "from": {
-      "type": "string",
-      "description": "The server name."
+      "const": "366"
     },
     "to": {
-      "type": "string",
-      "description": "The user's nick."
+      "type": "string"
     },
     "params": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "The channel name.",
-      "minItems": 1,
-      "maxItems": 1
+      "description": "[channel]."
     },
     "body": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "One string: 'End of /NAMES list'.",
-      "minItems": 1,
+      "description": "End of /NAMES list",
       "maxItems": 1
     }
   },
   "required": [
     "command",
-    "code",
-    "from",
     "to",
-    "params",
-    "body"
-  ],
-  "examples": [
-    {
-      "command": "RPL_ENDOFNAMES",
-      "code": 366,
-      "from": "neoirc",
-      "to": "alice",
-      "params": [
-        "#general"
-      ],
-      "body": [
-        "End of /NAMES list"
-      ]
-    }
+    "params"
   ]
 }

schema/numerics/372.json

@@ -2,45 +2,31 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/numerics/372.json",
   "title": "372 RPL_MOTD",
-  "description": "One line of the message of the day. The server sends one per line, after RPL_MOTDSTART. RFC 2812 §5.1.",
+  "description": "MOTD line. One message per line of the MOTD. RFC 2812 \u00a75.1.",
   "$ref": "../message.json",
   "properties": {
     "command": {
-      "const": "RPL_MOTD"
-    },
-    "code": {
-      "const": 372
-    },
-    "from": {
-      "type": "string",
-      "description": "The server name."
+      "const": "372"
     },
     "to": {
-      "type": "string",
-      "description": "The user's nick."
+      "type": "string"
     },
     "body": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "One string: '- ' and the line.",
-      "minItems": 1,
-      "maxItems": 1
+      "description": "MOTD line text (prefixed with '- ')."
     }
   },
   "required": [
     "command",
-    "code",
-    "from",
     "to",
     "body"
   ],
   "examples": [
     {
-      "command": "RPL_MOTD",
-      "code": 372,
-      "from": "neoirc",
+      "command": "372",
       "to": "alice",
       "body": [
         "- Welcome to our server!"

schema/numerics/375.json

@@ -2,49 +2,25 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/numerics/375.json",
   "title": "375 RPL_MOTDSTART",
-  "description": "The start of the message of the day. Sent after RPL_LUSERME (255) when the server has a message of the day. RFC 2812 §5.1.",
+  "description": "Start of MOTD. RFC 2812 \u00a75.1.",
   "$ref": "../message.json",
   "properties": {
     "command": {
-      "const": "RPL_MOTDSTART"
-    },
-    "code": {
-      "const": 375
-    },
-    "from": {
-      "type": "string",
-      "description": "The server name."
+      "const": "375"
     },
     "to": {
-      "type": "string",
-      "description": "The user's nick."
+      "type": "string"
     },
     "body": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "One string: '- ', the server name and ' Message of the Day -'.",
-      "minItems": 1,
-      "maxItems": 1
+      "description": "Text lines."
     }
   },
   "required": [
     "command",
-    "code",
-    "from",
-    "to",
-    "body"
-  ],
-  "examples": [
-    {
-      "command": "RPL_MOTDSTART",
-      "code": 375,
-      "from": "neoirc",
-      "to": "alice",
-      "body": [
-        "- neoirc Message of the Day -"
-      ]
-    }
+    "to"
   ]
 }

schema/numerics/376.json

@@ -2,49 +2,26 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/numerics/376.json",
   "title": "376 RPL_ENDOFMOTD",
-  "description": "The end of the message of the day. RFC 2812 §5.1.",
+  "description": "End of MOTD. RFC 2812 \u00a75.1.",
   "$ref": "../message.json",
   "properties": {
     "command": {
-      "const": "RPL_ENDOFMOTD"
-    },
-    "code": {
-      "const": 376
-    },
-    "from": {
-      "type": "string",
-      "description": "The server name."
+      "const": "376"
     },
     "to": {
-      "type": "string",
-      "description": "The user's nick."
+      "type": "string"
     },
     "body": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "One string: 'End of /MOTD command.'.",
-      "minItems": 1,
+      "description": "End of /MOTD command",
       "maxItems": 1
     }
   },
   "required": [
     "command",
-    "code",
-    "from",
-    "to",
-    "body"
-  ],
-  "examples": [
-    {
-      "command": "RPL_ENDOFMOTD",
-      "code": 376,
-      "from": "neoirc",
-      "to": "alice",
-      "body": [
-        "End of /MOTD command."
-      ]
-    }
+    "to"
   ]
 }

schema/numerics/401.json

@@ -2,61 +2,45 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/numerics/401.json",
   "title": "401 ERR_NOSUCHNICK",
-  "description": "No user has that nick. RFC 1459 §6.1.",
+  "description": "No such nick/channel. RFC 1459 \u00a76.1.",
   "$ref": "../message.json",
   "properties": {
     "command": {
-      "const": "ERR_NOSUCHNICK"
-    },
-    "code": {
-      "const": 401
-    },
-    "from": {
-      "type": "string",
-      "description": "The server name."
+      "const": "401"
     },
     "to": {
-      "type": "string",
-      "description": "The user's nick."
+      "type": "string"
     },
     "params": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "The nick that was not found.",
-      "minItems": 1,
-      "maxItems": 1
+      "description": "[target_nick]."
     },
     "body": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "One string: 'No such nick' in answer to a PRIVMSG or NOTICE, and 'No such nick/channel' in answer to anything else.",
-      "minItems": 1,
+      "description": "No such nick/channel",
       "maxItems": 1
     }
   },
   "required": [
     "command",
-    "code",
-    "from",
     "to",
-    "params",
-    "body"
+    "params"
   ],
   "examples": [
     {
-      "command": "ERR_NOSUCHNICK",
-      "code": 401,
-      "from": "neoirc",
+      "command": "401",
       "to": "alice",
       "params": [
         "bob"
       ],
       "body": [
-        "No such nick"
+        "No such nick/channel"
       ]
     }
   ]

schema/numerics/403.json

@@ -2,55 +2,39 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/numerics/403.json",
   "title": "403 ERR_NOSUCHCHANNEL",
-  "description": "No channel has that name. A JOIN with a channel name that the server does not allow gets it too. RFC 1459 §6.1.",
+  "description": "No such channel. RFC 1459 \u00a76.1.",
   "$ref": "../message.json",
   "properties": {
     "command": {
-      "const": "ERR_NOSUCHCHANNEL"
-    },
-    "code": {
-      "const": 403
-    },
-    "from": {
-      "type": "string",
-      "description": "The server name."
+      "const": "403"
     },
     "to": {
-      "type": "string",
-      "description": "The user's nick."
+      "type": "string"
     },
     "params": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "The channel name.",
-      "minItems": 1,
-      "maxItems": 1
+      "description": "[channel_name]."
     },
     "body": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "One string: 'No such channel'.",
-      "minItems": 1,
+      "description": "No such channel",
       "maxItems": 1
     }
   },
   "required": [
     "command",
-    "code",
-    "from",
     "to",
-    "params",
-    "body"
+    "params"
   ],
   "examples": [
     {
-      "command": "ERR_NOSUCHCHANNEL",
-      "code": 403,
-      "from": "neoirc",
+      "command": "403",
       "to": "alice",
       "params": [
         "#nonexistent"

schema/numerics/433.json

@@ -2,58 +2,42 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/numerics/433.json",
   "title": "433 ERR_NICKNAMEINUSE",
-  "description": "Another user has the nick. Sent in answer to a NICK. RFC 1459 §6.1.",
+  "description": "Nickname is already in use. RFC 1459 \u00a76.1.",
   "$ref": "../message.json",
   "properties": {
     "command": {
-      "const": "ERR_NICKNAMEINUSE"
-    },
-    "code": {
-      "const": 433
-    },
-    "from": {
-      "type": "string",
-      "description": "The server name."
+      "const": "433"
     },
     "to": {
-      "type": "string",
-      "description": "The user's nick, which has not changed."
+      "type": "string"
     },
     "params": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "The nick that was asked for.",
-      "minItems": 1,
-      "maxItems": 1
+      "description": "[requested_nick]."
     },
     "body": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "One string: 'Nickname is already in use'.",
-      "minItems": 1,
+      "description": "Nickname is already in use",
       "maxItems": 1
     }
   },
   "required": [
     "command",
-    "code",
-    "from",
     "to",
-    "params",
-    "body"
+    "params"
   ],
   "examples": [
     {
-      "command": "ERR_NICKNAMEINUSE",
-      "code": 433,
-      "from": "neoirc",
-      "to": "alice",
+      "command": "433",
+      "to": "*",
       "params": [
-        "bob"
+        "alice"
       ],
       "body": [
         "Nickname is already in use"

schema/numerics/442.json

@@ -2,62 +2,34 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/numerics/442.json",
   "title": "442 ERR_NOTONCHANNEL",
-  "description": "The user is not on that channel. RFC 1459 §6.1.",
+  "description": "You're not on that channel. RFC 1459 \u00a76.1.",
   "$ref": "../message.json",
   "properties": {
     "command": {
-      "const": "ERR_NOTONCHANNEL"
-    },
-    "code": {
-      "const": 442
-    },
-    "from": {
-      "type": "string",
-      "description": "The server name."
+      "const": "442"
     },
     "to": {
-      "type": "string",
-      "description": "The user's nick."
+      "type": "string"
     },
     "params": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "The channel name.",
-      "minItems": 1,
-      "maxItems": 1
+      "description": "[channel]."
     },
     "body": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "One string: 'You're not on that channel'.",
-      "minItems": 1,
+      "description": "You're not on that channel",
       "maxItems": 1
     }
   },
   "required": [
     "command",
-    "code",
-    "from",
     "to",
-    "params",
-    "body"
-  ],
-  "examples": [
-    {
-      "command": "ERR_NOTONCHANNEL",
-      "code": 442,
-      "from": "neoirc",
-      "to": "alice",
-      "params": [
-        "#general"
-      ],
-      "body": [
-        "You're not on that channel"
-      ]
-    }
+    "params"
   ]
 }

schema/numerics/482.json

@@ -2,62 +2,34 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://sneak.berlin/go/neoirc/schema/numerics/482.json",
   "title": "482 ERR_CHANOPRIVSNEEDED",
-  "description": "The user is not a channel operator, and the command needs one. RFC 1459 §6.1.",
+  "description": "You're not channel operator. RFC 1459 \u00a76.1.",
   "$ref": "../message.json",
   "properties": {
     "command": {
-      "const": "ERR_CHANOPRIVSNEEDED"
-    },
-    "code": {
-      "const": 482
-    },
-    "from": {
-      "type": "string",
-      "description": "The server name."
+      "const": "482"
     },
     "to": {
-      "type": "string",
-      "description": "The user's nick."
+      "type": "string"
     },
     "params": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "The channel name.",
-      "minItems": 1,
-      "maxItems": 1
+      "description": "[channel]."
     },
     "body": {
       "type": "array",
       "items": {
         "type": "string"
       },
-      "description": "One string: 'You're not channel operator'.",
-      "minItems": 1,
+      "description": "You're not channel operator",
       "maxItems": 1
     }
   },
   "required": [
     "command",
-    "code",
-    "from",
     "to",
-    "params",
-    "body"
-  ],
-  "examples": [
-    {
-      "command": "ERR_CHANOPRIVSNEEDED",
-      "code": 482,
-      "from": "neoirc",
-      "to": "alice",
-      "params": [
-        "#general"
-      ],
-      "body": [
-        "You're not channel operator"
-      ]
-    }
+    "params"
   ]
 }

web/src/app.jsx

@@ -7,11 +7,6 @@ const RECONNECT_DELAY = 3000;
 const MEMBER_REFRESH_INTERVAL = 10000;
 const ACTION_PREFIX = "\x01ACTION ";
 const ACTION_SUFFIX = "\x01";
-// SERVER_TAB is the Server tab's name, under which its messages and
-// unread count are stored. No nick or channel name can contain *, so a
-// user with the nick Server gets a direct-message tab of its own. The
-// tab bar labels this tab Server.
-const SERVER_TAB = "*server*";
 
 // Hashcash proof-of-work helpers using Web Crypto API.
 
@@ -63,13 +58,13 @@ async function mintHashcash(bits, resource) {
   }
 }
 
-// Requests are authenticated by the auth cookie, which the browser
-// sends on its own.
 function api(path, opts = {}) {
+  const token = localStorage.getItem("neoirc_token");
   const headers = {
     "Content-Type": "application/json",
     ...(opts.headers || {}),
   };
+  if (token) headers["Authorization"] = `Bearer ${token}`;
   const { signal, ...rest } = opts;
 
   return fetch(API + path, { ...rest, headers, signal }).then(async (r) => {
@@ -127,11 +122,12 @@ function LoginScreen({ onLogin }) {
         if (s.name) hashcashResourceRef.current = s.name;
       })
       .catch(() => {});
-    // Resume the session if the browser still holds a valid auth
-    // cookie; a 401 leaves the login form up.
-    api("/state?initChannelState=1")
-      .then((u) => onLogin(u.nick, true))
-      .catch(() => {});
+    const saved = localStorage.getItem("neoirc_token");
+    if (saved) {
+      api("/state?initChannelState=1")
+        .then((u) => onLogin(u.nick, true))
+        .catch(() => localStorage.removeItem("neoirc_token"));
+    }
     inputRef.current?.focus();
   }, []);
 
@@ -156,6 +152,7 @@ function LoginScreen({ onLogin }) {
         method: "POST",
         body: JSON.stringify(reqBody),
       });
+      localStorage.setItem("neoirc_token", res.token);
       onLogin(res.nick);
     } catch (err) {
       setError(err.data?.error || "Connection failed");
@@ -230,9 +227,10 @@ function UserList({ members, onNickClick }) {
   const regular = [];
 
   for (const m of members) {
-    if (m.isOperator) {
+    const mode = m.mode || "";
+    if (mode === "o") {
       ops.push(m);
-    } else if (m.isVoiced) {
+    } else if (mode === "v") {
       voiced.push(m);
     } else {
       regular.push(m);
@@ -275,9 +273,9 @@ function UserList({ members, onNickClick }) {
 function App() {
   const [loggedIn, setLoggedIn] = useState(false);
   const [nick, setNick] = useState("");
-  const [tabs, setTabs] = useState([{ type: "server", name: SERVER_TAB }]);
+  const [tabs, setTabs] = useState([{ type: "server", name: "Server" }]);
   const [activeTab, setActiveTab] = useState(0);
-  const [messages, setMessages] = useState({ [SERVER_TAB]: [] });
+  const [messages, setMessages] = useState({ Server: [] });
   const [members, setMembers] = useState({});
   const [topics, setTopics] = useState({});
   const [unread, setUnread] = useState({});
@@ -305,14 +303,11 @@ function App() {
     nickRef.current = nick;
   }, [nick]);
 
-  // Persist joined channels, once logged in: before then only the
-  // Server tab exists, and writing would erase the saved channels
-  // that onLogin rejoins.
+  // Persist joined channels.
   useEffect(() => {
-    if (!loggedIn) return;
     const channels = tabs.filter((t) => t.type === "channel").map((t) => t.name);
     localStorage.setItem("neoirc_channels", JSON.stringify(channels));
-  }, [loggedIn, tabs]);
+  }, [tabs]);
 
   // Clear unread on tab switch.
   useEffect(() => {
@@ -360,26 +355,6 @@ function App() {
       .catch(() => {});
   }, []);
 
-  // removeChannelTab closes a channel's tab. The tab the user was
-  // reading stays active, found by its name; when it was the closed tab,
-  // the Server tab shows.
-  const removeChannelTab = useCallback((name) => {
-    setTabs((prev) => {
-      const remaining = prev.filter(
-        (t) => !(t.type === "channel" && t.name === name),
-      );
-      // Preact runs this update at once, on the newest active tab.
-      setActiveTab((active) => {
-        const reading = prev[active]?.name;
-        const idx = remaining.findIndex((t) => t.name === reading);
-
-        return idx >= 0 ? idx : 0;
-      });
-
-      return remaining;
-    });
-  }, []);
-
   const processMessage = useCallback(
     (msg) => {
       const body = Array.isArray(msg.body) ? msg.body.join("\n") : "";
@@ -391,9 +366,7 @@ function App() {
         command: msg.command,
       };
 
-      // A numeric reply carries its number in `code` and its name in
-      // `command`; other messages have no `code`.
-      switch (msg.code || msg.command) {
+      switch (msg.command) {
         case "PRIVMSG":
         case "NOTICE": {
           let text = body;
@@ -449,13 +422,6 @@ function App() {
           break;
         }
         case "PART": {
-          // The user's own PART, sent from this client or another,
-          // closes the tab and adds no message or unread count.
-          if (msg.from === nickRef.current) {
-            removeChannelTab(msg.to);
-
-            break;
-          }
           const reason = body ? " (" + body + ")" : "";
           const text = `${msg.from} has parted ${msg.to}${reason}`;
           if (msg.to) addMessage(msg.to, { ...base, text, system: true });
@@ -463,29 +429,6 @@ function App() {
 
           break;
         }
-        case "KICK": {
-          // The kicked nick is in params; the body is the reason.
-          const kicked = Array.isArray(msg.params) ? msg.params[0] : "";
-          const reason = body ? " (" + body + ")" : "";
-          const text = `${kicked} was kicked from ${msg.to} by ${msg.from}${reason}`;
-          if (msg.to) addMessage(msg.to, { ...base, text, system: true });
-          if (kicked === nickRef.current) {
-            // The channel's tab closes, so the Server tab gets the line
-            // too. It needs an id of its own: addMessage drops a message
-            // whose id it has already seen.
-            addMessage(SERVER_TAB, {
-              ...base,
-              id: msg.id + "-server",
-              text,
-              system: true,
-            });
-            removeChannelTab(msg.to);
-          } else if (msg.to && msg.to.startsWith("#")) {
-            refreshMembers(msg.to);
-          }
-
-          break;
-        }
         case "QUIT": {
           const reason = body ? " (" + body + ")" : "";
           const text = `${msg.from} has quit${reason}`;
@@ -521,18 +464,8 @@ function App() {
 
           break;
         }
-        case "MODE": {
-          // The body is the change, with its value where it has one:
-          // ["+o bob"], ["+m"], ["+k", "secretpass"].
-          const modes = Array.isArray(msg.body) ? msg.body.join(" ") : "";
-          const text = `${msg.from} sets mode ${modes} on ${msg.to}`;
-          if (msg.to) addMessage(msg.to, { ...base, text, system: true });
-
-          break;
-        }
-        case 353: {
-          // RPL_NAMREPLY — each name is a hostmask (nick!user@host),
-          // prefixed with @ for an operator or + for a voiced member.
+        case "353": {
+          // RPL_NAMREPLY — parse mode prefixes from names list.
           if (
             Array.isArray(msg.params) &&
             msg.params.length >= 2 &&
@@ -544,18 +477,21 @@ function App() {
               : String(msg.body);
             const names = namesStr.split(/\s+/).filter(Boolean);
             const parsed = names.map((n) => {
-              const isOperator = n.startsWith("@");
-              const isVoiced = n.startsWith("+");
-              const hostmask = isOperator || isVoiced ? n.slice(1) : n;
+              if (n.startsWith("@")) {
+                return { nick: n.slice(1), mode: "o" };
+              }
+              if (n.startsWith("+")) {
+                return { nick: n.slice(1), mode: "v" };
+              }
 
-              return { nick: hostmask.split("!")[0], isOperator, isVoiced };
+              return { nick: n, mode: "" };
             });
             setMembers((prev) => ({ ...prev, [channel]: parsed }));
           }
 
           break;
         }
-        case 332: {
+        case "332": {
           // RPL_TOPIC — set topic from server.
           if (Array.isArray(msg.params) && msg.params.length >= 1) {
             const channel = msg.params[0];
@@ -567,13 +503,13 @@ function App() {
 
           break;
         }
-        case 322: {
+        case "322": {
           // RPL_LIST — channel, member count, topic.
           if (Array.isArray(msg.params) && msg.params.length >= 2) {
             const chName = msg.params[0];
             const count = msg.params[1];
             const chTopic = body || "";
-            addMessage(SERVER_TAB, {
+            addMessage("Server", {
               ...base,
               text: `${chName} (${count} users): ${chTopic.trim()}`,
               system: true,
@@ -582,21 +518,21 @@ function App() {
 
           break;
         }
-        case 323:
-          addMessage(SERVER_TAB, {
+        case "323":
+          addMessage("Server", {
             ...base,
             text: body || "End of channel list",
             system: true,
           });
 
           break;
-        case 352: {
+        case "352": {
           // RPL_WHOREPLY — channel, user, host, server, nick, flags.
           if (Array.isArray(msg.params) && msg.params.length >= 5) {
             const whoCh = msg.params[0];
             const whoNick = msg.params[4];
             const whoFlags = msg.params.length > 5 ? msg.params[5] : "";
-            addMessage(SERVER_TAB, {
+            addMessage("Server", {
               ...base,
               text: `${whoCh} ${whoNick} ${whoFlags}`,
               system: true,
@@ -605,33 +541,33 @@ function App() {
 
           break;
         }
-        case 315:
-          addMessage(SERVER_TAB, {
+        case "315":
+          addMessage("Server", {
             ...base,
             text: body || "End of /WHO list",
             system: true,
           });
 
           break;
-        case 311: {
-          // RPL_WHOISUSER — params nick, user, host, *; body realname.
-          if (Array.isArray(msg.params) && msg.params.length >= 3) {
-            const [wiNick, wiUser, wiHost] = msg.params;
-            addMessage(SERVER_TAB, {
+        case "311": {
+          // RPL_WHOISUSER — nick, user, host, *, realname.
+          if (Array.isArray(msg.params) && msg.params.length >= 1) {
+            const wiNick = msg.params[0];
+            addMessage("Server", {
               ...base,
-              text: `${wiNick} is ${wiUser}@${wiHost} (${body})`,
+              text: `${wiNick} (${body})`,
               system: true,
             });
           }
 
           break;
         }
-        case 312: {
+        case "312": {
           // RPL_WHOISSERVER — nick, server, server info.
           if (Array.isArray(msg.params) && msg.params.length >= 2) {
             const wiNick = msg.params[0];
             const wiServer = msg.params[1];
-            addMessage(SERVER_TAB, {
+            addMessage("Server", {
               ...base,
               text: `${wiNick} on ${wiServer}`,
               system: true,
@@ -640,37 +576,11 @@ function App() {
 
           break;
         }
-        case 313: {
-          // RPL_WHOISOPERATOR — nick; body "is an IRC operator".
-          if (Array.isArray(msg.params) && msg.params.length >= 1) {
-            addMessage(SERVER_TAB, {
-              ...base,
-              text: `${msg.params[0]} ${body}`,
-              system: true,
-            });
-          }
-
-          break;
-        }
-        case 317: {
-          // RPL_WHOISIDLE — nick, idle seconds, signon time (Unix).
-          if (Array.isArray(msg.params) && msg.params.length >= 3) {
-            const [wiNick, idle, signon] = msg.params;
-            const signedOn = new Date(Number(signon) * 1000).toLocaleString();
-            addMessage(SERVER_TAB, {
-              ...base,
-              text: `${wiNick} has been idle ${idle}s, signed on ${signedOn}`,
-              system: true,
-            });
-          }
-
-          break;
-        }
-        case 319: {
+        case "319": {
           // RPL_WHOISCHANNELS — nick, channels.
           if (Array.isArray(msg.params) && msg.params.length >= 1) {
             const wiNick = msg.params[0];
-            addMessage(SERVER_TAB, {
+            addMessage("Server", {
               ...base,
               text: `${wiNick} is on: ${body}`,
               system: true,
@@ -679,39 +589,27 @@ function App() {
 
           break;
         }
-        case 318:
-          addMessage(SERVER_TAB, {
+        case "318":
+          addMessage("Server", {
             ...base,
             text: body || "End of /WHOIS list",
             system: true,
           });
 
           break;
-        case 324: {
-          // RPL_CHANNELMODEIS — channel, mode string.
-          if (Array.isArray(msg.params) && msg.params.length >= 2) {
-            addMessage(SERVER_TAB, {
-              ...base,
-              text: `${msg.params[0]} modes: ${msg.params[1]}`,
-              system: true,
-            });
-          }
-
-          break;
-        }
-        case 375:
-        case 372:
-        case 376:
-          addMessage(SERVER_TAB, { ...base, text: body, system: true });
+        case "375":
+        case "372":
+        case "376":
+          addMessage("Server", { ...base, text: body, system: true });
 
           break;
         default:
           if (body) {
-            addMessage(SERVER_TAB, { ...base, text: body, system: true });
+            addMessage("Server", { ...base, text: body, system: true });
           }
       }
     },
-    [addMessage, refreshMembers, removeChannelTab],
+    [addMessage, refreshMembers],
   );
 
   // Long-poll loop.
@@ -739,14 +637,6 @@ function App() {
         } catch (err) {
           if (!alive) break;
           if (err.name === "AbortError") continue;
-          // 401: the session is gone (QUIT from another client, or
-          // expiry). Reloading drops this page's state and brings
-          // back the login screen.
-          if (err.status === 401) {
-            window.location.reload();
-
-            return;
-          }
           setConnected(false);
           await new Promise((r) => setTimeout(r, RECONNECT_DELAY));
         }
@@ -826,14 +716,9 @@ function App() {
 
   const onLogin = useCallback(
     async (userNick, isResumed) => {
-      // Read before setLoggedIn(true): from then on the effect under
-      // "Persist joined channels" writes the open channel tabs over it.
-      const saved = JSON.parse(
-        localStorage.getItem("neoirc_channels") || "[]",
-      );
       setNick(userNick);
       setLoggedIn(true);
-      addSystemMessage(SERVER_TAB, `Connected as ${userNick}`);
+      addSystemMessage("Server", `Connected as ${userNick}`);
 
       if (isResumed) {
         // Request MOTD on resumed sessions (new sessions
@@ -855,13 +740,15 @@ function App() {
       }
 
       // Fresh session — join any previously saved channels.
+      const saved = JSON.parse(
+        localStorage.getItem("neoirc_channels") || "[]",
+      );
       for (const ch of saved) {
         try {
-          const res = await api("/messages", {
+          await api("/messages", {
             method: "POST",
             body: JSON.stringify({ command: "JOIN", to: ch }),
           });
-          if (res?.status !== "joined") continue;
           setTabs((prev) => {
             if (prev.find((t) => t.type === "channel" && t.name === ch))
               return prev;
@@ -881,30 +768,18 @@ function App() {
     name = name.trim();
     if (!name.startsWith("#")) name = "#" + name;
     try {
-      const res = await api("/messages", {
+      await api("/messages", {
         method: "POST",
         body: JSON.stringify({ command: "JOIN", to: name }),
       });
-      // A refused join opens no tab. The error numeric that the
-      // server sends to the message queue tells the user why.
-      if (res?.status !== "joined") return;
-      // Show the channel's tab. Preact runs this update at once on the
-      // newest tab list, so the tab is found there by name: the user's
-      // own JOIN event may already have added it, and other tabs may
-      // have closed.
       setTabs((prev) => {
-        const idx = prev.findIndex(
-          (t) => t.type === "channel" && t.name === name,
-        );
-        if (idx >= 0) {
-          setActiveTab(idx);
-
+        if (prev.find((t) => t.type === "channel" && t.name === name))
           return prev;
-        }
-        setActiveTab(prev.length);
 
         return [...prev, { type: "channel", name }];
       });
+      const newIdx = tabsRef.current.length;
+      setActiveTab(newIdx);
       try {
         const hist = await api(
           `/history?target=${encodeURIComponent(name)}&limit=50`,
@@ -917,7 +792,7 @@ function App() {
       }
     } catch (err) {
       addSystemMessage(
-        SERVER_TAB,
+        "Server",
         `Failed to join ${name}: ${err.data?.error || "error"}`,
       );
     }
@@ -933,7 +808,10 @@ function App() {
     } catch (e) {
       // Ignore.
     }
-    removeChannelTab(name);
+    setTabs((prev) =>
+      prev.filter((t) => !(t.type === "channel" && t.name === name)),
+    );
+    setActiveTab(0);
   };
 
   const closeTab = (idx) => {
@@ -948,23 +826,16 @@ function App() {
 
   const openDM = (targetNick) => {
     if (targetNick === nickRef.current) return;
-    // Show the direct-message tab. Preact runs this update at once on
-    // the newest tab list, so the tab is found there by name: the
-    // server's copy of the user's message may already have added it,
-    // and other tabs may have opened or closed.
     setTabs((prev) => {
-      const idx = prev.findIndex(
-        (t) => t.type === "dm" && t.name === targetNick,
-      );
-      if (idx >= 0) {
-        setActiveTab(idx);
-
+      if (prev.find((t) => t.type === "dm" && t.name === targetNick))
         return prev;
-      }
-      setActiveTab(prev.length);
 
       return [...prev, { type: "dm", name: targetNick }];
     });
+    const idx = tabs.findIndex(
+      (t) => t.type === "dm" && t.name === targetNick,
+    );
+    setActiveTab(idx >= 0 ? idx : tabs.length);
   };
 
   const handleCommand = async (text) => {
@@ -975,7 +846,7 @@ function App() {
     switch (cmd) {
       case "/join": {
         if (parts[1]) joinChannel(parts[1]);
-        else addSystemMessage(SERVER_TAB, "Usage: /join #channel");
+        else addSystemMessage("Server", "Usage: /join #channel");
 
         break;
       }
@@ -984,7 +855,7 @@ function App() {
           const reason = parts.slice(1).join(" ") || undefined;
           partChannel(tab.name, reason);
         } else {
-          addSystemMessage(SERVER_TAB, "You are not in a channel");
+          addSystemMessage("Server", "You are not in a channel");
         }
 
         break;
@@ -1005,19 +876,19 @@ function App() {
             openDM(target);
           } catch (err) {
             addSystemMessage(
-              SERVER_TAB,
+              "Server",
               `Message failed: ${err.data?.error || "error"}`,
             );
           }
         } else {
-          addSystemMessage(SERVER_TAB, "Usage: /msg <nick> <message>");
+          addSystemMessage("Server", "Usage: /msg <nick> <message>");
         }
 
         break;
       }
       case "/me": {
         if (tab.type === "server") {
-          addSystemMessage(SERVER_TAB, "Cannot use /me in server window");
+          addSystemMessage("Server", "Cannot use /me in server window");
 
           break;
         }
@@ -1039,7 +910,7 @@ function App() {
             );
           }
         } else {
-          addSystemMessage(SERVER_TAB, "Usage: /me <action>");
+          addSystemMessage("Server", "Usage: /me <action>");
         }
 
         break;
@@ -1053,19 +924,19 @@ function App() {
             });
           } catch (err) {
             addSystemMessage(
-              SERVER_TAB,
+              "Server",
               `Nick change failed: ${err.data?.error || "error"}`,
             );
           }
         } else {
-          addSystemMessage(SERVER_TAB, "Usage: /nick <newnick>");
+          addSystemMessage("Server", "Usage: /nick <newnick>");
         }
 
         break;
       }
       case "/topic": {
         if (tab.type !== "channel") {
-          addSystemMessage(SERVER_TAB, "You are not in a channel");
+          addSystemMessage("Server", "You are not in a channel");
 
           break;
         }
@@ -1082,13 +953,13 @@ function App() {
             });
           } catch (err) {
             addSystemMessage(
-              SERVER_TAB,
+              "Server",
               `Topic change failed: ${err.data?.error || "error"}`,
             );
           }
         } else {
           addSystemMessage(
-            SERVER_TAB,
+            "Server",
             `Current topic for ${tab.name}: ${topics[tab.name] || "(none)"}`,
           );
         }
@@ -1097,26 +968,31 @@ function App() {
       }
       case "/mode": {
         if (tab.type !== "channel") {
-          addSystemMessage(SERVER_TAB, "You are not in a channel");
+          addSystemMessage("Server", "You are not in a channel");
 
           break;
         }
-        // With no arguments MODE is a query. A change is one sign and
-        // letter, then its value where it takes one: +m, +o nick.
         const modeArgs = parts.slice(1);
-        const body =
-          modeArgs.length > 0
-            ? { command: "MODE", to: tab.name, body: modeArgs }
-            : { command: "MODE", to: tab.name };
-        try {
-          await api("/messages", {
-            method: "POST",
-            body: JSON.stringify(body),
-          });
-        } catch (err) {
+        if (modeArgs.length > 0) {
+          try {
+            await api("/messages", {
+              method: "POST",
+              body: JSON.stringify({
+                command: "MODE",
+                to: tab.name,
+                params: modeArgs,
+              }),
+            });
+          } catch (err) {
+            addSystemMessage(
+              "Server",
+              `Mode change failed: ${err.data?.error || "error"}`,
+            );
+          }
+        } else {
           addSystemMessage(
-            SERVER_TAB,
-            `MODE failed: ${err.data?.error || "error"}`,
+            "Server",
+            "Usage: /mode <+/-mode> [params]",
           );
         }
 
@@ -1133,6 +1009,7 @@ function App() {
         } catch (e) {
           // Ignore.
         }
+        localStorage.removeItem("neoirc_token");
         localStorage.removeItem("neoirc_channels");
         window.location.reload();
 
@@ -1146,7 +1023,7 @@ function App() {
           });
         } catch (err) {
           addSystemMessage(
-            SERVER_TAB,
+            "Server",
             `Failed to request MOTD: ${err.data?.error || "error"}`,
           );
         }
@@ -1170,13 +1047,13 @@ function App() {
               });
             } catch (err) {
               addSystemMessage(
-                SERVER_TAB,
+                "Server",
                 `Message failed: ${err.data?.error || "error"}`,
               );
             }
           }
         } else {
-          addSystemMessage(SERVER_TAB, "Usage: /query <nick> [message]");
+          addSystemMessage("Server", "Usage: /query <nick> [message]");
         }
 
         break;
@@ -1189,7 +1066,7 @@ function App() {
           });
         } catch (err) {
           addSystemMessage(
-            SERVER_TAB,
+            "Server",
             `Failed to list channels: ${err.data?.error || "error"}`,
           );
         }
@@ -1206,12 +1083,12 @@ function App() {
             });
           } catch (err) {
             addSystemMessage(
-              SERVER_TAB,
+              "Server",
               `WHO failed: ${err.data?.error || "error"}`,
             );
           }
         } else {
-          addSystemMessage(SERVER_TAB, "Usage: /who #channel");
+          addSystemMessage("Server", "Usage: /who #channel");
         }
 
         break;
@@ -1225,12 +1102,12 @@ function App() {
             });
           } catch (err) {
             addSystemMessage(
-              SERVER_TAB,
+              "Server",
               `WHOIS failed: ${err.data?.error || "error"}`,
             );
           }
         } else {
-          addSystemMessage(SERVER_TAB, "Usage: /whois <nick>");
+          addSystemMessage("Server", "Usage: /whois <nick>");
         }
 
         break;
@@ -1251,7 +1128,7 @@ function App() {
           "  /me action            — Send an action",
           "  /nick newnick         — Change your nickname",
           "  /topic [text]         — View or set channel topic",
-          "  /mode [+/-flag [arg]] — View or set channel modes",
+          "  /mode +/-flags        — Set channel modes",
           "  /motd                 — Display the message of the day",
           "  /list                 — List all channels",
           "  /who [#channel]       — List users in a channel",
@@ -1261,13 +1138,13 @@ function App() {
           "  /help                 — Show this help",
         ];
         for (const line of helpLines) {
-          addSystemMessage(SERVER_TAB, line);
+          addSystemMessage("Server", line);
         }
 
         break;
       }
       default:
-        addSystemMessage(SERVER_TAB, `Unknown command: ${cmd}`);
+        addSystemMessage("Server", `Unknown command: ${cmd}`);
     }
   };
 
@@ -1296,7 +1173,7 @@ function App() {
 
     if (tab.type === "server") {
       addSystemMessage(
-        SERVER_TAB,
+        "Server",
         "Cannot send messages to the server window. Use /join #channel first.",
       );
 
@@ -1367,7 +1244,7 @@ function App() {
               key={tab.name}
             >
               <span class="tab-label">
-                {tab.type === "server" ? "Server" : tab.name}
+                {tab.type === "dm" ? tab.name : tab.name}
               </span>
               {unread[tab.name] > 0 && i !== activeTab && (
                 <span class="unread-count">({unread[tab.name]})</span>