Merge pull request 'dockerfile: use CGO_ENABLED=0 for binary builds (closes #13)' (#21) from fix/cgo-disabled into main

Reviewed-on: #21

.editorconfig

@@ -0,0 +1,12 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[Makefile]
+indent_style = tab

.gitea/workflows/check.yml

@@ -0,0 +1,9 @@
+name: check
+on: [push]
+jobs:
+    check:
+        runs-on: ubuntu-latest
+        steps:
+            # actions/checkout v4.2.2, 2026-02-22
+            - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+            - run: docker build .

.gitignore

@@ -1,7 +1,28 @@
+# OS
+.DS_Store
+Thumbs.db
+
+# Editors
+*.swp
+*.swo
+*~
+*.bak
+.idea/
+.vscode/
+*.sublime-*
+
+# Node
+node_modules/
+
+# Environment / secrets
+.env
+.env.*
+*.pem
+*.key
+
+# Build artifacts
 /chatd
 /bin/
-data.db
-.env
 *.exe
 *.dll
 *.so
@@ -9,6 +30,9 @@ data.db
 *.test
 *.out
 vendor/
+
+# Project
+data.db
 debug.log
+/chat-cli
 web/node_modules/
-chat-cli

.golangci.yml

@@ -7,24 +7,7 @@ run:
 linters:
   default: all
   disable:
-    - exhaustruct
-    - depguard
-    - godot
-    - wsl
-    - wsl_v5
-    - wrapcheck
-    - varnamelen
-    - noinlineerr
-    - dupl
-    - paralleltest
-    - nlreturn
-    - tagliatelle
-    - goconst
-    - funlen
-    - maintidx
-    - cyclop
-    - gocognit
-    - lll
+    - wsl  # Deprecated in v2, replaced by wsl_v5
   settings:
     lll:
       line-length: 88
@@ -35,7 +18,19 @@ linters:
       max-complexity: 15
     dupl:
       threshold: 100
+    gosec:
+      excludes:
+        - G704
+    depguard:
+      rules:
+        all:
+          deny:
+            - pkg: "io/ioutil"
+              desc: "Deprecated; use io and os packages."
+            - pkg: "math/rand$"
+              desc: "Use crypto/rand for security-sensitive code."
 
 issues:
+  exclude-use-default: false
   max-issues-per-linter: 0
   max-same-issues: 0

Dockerfile

@@ -1,23 +1,26 @@
-# Build stage
-FROM golang:1.24-alpine AS builder
+# golang:1.24-alpine, 2026-02-26
+FROM golang@sha256:8bee1901f1e530bfb4a7850aa7a479d17ae3a18beb6e09064ed54cfd245b7191 AS builder
 WORKDIR /src
-RUN apk add --no-cache make gcc musl-dev
+RUN apk add --no-cache git build-base make
+
+# golangci-lint v2.1.6 (eabc2638a66d), 2026-02-26
+RUN CGO_ENABLED=0 go install github.com/golangci/golangci-lint/v2/cmd/golangci-lint@eabc2638a66daf5bb6c6fb052a32fa3ef7b6600d
 
 COPY go.mod go.sum ./
 RUN go mod download
 
 COPY . .
 
-# Run tests
-ENV DBURL="file::memory:?cache=shared"
-RUN go test ./...
+# Run all checks — build fails if branch is not green
+RUN make check
 
-# Build binaries
-RUN CGO_ENABLED=1 go build -trimpath -ldflags="-s -w" -o /chatd ./cmd/chatd/
-RUN CGO_ENABLED=1 go build -trimpath -ldflags="-s -w" -o /chat-cli ./cmd/chat-cli/
+# Build static binaries (no cgo needed at runtime — modernc.org/sqlite is pure Go)
+ARG VERSION=dev
+RUN CGO_ENABLED=0 go build -trimpath -ldflags="-s -w -X main.Version=${VERSION}" -o /chatd ./cmd/chatd/
+RUN CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /chat-cli ./cmd/chat-cli/
 
-# Final stage — server only
-FROM alpine:3.21
+# alpine:3.21, 2026-02-26
+FROM alpine@sha256:c3f8e73fdb79deaebaa2037150150191b9dcbfba68b4a46d70103204c53f4709
 RUN apk add --no-cache ca-certificates \
     && addgroup -S chat && adduser -S chat -G chat
 COPY --from=builder /chatd /usr/local/bin/chatd

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 sneak
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Makefile

@@ -1,20 +1,49 @@
-VERSION := $(shell git describe --tags --always --dirty 2>/dev/null || echo "dev")
-LDFLAGS := -ldflags "-X main.Version=$(VERSION)"
+.PHONY: all build lint fmt fmt-check test check clean run debug docker hooks
 
-.PHONY: build test clean docker lint
+BINARY := chatd
+VERSION := $(shell git describe --tags --always --dirty 2>/dev/null || echo "dev")
+BUILDARCH := $(shell go env GOARCH)
+LDFLAGS := -X main.Version=$(VERSION) -X main.Buildarch=$(BUILDARCH)
+
+all: check build
 
 build:
-	go build $(LDFLAGS) -o chatd ./cmd/chatd/
-	go build $(LDFLAGS) -o chat-cli ./cmd/chat-cli/
-
-test:
-	DBURL="file::memory:?cache=shared" go test ./...
-
-clean:
-	rm -f chatd chat-cli
+	go build -ldflags "$(LDFLAGS)" -o bin/$(BINARY) ./cmd/chatd
 
 lint:
-	GOFLAGS=-buildvcs=false golangci-lint run ./...
+	golangci-lint run --config .golangci.yml ./...
+
+fmt:
+	gofmt -s -w .
+	goimports -w .
+
+fmt-check:
+	@test -z "$$(gofmt -l .)" || (echo "Files not formatted:" && gofmt -l . && exit 1)
+
+test:
+	go test -timeout 30s -v -race -cover ./...
+
+# check runs all validation without making changes
+# Used by CI and Docker build — fails if anything is wrong
+check: test lint fmt-check
+	@echo "==> Building..."
+	go build -ldflags "$(LDFLAGS)" -o /dev/null ./cmd/chatd
+	@echo "==> All checks passed!"
+
+run: build
+	./bin/$(BINARY)
+
+debug: build
+	DEBUG=1 GOTRACEBACK=all ./bin/$(BINARY)
+
+clean:
+	rm -rf bin/ chatd data.db
 
 docker:
-	docker build -t chat:$(VERSION) .
+	docker build -t chat .
+
+hooks:
+	@printf '#!/bin/sh\nset -e\n' > .git/hooks/pre-commit
+	@printf 'go mod tidy\ngo fmt ./...\ngit diff --exit-code -- go.mod go.sum || { echo "go mod tidy changed files; please stage and retry"; exit 1; }\n' >> .git/hooks/pre-commit
+	@printf 'make check\n' >> .git/hooks/pre-commit
+	@chmod +x .git/hooks/pre-commit

README.md

@@ -2199,3 +2199,8 @@ See [Roadmap](#roadmap) for what's next.
 ## License
 
 MIT
+
+## Author
+
+[@sneak](https://sneak.berlin)
+

REPO_POLICIES.md

@@ -0,0 +1,182 @@
+---
+title: Repository Policies
+last_modified: 2026-02-22
+---
+
+This document covers repository structure, tooling, and workflow standards. Code
+style conventions are in separate documents:
+
+- [Code Styleguide](https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/CODE_STYLEGUIDE.md)
+  (general, bash, Docker)
+- [Go](https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/CODE_STYLEGUIDE_GO.md)
+- [JavaScript](https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/CODE_STYLEGUIDE_JS.md)
+- [Python](https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/CODE_STYLEGUIDE_PYTHON.md)
+- [Go HTTP Server Conventions](https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/GO_HTTP_SERVER_CONVENTIONS.md)
+
+---
+
+- Cross-project documentation (such as this file) must include
+  `last_modified: YYYY-MM-DD` in the YAML front matter so it can be kept in sync
+  with the authoritative source as policies evolve.
+
+- **ALL external references must be pinned by cryptographic hash.** This
+  includes Docker base images, Go modules, npm packages, GitHub Actions, and
+  anything else fetched from a remote source. Version tags (`@v4`, `@latest`,
+  `:3.21`, etc.) are server-mutable and therefore remote code execution
+  vulnerabilities. The ONLY acceptable way to reference an external dependency
+  is by its content hash (Docker `@sha256:...`, Go module hash in `go.sum`, npm
+  integrity hash in lockfile, GitHub Actions `@<commit-sha>`). No exceptions.
+  This also means never `curl | bash` to install tools like pyenv, nvm, rustup,
+  etc. Instead, download a specific release archive from GitHub, verify its hash
+  (hardcoded in the Dockerfile or script), and only then install. Unverified
+  install scripts are arbitrary remote code execution. This is the single most
+  important rule in this document. Double-check every external reference in
+  every file before committing. There are zero exceptions to this rule.
+
+- Every repo with software must have a root `Makefile` with these targets:
+  `make test`, `make lint`, `make fmt` (writes), `make fmt-check` (read-only),
+  `make check` (prereqs: `test`, `lint`, `fmt-check`), `make docker`, and
+  `make hooks` (installs pre-commit hook). A model Makefile is at
+  `https://git.eeqj.de/sneak/prompts/raw/branch/main/Makefile`.
+
+- Always use Makefile targets (`make fmt`, `make test`, `make lint`, etc.)
+  instead of invoking the underlying tools directly. The Makefile is the single
+  source of truth for how these operations are run.
+
+- The Makefile is authoritative documentation for how the repo is used. Beyond
+  the required targets above, it should have targets for every common operation:
+  running a local development server (`make run`, `make dev`), re-initializing
+  or migrating the database (`make db-reset`, `make migrate`), building
+  artifacts (`make build`), generating code, seeding data, or anything else a
+  developer would do regularly. If someone checks out the repo and types
+  `make<tab>`, they should see every meaningful operation available. A new
+  contributor should be able to understand the entire development workflow by
+  reading the Makefile.
+
+- Every repo should have a `Dockerfile`. All Dockerfiles must run `make check`
+  as a build step so the build fails if the branch is not green. For non-server
+  repos, the Dockerfile should bring up a development environment and run
+  `make check`. For server repos, `make check` should run as an early build
+  stage before the final image is assembled.
+
+- Every repo should have a Gitea Actions workflow (`.gitea/workflows/`) that
+  runs `docker build .` on push. Since the Dockerfile already runs `make check`,
+  a successful build implies all checks pass.
+
+- Use platform-standard formatters: `black` for Python, `prettier` for
+  JS/CSS/Markdown/HTML, `go fmt` for Go. Always use default configuration with
+  two exceptions: four-space indents (except Go), and `proseWrap: always` for
+  Markdown (hard-wrap at 80 columns). Documentation and writing repos (Markdown,
+  HTML, CSS) should also have `.prettierrc` and `.prettierignore`.
+
+- Pre-commit hook: `make check` if local testing is possible, otherwise
+  `make lint && make fmt-check`. The Makefile should provide a `make hooks`
+  target to install the pre-commit hook.
+
+- All repos with software must have tests that run via the platform-standard
+  test framework (`go test`, `pytest`, `jest`/`vitest`, etc.). If no meaningful
+  tests exist yet, add the most minimal test possible — e.g. importing the
+  module under test to verify it compiles/parses. There is no excuse for
+  `make test` to be a no-op.
+
+- `make test` must complete in under 20 seconds. Add a 30-second timeout in the
+  Makefile.
+
+- Docker builds must complete in under 5 minutes.
+
+- `make check` must not modify any files in the repo. Tests may use temporary
+  directories.
+
+- `main` must always pass `make check`, no exceptions.
+
+- Never commit secrets. `.env` files, credentials, API keys, and private keys
+  must be in `.gitignore`. No exceptions.
+
+- `.gitignore` should be comprehensive from the start: OS files (`.DS_Store`),
+  editor files (`.swp`, `*~`), language build artifacts, and `node_modules/`.
+  Fetch the standard `.gitignore` from
+  `https://git.eeqj.de/sneak/prompts/raw/branch/main/.gitignore` when setting up
+  a new repo.
+
+- Never use `git add -A` or `git add .`. Always stage files explicitly by name.
+
+- Never force-push to `main`.
+
+- Make all changes on a feature branch. You can do whatever you want on a
+  feature branch.
+
+- `.golangci.yml` is standardized and must _NEVER_ be modified by an agent, only
+  manually by the user. Fetch from
+  `https://git.eeqj.de/sneak/prompts/raw/branch/main/.golangci.yml`.
+
+- When pinning images or packages by hash, add a comment above the reference
+  with the version and date (YYYY-MM-DD).
+
+- Use `yarn`, not `npm`.
+
+- Write all dates as YYYY-MM-DD (ISO 8601).
+
+- Simple projects should be configured with environment variables.
+
+- Dockerized web services listen on port 8080 by default, overridable with
+  `PORT`.
+
+- `README.md` is the primary documentation. Required sections:
+    - **Description**: First line must include the project name, purpose,
+      category (web server, SPA, CLI tool, etc.), license, and author. Example:
+      "µPaaS is an MIT-licensed Go web application by @sneak that receives
+      git-frontend webhooks and deploys applications via Docker in realtime."
+    - **Getting Started**: Copy-pasteable install/usage code block.
+    - **Rationale**: Why does this exist?
+    - **Design**: How is the program structured?
+    - **TODO**: Update meticulously, even between commits. When planning, put
+      the todo list in the README so a new agent can pick up where the last one
+      left off.
+    - **License**: MIT, GPL, or WTFPL. Ask the user for new projects. Include a
+      `LICENSE` file in the repo root and a License section in the README.
+    - **Author**: [@sneak](https://sneak.berlin).
+
+- First commit of a new repo should contain only `README.md`.
+
+- Go module root: `sneak.berlin/go/<name>`. Always run `go mod tidy` before
+  committing.
+
+- Use SemVer.
+
+- Database migrations live in `internal/db/migrations/` and must be embedded in
+  the binary. Pre-1.0.0: modify existing migrations (no installed base assumed).
+  Post-1.0.0: add new migration files.
+
+- All repos should have an `.editorconfig` enforcing the project's indentation
+  settings.
+
+- Avoid putting files in the repo root unless necessary. Root should contain
+  only project-level config files (`README.md`, `Makefile`, `Dockerfile`,
+  `LICENSE`, `.gitignore`, `.editorconfig`, `REPO_POLICIES.md`, and
+  language-specific config). Everything else goes in a subdirectory. Canonical
+  subdirectory names:
+    - `bin/` — executable scripts and tools
+    - `cmd/` — Go command entrypoints
+    - `configs/` — configuration templates and examples
+    - `deploy/` — deployment manifests (k8s, compose, terraform)
+    - `docs/` — documentation and markdown (README.md stays in root)
+    - `internal/` — Go internal packages
+    - `internal/db/migrations/` — database migrations
+    - `pkg/` — Go library packages
+    - `share/` — systemd units, data files
+    - `static/` — static assets (images, fonts, etc.)
+    - `web/` — web frontend source
+
+- When setting up a new repo, files from the `prompts` repo may be used as
+  templates. Fetch them from
+  `https://git.eeqj.de/sneak/prompts/raw/branch/main/<path>`.
+
+- New repos must contain at minimum:
+    - `README.md`, `.git`, `.gitignore`, `.editorconfig`
+    - `LICENSE`, `REPO_POLICIES.md` (copy from the `prompts` repo)
+    - `Makefile`
+    - `Dockerfile`, `.dockerignore`
+    - `.gitea/workflows/check.yml`
+    - Go: `go.mod`, `go.sum`, `.golangci.yml`
+    - JS: `package.json`, `yarn.lock`, `.prettierrc`, `.prettierignore`
+    - Python: `pyproject.toml`

cmd/chat-cli/api/client.go

@@ -1,3 +1,4 @@
+// Package chatapi provides a client for the chat server API.
 package chatapi
 
 import (
@@ -15,8 +16,8 @@ import (
 )
 
 const (
-	httpTimeout     = 30 * time.Second
-	pollExtraTime   = 5
+	httpTimeout      = 30 * time.Second
+	pollExtraTime    = 5
 	httpErrThreshold = 400
 )
 
@@ -31,17 +32,19 @@ type Client struct {
 
 // NewClient creates a new API client.
 func NewClient(baseURL string) *Client {
-	return &Client{
-		BaseURL:    baseURL,
-		HTTPClient: &http.Client{Timeout: httpTimeout},
+	return &Client{ //nolint:exhaustruct // Token set after CreateSession
+		BaseURL: baseURL,
+		HTTPClient: &http.Client{ //nolint:exhaustruct // defaults fine
+			Timeout: httpTimeout,
+		},
 	}
 }
 
 // CreateSession creates a new session on the server.
-func (c *Client) CreateSession(
+func (client *Client) CreateSession(
 	nick string,
 ) (*SessionResponse, error) {
-	data, err := c.do(
+	data, err := client.do(
 		http.MethodPost,
 		"/api/v1/session",
 		&SessionRequest{Nick: nick},
@@ -57,14 +60,14 @@ func (c *Client) CreateSession(
 		return nil, fmt.Errorf("decode session: %w", err)
 	}
 
-	c.Token = resp.Token
+	client.Token = resp.Token
 
 	return &resp, nil
 }
 
 // GetState returns the current user state.
-func (c *Client) GetState() (*StateResponse, error) {
-	data, err := c.do(
+func (client *Client) GetState() (*StateResponse, error) {
+	data, err := client.do(
 		http.MethodGet, "/api/v1/state", nil,
 	)
 	if err != nil {
@@ -82,8 +85,8 @@ func (c *Client) GetState() (*StateResponse, error) {
 }
 
 // SendMessage sends a message (any IRC command).
-func (c *Client) SendMessage(msg *Message) error {
-	_, err := c.do(
+func (client *Client) SendMessage(msg *Message) error {
+	_, err := client.do(
 		http.MethodPost, "/api/v1/messages", msg,
 	)
 
@@ -91,11 +94,11 @@ func (c *Client) SendMessage(msg *Message) error {
 }
 
 // PollMessages long-polls for new messages.
-func (c *Client) PollMessages(
+func (client *Client) PollMessages(
 	afterID int64,
 	timeout int,
 ) (*PollResult, error) {
-	client := &http.Client{
+	pollClient := &http.Client{ //nolint:exhaustruct // defaults fine
 		Timeout: time.Duration(
 			timeout+pollExtraTime,
 		) * time.Second,
@@ -113,28 +116,30 @@ func (c *Client) PollMessages(
 
 	path := "/api/v1/messages?" + params.Encode()
 
-	req, err := http.NewRequestWithContext(
+	request, err := http.NewRequestWithContext(
 		context.Background(),
 		http.MethodGet,
-		c.BaseURL+path,
+		client.BaseURL+path,
 		nil,
 	)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("new request: %w", err)
 	}
 
-	req.Header.Set("Authorization", "Bearer "+c.Token)
+	request.Header.Set(
+		"Authorization", "Bearer "+client.Token,
+	)
 
-	resp, err := client.Do(req) //nolint:gosec // URL built from trusted BaseURL + hardcoded path
+	resp, err := pollClient.Do(request)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("poll request: %w", err)
 	}
 
 	defer func() { _ = resp.Body.Close() }()
 
 	data, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("read poll body: %w", err)
 	}
 
 	if resp.StatusCode >= httpErrThreshold {
@@ -160,22 +165,28 @@ func (c *Client) PollMessages(
 }
 
 // JoinChannel joins a channel.
-func (c *Client) JoinChannel(channel string) error {
-	return c.SendMessage(
-		&Message{Command: "JOIN", To: channel},
+func (client *Client) JoinChannel(channel string) error {
+	return client.SendMessage(
+		&Message{ //nolint:exhaustruct // only command+to needed
+			Command: "JOIN", To: channel,
+		},
 	)
 }
 
 // PartChannel leaves a channel.
-func (c *Client) PartChannel(channel string) error {
-	return c.SendMessage(
-		&Message{Command: "PART", To: channel},
+func (client *Client) PartChannel(channel string) error {
+	return client.SendMessage(
+		&Message{ //nolint:exhaustruct // only command+to needed
+			Command: "PART", To: channel,
+		},
 	)
 }
 
 // ListChannels returns all channels on the server.
-func (c *Client) ListChannels() ([]Channel, error) {
-	data, err := c.do(
+func (client *Client) ListChannels() (
+	[]Channel, error,
+) {
+	data, err := client.do(
 		http.MethodGet, "/api/v1/channels", nil,
 	)
 	if err != nil {
@@ -186,19 +197,21 @@ func (c *Client) ListChannels() ([]Channel, error) {
 
 	err = json.Unmarshal(data, &channels)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf(
+			"decode channels: %w", err,
+		)
 	}
 
 	return channels, nil
 }
 
 // GetMembers returns members of a channel.
-func (c *Client) GetMembers(
+func (client *Client) GetMembers(
 	channel string,
 ) ([]string, error) {
 	name := strings.TrimPrefix(channel, "#")
 
-	data, err := c.do(
+	data, err := client.do(
 		http.MethodGet,
 		"/api/v1/channels/"+url.PathEscape(name)+
 			"/members",
@@ -221,8 +234,10 @@ func (c *Client) GetMembers(
 }
 
 // GetServerInfo returns server info.
-func (c *Client) GetServerInfo() (*ServerInfo, error) {
-	data, err := c.do(
+func (client *Client) GetServerInfo() (
+	*ServerInfo, error,
+) {
+	data, err := client.do(
 		http.MethodGet, "/api/v1/server", nil,
 	)
 	if err != nil {
@@ -233,13 +248,15 @@ func (c *Client) GetServerInfo() (*ServerInfo, error) {
 
 	err = json.Unmarshal(data, &info)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf(
+			"decode server info: %w", err,
+		)
 	}
 
 	return &info, nil
 }
 
-func (c *Client) do(
+func (client *Client) do(
 	method, path string,
 	body any,
 ) ([]byte, error) {
@@ -254,25 +271,27 @@ func (c *Client) do(
 		bodyReader = bytes.NewReader(data)
 	}
 
-	req, err := http.NewRequestWithContext(
+	request, err := http.NewRequestWithContext(
 		context.Background(),
 		method,
-		c.BaseURL+path,
+		client.BaseURL+path,
 		bodyReader,
 	)
 	if err != nil {
 		return nil, fmt.Errorf("request: %w", err)
 	}
 
-	req.Header.Set("Content-Type", "application/json")
+	request.Header.Set(
+		"Content-Type", "application/json",
+	)
 
-	if c.Token != "" {
-		req.Header.Set(
-			"Authorization", "Bearer "+c.Token,
+	if client.Token != "" {
+		request.Header.Set(
+			"Authorization", "Bearer "+client.Token,
 		)
 	}
 
-	resp, err := c.HTTPClient.Do(req) //nolint:gosec // URL built from trusted BaseURL + hardcoded path
+	resp, err := client.HTTPClient.Do(request)
 	if err != nil {
 		return nil, fmt.Errorf("http: %w", err)
 	}

cmd/chat-cli/api/types.go

@@ -1,4 +1,3 @@
-// Package chatapi provides API types and client for chat-cli.
 package chatapi
 
 import "time"
@@ -24,9 +23,9 @@ type StateResponse struct {
 
 // Message represents a chat message envelope.
 type Message struct {
-	Command string `json:"command"`
-	From    string `json:"from,omitempty"`
-	To      string `json:"to,omitempty"`
+	Command string   `json:"command"`
+	From    string   `json:"from,omitempty"`
+	To      string   `json:"to,omitempty"`
 	Params  []string `json:"params,omitempty"`
 	Body    any      `json:"body,omitempty"`
 	ID      string   `json:"id,omitempty"`
@@ -36,19 +35,19 @@ type Message struct {
 
 // BodyLines returns the body as a string slice.
 func (m *Message) BodyLines() []string {
-	switch v := m.Body.(type) {
+	switch bodyVal := m.Body.(type) {
 	case []any:
-		lines := make([]string, 0, len(v))
+		lines := make([]string, 0, len(bodyVal))
 
-		for _, item := range v {
-			if s, ok := item.(string); ok {
-				lines = append(lines, s)
+		for _, item := range bodyVal {
+			if str, ok := item.(string); ok {
+				lines = append(lines, str)
 			}
 		}
 
 		return lines
 	case []string:
-		return v
+		return bodyVal
 	default:
 		return nil
 	}

cmd/chat-cli/main.go

@@ -12,10 +12,10 @@ import (
 )
 
 const (
-	splitParts   = 2
-	pollTimeout  = 15
-	pollRetry    = 2 * time.Second
-	timeFormat   = "15:04"
+	splitParts  = 2
+	pollTimeout = 15
+	pollRetry   = 2 * time.Second
+	timeFormat  = "15:04"
 )
 
 // App holds the application state.
@@ -32,7 +32,7 @@ type App struct {
 }
 
 func main() {
-	app := &App{
+	app := &App{ //nolint:exhaustruct
 		ui:   NewUI(),
 		nick: "guest",
 	}
@@ -85,7 +85,7 @@ func (a *App) handleInput(text string) {
 		return
 	}
 
-	err := a.client.SendMessage(&api.Message{
+	err := a.client.SendMessage(&api.Message{ //nolint:exhaustruct
 		Command: "PRIVMSG",
 		To:      target,
 		Body:    []string{text},
@@ -98,7 +98,7 @@ func (a *App) handleInput(text string) {
 		return
 	}
 
-	ts := time.Now().Format(timeFormat)
+	timestamp := time.Now().Format(timeFormat)
 
 	a.mu.Lock()
 	nick := a.nick
@@ -106,7 +106,7 @@ func (a *App) handleInput(text string) {
 
 	a.ui.AddLine(target, fmt.Sprintf(
 		"[gray]%s [green]<%s>[white] %s",
-		ts, nick, text,
+		timestamp, nick, text,
 	))
 }
 
@@ -227,7 +227,7 @@ func (a *App) cmdNick(nick string) {
 		return
 	}
 
-	err := a.client.SendMessage(&api.Message{
+	err := a.client.SendMessage(&api.Message{ //nolint:exhaustruct
 		Command: "NICK",
 		Body:    []string{nick},
 	})
@@ -362,7 +362,7 @@ func (a *App) cmdMsg(args string) {
 		return
 	}
 
-	err := a.client.SendMessage(&api.Message{
+	err := a.client.SendMessage(&api.Message{ //nolint:exhaustruct
 		Command: "PRIVMSG",
 		To:      target,
 		Body:    []string{text},
@@ -375,11 +375,11 @@ func (a *App) cmdMsg(args string) {
 		return
 	}
 
-	ts := time.Now().Format(timeFormat)
+	timestamp := time.Now().Format(timeFormat)
 
 	a.ui.AddLine(target, fmt.Sprintf(
 		"[gray]%s [green]<%s>[white] %s",
-		ts, nick, text,
+		timestamp, nick, text,
 	))
 }
 
@@ -420,7 +420,7 @@ func (a *App) cmdTopic(args string) {
 	}
 
 	if args == "" {
-		err := a.client.SendMessage(&api.Message{
+		err := a.client.SendMessage(&api.Message{ //nolint:exhaustruct
 			Command: "TOPIC",
 			To:      target,
 		})
@@ -433,7 +433,7 @@ func (a *App) cmdTopic(args string) {
 		return
 	}
 
-	err := a.client.SendMessage(&api.Message{
+	err := a.client.SendMessage(&api.Message{ //nolint:exhaustruct
 		Command: "TOPIC",
 		To:      target,
 		Body:    []string{args},
@@ -519,18 +519,18 @@ func (a *App) cmdWindow(args string) {
 		return
 	}
 
-	var n int
+	var bufIndex int
 
-	_, _ = fmt.Sscanf(args, "%d", &n)
+	_, _ = fmt.Sscanf(args, "%d", &bufIndex)
 
-	a.ui.SwitchBuffer(n)
+	a.ui.SwitchBuffer(bufIndex)
 
 	a.mu.Lock()
 	nick := a.nick
 	a.mu.Unlock()
 
-	if n >= 0 && n < a.ui.BufferCount() {
-		buf := a.ui.buffers[n]
+	if bufIndex >= 0 && bufIndex < a.ui.BufferCount() {
+		buf := a.ui.buffers[bufIndex]
 		if buf.Name != "(status)" {
 			a.mu.Lock()
 			a.target = buf.Name
@@ -550,7 +550,7 @@ func (a *App) cmdQuit() {
 
 	if a.connected && a.client != nil {
 		_ = a.client.SendMessage(
-			&api.Message{Command: "QUIT"},
+			&api.Message{Command: "QUIT"}, //nolint:exhaustruct
 		)
 	}
 
@@ -625,7 +625,7 @@ func (a *App) pollLoop() {
 }
 
 func (a *App) handleServerMessage(msg *api.Message) {
-	ts := a.formatTS(msg)
+	timestamp := a.formatTS(msg)
 
 	a.mu.Lock()
 	myNick := a.nick
@@ -633,21 +633,21 @@ func (a *App) handleServerMessage(msg *api.Message) {
 
 	switch msg.Command {
 	case "PRIVMSG":
-		a.handlePrivmsgEvent(msg, ts, myNick)
+		a.handlePrivmsgEvent(msg, timestamp, myNick)
 	case "JOIN":
-		a.handleJoinEvent(msg, ts)
+		a.handleJoinEvent(msg, timestamp)
 	case "PART":
-		a.handlePartEvent(msg, ts)
+		a.handlePartEvent(msg, timestamp)
 	case "QUIT":
-		a.handleQuitEvent(msg, ts)
+		a.handleQuitEvent(msg, timestamp)
 	case "NICK":
-		a.handleNickEvent(msg, ts, myNick)
+		a.handleNickEvent(msg, timestamp, myNick)
 	case "NOTICE":
-		a.handleNoticeEvent(msg, ts)
+		a.handleNoticeEvent(msg, timestamp)
 	case "TOPIC":
-		a.handleTopicEvent(msg, ts)
+		a.handleTopicEvent(msg, timestamp)
 	default:
-		a.handleDefaultEvent(msg, ts)
+		a.handleDefaultEvent(msg, timestamp)
 	}
 }
 
@@ -660,7 +660,7 @@ func (a *App) formatTS(msg *api.Message) string {
 }
 
 func (a *App) handlePrivmsgEvent(
-	msg *api.Message, ts, myNick string,
+	msg *api.Message, timestamp, myNick string,
 ) {
 	lines := msg.BodyLines()
 	text := strings.Join(lines, " ")
@@ -676,12 +676,12 @@ func (a *App) handlePrivmsgEvent(
 
 	a.ui.AddLine(target, fmt.Sprintf(
 		"[gray]%s [green]<%s>[white] %s",
-		ts, msg.From, text,
+		timestamp, msg.From, text,
 	))
 }
 
 func (a *App) handleJoinEvent(
-	msg *api.Message, ts string,
+	msg *api.Message, timestamp string,
 ) {
 	if msg.To == "" {
 		return
@@ -689,12 +689,12 @@ func (a *App) handleJoinEvent(
 
 	a.ui.AddLine(msg.To, fmt.Sprintf(
 		"[gray]%s [yellow]*** %s has joined %s",
-		ts, msg.From, msg.To,
+		timestamp, msg.From, msg.To,
 	))
 }
 
 func (a *App) handlePartEvent(
-	msg *api.Message, ts string,
+	msg *api.Message, timestamp string,
 ) {
 	if msg.To == "" {
 		return
@@ -706,18 +706,18 @@ func (a *App) handlePartEvent(
 	if reason != "" {
 		a.ui.AddLine(msg.To, fmt.Sprintf(
 			"[gray]%s [yellow]*** %s has left %s (%s)",
-			ts, msg.From, msg.To, reason,
+			timestamp, msg.From, msg.To, reason,
 		))
 	} else {
 		a.ui.AddLine(msg.To, fmt.Sprintf(
 			"[gray]%s [yellow]*** %s has left %s",
-			ts, msg.From, msg.To,
+			timestamp, msg.From, msg.To,
 		))
 	}
 }
 
 func (a *App) handleQuitEvent(
-	msg *api.Message, ts string,
+	msg *api.Message, timestamp string,
 ) {
 	lines := msg.BodyLines()
 	reason := strings.Join(lines, " ")
@@ -725,18 +725,18 @@ func (a *App) handleQuitEvent(
 	if reason != "" {
 		a.ui.AddStatus(fmt.Sprintf(
 			"[gray]%s [yellow]*** %s has quit (%s)",
-			ts, msg.From, reason,
+			timestamp, msg.From, reason,
 		))
 	} else {
 		a.ui.AddStatus(fmt.Sprintf(
 			"[gray]%s [yellow]*** %s has quit",
-			ts, msg.From,
+			timestamp, msg.From,
 		))
 	}
 }
 
 func (a *App) handleNickEvent(
-	msg *api.Message, ts, myNick string,
+	msg *api.Message, timestamp, myNick string,
 ) {
 	lines := msg.BodyLines()
 
@@ -757,24 +757,24 @@ func (a *App) handleNickEvent(
 
 	a.ui.AddStatus(fmt.Sprintf(
 		"[gray]%s [yellow]*** %s is now known as %s",
-		ts, msg.From, newNick,
+		timestamp, msg.From, newNick,
 	))
 }
 
 func (a *App) handleNoticeEvent(
-	msg *api.Message, ts string,
+	msg *api.Message, timestamp string,
 ) {
 	lines := msg.BodyLines()
 	text := strings.Join(lines, " ")
 
 	a.ui.AddStatus(fmt.Sprintf(
 		"[gray]%s [magenta]--%s-- %s",
-		ts, msg.From, text,
+		timestamp, msg.From, text,
 	))
 }
 
 func (a *App) handleTopicEvent(
-	msg *api.Message, ts string,
+	msg *api.Message, timestamp string,
 ) {
 	if msg.To == "" {
 		return
@@ -785,12 +785,12 @@ func (a *App) handleTopicEvent(
 
 	a.ui.AddLine(msg.To, fmt.Sprintf(
 		"[gray]%s [cyan]*** %s set topic: %s",
-		ts, msg.From, text,
+		timestamp, msg.From, text,
 	))
 }
 
 func (a *App) handleDefaultEvent(
-	msg *api.Message, ts string,
+	msg *api.Message, timestamp string,
 ) {
 	lines := msg.BodyLines()
 	text := strings.Join(lines, " ")
@@ -798,7 +798,7 @@ func (a *App) handleDefaultEvent(
 	if text != "" {
 		a.ui.AddStatus(fmt.Sprintf(
 			"[gray]%s [white][%s] %s",
-			ts, msg.Command, text,
+			timestamp, msg.Command, text,
 		))
 	}
 }

cmd/chat-cli/ui.go

@@ -32,10 +32,10 @@ type UI struct {
 
 // NewUI creates the tview-based IRC-like UI.
 func NewUI() *UI {
-	ui := &UI{
+	ui := &UI{ //nolint:exhaustruct,varnamelen // fields set below; ui is idiomatic
 		app: tview.NewApplication(),
 		buffers: []*Buffer{
-			{Name: "(status)", Lines: nil},
+			{Name: "(status)", Lines: nil, Unread: 0},
 		},
 	}
 
@@ -58,7 +58,12 @@ func NewUI() *UI {
 
 // Run starts the UI event loop (blocks).
 func (ui *UI) Run() error {
-	return ui.app.Run()
+	err := ui.app.Run()
+	if err != nil {
+		return fmt.Errorf("run ui: %w", err)
+	}
+
+	return nil
 }
 
 // Stop stops the UI.
@@ -80,6 +85,7 @@ func (ui *UI) AddLine(bufferName, line string) {
 		cur := ui.buffers[ui.currentBuffer]
 		if cur != buf {
 			buf.Unread++
+
 			ui.refreshStatusBar()
 		}
 
@@ -99,15 +105,15 @@ func (ui *UI) AddStatus(line string) {
 }
 
 // SwitchBuffer switches to the buffer at index n.
-func (ui *UI) SwitchBuffer(n int) {
+func (ui *UI) SwitchBuffer(bufIndex int) {
 	ui.app.QueueUpdateDraw(func() {
-		if n < 0 || n >= len(ui.buffers) {
+		if bufIndex < 0 || bufIndex >= len(ui.buffers) {
 			return
 		}
 
-		ui.currentBuffer = n
+		ui.currentBuffer = bufIndex
 
-		buf := ui.buffers[n]
+		buf := ui.buffers[bufIndex]
 		buf.Unread = 0
 
 		ui.messages.Clear()
@@ -281,7 +287,7 @@ func (ui *UI) getOrCreateBuffer(name string) *Buffer {
 		}
 	}
 
-	buf := &Buffer{Name: name}
+	buf := &Buffer{Name: name, Lines: nil, Unread: 0}
 	ui.buffers = append(ui.buffers, buf)
 
 	return buf

internal/broker/broker.go

@@ -8,25 +8,28 @@ import (
 // Broker notifies waiting clients when new messages are available.
 type Broker struct {
 	mu        sync.Mutex
-	listeners map[int64][]chan struct{} // userID -> list of waiting channels
+	listeners map[int64][]chan struct{}
 }
 
 // New creates a new Broker.
 func New() *Broker {
-	return &Broker{
+	return &Broker{ //nolint:exhaustruct // mu has zero-value default
 		listeners: make(map[int64][]chan struct{}),
 	}
 }
 
-// Wait returns a channel that will be closed when a message is available for the user.
+// Wait returns a channel that will be closed when a message
+// is available for the user.
 func (b *Broker) Wait(userID int64) chan struct{} {
-	ch := make(chan struct{}, 1)
+	waitCh := make(chan struct{}, 1)
 
 	b.mu.Lock()
-	b.listeners[userID] = append(b.listeners[userID], ch)
+	b.listeners[userID] = append(
+		b.listeners[userID], waitCh,
+	)
 	b.mu.Unlock()
 
-	return ch
+	return waitCh
 }
 
 // Notify wakes up all waiting clients for a user.
@@ -36,24 +39,29 @@ func (b *Broker) Notify(userID int64) {
 	delete(b.listeners, userID)
 	b.mu.Unlock()
 
-	for _, ch := range waiters {
+	for _, waiter := range waiters {
 		select {
-		case ch <- struct{}{}:
+		case waiter <- struct{}{}:
 		default:
 		}
 	}
 }
 
 // Remove removes a specific wait channel (for cleanup on timeout).
-func (b *Broker) Remove(userID int64, ch chan struct{}) {
+func (b *Broker) Remove(
+	userID int64,
+	waitCh chan struct{},
+) {
 	b.mu.Lock()
 	defer b.mu.Unlock()
 
 	waiters := b.listeners[userID]
 
-	for i, w := range waiters {
-		if w == ch {
-			b.listeners[userID] = append(waiters[:i], waiters[i+1:]...)
+	for i, waiter := range waiters {
+		if waiter == waitCh {
+			b.listeners[userID] = append(
+				waiters[:i], waiters[i+1:]...,
+			)
 
 			break
 		}

internal/broker/broker_test.go

@@ -11,8 +11,8 @@ import (
 func TestNewBroker(t *testing.T) {
 	t.Parallel()
 
-	b := broker.New()
-	if b == nil {
+	brk := broker.New()
+	if brk == nil {
 		t.Fatal("expected non-nil broker")
 	}
 }
@@ -20,16 +20,16 @@ func TestNewBroker(t *testing.T) {
 func TestWaitAndNotify(t *testing.T) {
 	t.Parallel()
 
-	b := broker.New()
-	ch := b.Wait(1)
+	brk := broker.New()
+	waitCh := brk.Wait(1)
 
 	go func() {
 		time.Sleep(10 * time.Millisecond)
-		b.Notify(1)
+		brk.Notify(1)
 	}()
 
 	select {
-	case <-ch:
+	case <-waitCh:
 	case <-time.After(2 * time.Second):
 		t.Fatal("timeout")
 	}
@@ -38,21 +38,22 @@ func TestWaitAndNotify(t *testing.T) {
 func TestNotifyWithoutWaiters(t *testing.T) {
 	t.Parallel()
 
-	b := broker.New()
-	b.Notify(42) // should not panic
+	brk := broker.New()
+	brk.Notify(42) // should not panic.
 }
 
 func TestRemove(t *testing.T) {
 	t.Parallel()
 
-	b := broker.New()
-	ch := b.Wait(1)
-	b.Remove(1, ch)
+	brk := broker.New()
+	waitCh := brk.Wait(1)
 
-	b.Notify(1)
+	brk.Remove(1, waitCh)
+
+	brk.Notify(1)
 
 	select {
-	case <-ch:
+	case <-waitCh:
 		t.Fatal("should not receive after remove")
 	case <-time.After(50 * time.Millisecond):
 	}
@@ -61,20 +62,20 @@ func TestRemove(t *testing.T) {
 func TestMultipleWaiters(t *testing.T) {
 	t.Parallel()
 
-	b := broker.New()
-	ch1 := b.Wait(1)
-	ch2 := b.Wait(1)
+	brk := broker.New()
+	waitCh1 := brk.Wait(1)
+	waitCh2 := brk.Wait(1)
 
-	b.Notify(1)
+	brk.Notify(1)
 
 	select {
-	case <-ch1:
+	case <-waitCh1:
 	case <-time.After(time.Second):
 		t.Fatal("ch1 timeout")
 	}
 
 	select {
-	case <-ch2:
+	case <-waitCh2:
 	case <-time.After(time.Second):
 		t.Fatal("ch2 timeout")
 	}
@@ -83,36 +84,38 @@ func TestMultipleWaiters(t *testing.T) {
 func TestConcurrentWaitNotify(t *testing.T) {
 	t.Parallel()
 
-	b := broker.New()
+	brk := broker.New()
 
-	var wg sync.WaitGroup
+	var waitGroup sync.WaitGroup
 
 	const concurrency = 100
 
-	for i := range concurrency {
-		wg.Add(1)
+	for idx := range concurrency {
+		waitGroup.Add(1)
 
 		go func(uid int64) {
-			defer wg.Done()
+			defer waitGroup.Done()
 
-			ch := b.Wait(uid)
-			b.Notify(uid)
+			waitCh := brk.Wait(uid)
+
+			brk.Notify(uid)
 
 			select {
-			case <-ch:
+			case <-waitCh:
 			case <-time.After(time.Second):
 				t.Error("timeout")
 			}
-		}(int64(i % 10))
+		}(int64(idx % 10))
 	}
 
-	wg.Wait()
+	waitGroup.Wait()
 }
 
 func TestRemoveNonexistent(t *testing.T) {
 	t.Parallel()
 
-	b := broker.New()
-	ch := make(chan struct{}, 1)
-	b.Remove(999, ch) // should not panic
+	brk := broker.New()
+	waitCh := make(chan struct{}, 1)
+
+	brk.Remove(999, waitCh) // should not panic.
 }

internal/config/config.go

@@ -41,7 +41,9 @@ type Config struct {
 }
 
 // New creates a new Config by reading from files and environment variables.
-func New(_ fx.Lifecycle, params Params) (*Config, error) {
+func New(
+	_ fx.Lifecycle, params Params,
+) (*Config, error) {
 	log := params.Logger.Get()
 	name := params.Globals.Appname
 
@@ -74,7 +76,7 @@ func New(_ fx.Lifecycle, params Params) (*Config, error) {
 		}
 	}
 
-	s := &Config{
+	cfg := &Config{
 		DBURL:           viper.GetString("DBURL"),
 		Debug:           viper.GetBool("DEBUG"),
 		Port:            viper.GetInt("PORT"),
@@ -92,10 +94,10 @@ func New(_ fx.Lifecycle, params Params) (*Config, error) {
 		params:          &params,
 	}
 
-	if s.Debug {
+	if cfg.Debug {
 		params.Logger.EnableDebugLogging()
-		s.log = params.Logger.Get()
+		cfg.log = params.Logger.Get()
 	}
 
-	return s, nil
+	return cfg, nil
 }

internal/db/db.go

@@ -37,84 +37,93 @@ type Params struct {
 
 // Database manages the SQLite connection and migrations.
 type Database struct {
-	db     *sql.DB
+	conn   *sql.DB
 	log    *slog.Logger
 	params *Params
 }
 
 // New creates a new Database and registers lifecycle hooks.
 func New(
-	lc fx.Lifecycle,
+	lifecycle fx.Lifecycle,
 	params Params,
 ) (*Database, error) {
-	s := new(Database)
-	s.params = &params
-	s.log = params.Logger.Get()
+	database := &Database{ //nolint:exhaustruct // conn set in OnStart
+		params: &params,
+		log:    params.Logger.Get(),
+	}
 
-	s.log.Info("Database instantiated")
+	database.log.Info("Database instantiated")
 
-	lc.Append(fx.Hook{
+	lifecycle.Append(fx.Hook{
 		OnStart: func(ctx context.Context) error {
-			s.log.Info("Database OnStart Hook")
+			database.log.Info("Database OnStart Hook")
 
-			return s.connect(ctx)
+			return database.connect(ctx)
 		},
 		OnStop: func(_ context.Context) error {
-			s.log.Info("Database OnStop Hook")
+			database.log.Info("Database OnStop Hook")
 
-			if s.db != nil {
-				return s.db.Close()
+			if database.conn != nil {
+				closeErr := database.conn.Close()
+				if closeErr != nil {
+					return fmt.Errorf(
+						"close db: %w", closeErr,
+					)
+				}
 			}
 
 			return nil
 		},
 	})
 
-	return s, nil
+	return database, nil
 }
 
 // GetDB returns the underlying sql.DB connection.
-func (s *Database) GetDB() *sql.DB {
-	return s.db
+func (database *Database) GetDB() *sql.DB {
+	return database.conn
 }
 
-func (s *Database) connect(ctx context.Context) error {
-	dbURL := s.params.Config.DBURL
+func (database *Database) connect(ctx context.Context) error {
+	dbURL := database.params.Config.DBURL
 	if dbURL == "" {
-		dbURL = "file:./data.db?_journal_mode=WAL"
+		dbURL = "file:./data.db?_journal_mode=WAL&_busy_timeout=5000"
 	}
 
-	s.log.Info("connecting to database", "url", dbURL)
+	database.log.Info(
+		"connecting to database", "url", dbURL,
+	)
 
-	d, err := sql.Open("sqlite", dbURL)
+	conn, err := sql.Open("sqlite", dbURL)
 	if err != nil {
-		s.log.Error(
-			"failed to open database", "error", err,
-		)
-
-		return err
+		return fmt.Errorf("open database: %w", err)
 	}
 
-	err = d.PingContext(ctx)
+	err = conn.PingContext(ctx)
 	if err != nil {
-		s.log.Error(
-			"failed to ping database", "error", err,
-		)
-
-		return err
+		return fmt.Errorf("ping database: %w", err)
 	}
 
-	s.db = d
-	s.log.Info("database connected")
+	conn.SetMaxOpenConns(1)
 
-	_, err = s.db.ExecContext(
+	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 s.runMigrations(ctx)
+	_, err = database.conn.ExecContext(
+		ctx, "PRAGMA busy_timeout = 5000",
+	)
+	if err != nil {
+		return fmt.Errorf("set busy timeout: %w", err)
+	}
+
+	return database.runMigrations(ctx)
 }
 
 type migration struct {
@@ -123,10 +132,10 @@ type migration struct {
 	sql     string
 }
 
-func (s *Database) runMigrations(
+func (database *Database) runMigrations(
 	ctx context.Context,
 ) error {
-	_, err := s.db.ExecContext(ctx,
+	_, err := database.conn.ExecContext(ctx,
 		`CREATE TABLE IF NOT EXISTS schema_migrations (
 		 version INTEGER PRIMARY KEY,
 		 applied_at DATETIME DEFAULT CURRENT_TIMESTAMP)`)
@@ -136,37 +145,37 @@ func (s *Database) runMigrations(
 		)
 	}
 
-	migrations, err := s.loadMigrations()
+	migrations, err := database.loadMigrations()
 	if err != nil {
 		return err
 	}
 
-	for _, m := range migrations {
-		err = s.applyMigration(ctx, m)
+	for _, mig := range migrations {
+		err = database.applyMigration(ctx, mig)
 		if err != nil {
 			return err
 		}
 	}
 
-	s.log.Info("database migrations complete")
+	database.log.Info("database migrations complete")
 
 	return nil
 }
 
-func (s *Database) applyMigration(
+func (database *Database) applyMigration(
 	ctx context.Context,
-	m migration,
+	mig migration,
 ) error {
 	var exists int
 
-	err := s.db.QueryRowContext(ctx,
+	err := database.conn.QueryRowContext(ctx,
 		`SELECT COUNT(*) FROM schema_migrations
 		 WHERE version = ?`,
-		m.version,
+		mig.version,
 	).Scan(&exists)
 	if err != nil {
 		return fmt.Errorf(
-			"check migration %d: %w", m.version, err,
+			"check migration %d: %w", mig.version, err,
 		)
 	}
 
@@ -174,55 +183,63 @@ func (s *Database) applyMigration(
 		return nil
 	}
 
-	s.log.Info(
+	database.log.Info(
 		"applying migration",
-		"version", m.version,
-		"name", m.name,
+		"version", mig.version,
+		"name", mig.name,
 	)
 
-	return s.execMigration(ctx, m)
+	return database.execMigration(ctx, mig)
 }
 
-func (s *Database) execMigration(
+func (database *Database) execMigration(
 	ctx context.Context,
-	m migration,
+	mig migration,
 ) error {
-	tx, err := s.db.BeginTx(ctx, nil)
+	transaction, err := database.conn.BeginTx(ctx, nil)
 	if err != nil {
 		return fmt.Errorf(
 			"begin tx for migration %d: %w",
-			m.version, err,
+			mig.version, err,
 		)
 	}
 
-	_, err = tx.ExecContext(ctx, m.sql)
+	_, err = transaction.ExecContext(ctx, mig.sql)
 	if err != nil {
-		_ = tx.Rollback()
+		_ = transaction.Rollback()
 
 		return fmt.Errorf(
 			"apply migration %d (%s): %w",
-			m.version, m.name, err,
+			mig.version, mig.name, err,
 		)
 	}
 
-	_, err = tx.ExecContext(ctx,
+	_, err = transaction.ExecContext(ctx,
 		`INSERT INTO schema_migrations (version)
 		 VALUES (?)`,
-		m.version,
+		mig.version,
 	)
 	if err != nil {
-		_ = tx.Rollback()
+		_ = transaction.Rollback()
 
 		return fmt.Errorf(
 			"record migration %d: %w",
-			m.version, err,
+			mig.version, err,
 		)
 	}
 
-	return tx.Commit()
+	err = transaction.Commit()
+	if err != nil {
+		return fmt.Errorf(
+			"commit migration %d: %w",
+			mig.version, err,
+		)
+	}
+
+	return nil
 }
 
-func (s *Database) loadMigrations() (
+func (database *Database) loadMigrations() (
 	[]migration,
 	error,
 ) {
@@ -233,7 +250,7 @@ func (s *Database) loadMigrations() (
 		)
 	}
 
-	var migrations []migration
+	migrations := make([]migration, 0, len(entries))
 
 	for _, entry := range entries {
 		if entry.IsDir() ||

internal/db/export_test.go

@@ -13,35 +13,48 @@ var testDBCounter atomic.Int64
 
 // NewTestDatabase creates an in-memory database for testing.
 func NewTestDatabase() (*Database, error) {
-	n := testDBCounter.Add(1)
+	counter := testDBCounter.Add(1)
 
 	dsn := fmt.Sprintf(
 		"file:testdb%d?mode=memory"+
 			"&cache=shared&_pragma=foreign_keys(1)",
-		n,
+		counter,
 	)
 
-	d, err := sql.Open("sqlite", dsn)
+	conn, err := sql.Open("sqlite", dsn)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("open test db: %w", err)
 	}
 
-	database := &Database{db: d, log: slog.Default()}
+	database := &Database{ //nolint:exhaustruct // test helper, params not needed
+		conn: conn,
+		log:  slog.Default(),
+	}
 
 	err = database.runMigrations(context.Background())
 	if err != nil {
-		closeErr := d.Close()
+		closeErr := conn.Close()
 		if closeErr != nil {
-			return nil, closeErr
+			return nil, fmt.Errorf(
+				"close after migration failure: %w",
+				closeErr,
+			)
 		}
 
-		return nil, err
+		return nil, fmt.Errorf(
+			"run test migrations: %w", err,
+		)
 	}
 
 	return database, nil
 }
 
 // Close closes the underlying database connection.
-func (s *Database) Close() error {
-	return s.db.Close()
+func (database *Database) Close() error {
+	err := database.conn.Close()
+	if err != nil {
+		return fmt.Errorf("close database: %w", err)
+	}
+
+	return nil
 }

internal/db/queries.go

@@ -18,11 +18,15 @@ const (
 	defaultHistLimit = 50
 )
 
-func generateToken() string {
-	b := make([]byte, tokenBytes)
-	_, _ = rand.Read(b)
+func generateToken() (string, error) {
+	buf := make([]byte, tokenBytes)
 
-	return hex.EncodeToString(b)
+	_, err := rand.Read(buf)
+	if err != nil {
+		return "", fmt.Errorf("generate token: %w", err)
+	}
+
+	return hex.EncodeToString(buf), nil
 }
 
 // IRCMessage is the IRC envelope for all messages.
@@ -52,14 +56,18 @@ type MemberInfo struct {
 }
 
 // CreateUser registers a new user with the given nick.
-func (s *Database) CreateUser(
+func (database *Database) CreateUser(
 	ctx context.Context,
 	nick string,
 ) (int64, string, error) {
-	token := generateToken()
+	token, err := generateToken()
+	if err != nil {
+		return 0, "", err
+	}
+
 	now := time.Now()
 
-	res, err := s.db.ExecContext(ctx,
+	res, err := database.conn.ExecContext(ctx,
 		`INSERT INTO users
 		 (nick, token, created_at, last_seen)
 		 VALUES (?, ?, ?, ?)`,
@@ -68,90 +76,88 @@ func (s *Database) CreateUser(
 		return 0, "", fmt.Errorf("create user: %w", err)
 	}
 
-	id, _ := res.LastInsertId()
+	userID, _ := res.LastInsertId()
 
-	return id, token, nil
+	return userID, token, nil
 }
 
 // GetUserByToken returns user id and nick for a token.
-func (s *Database) GetUserByToken(
+func (database *Database) GetUserByToken(
 	ctx context.Context,
 	token string,
 ) (int64, string, error) {
-	var id int64
+	var userID int64
 
 	var nick string
 
-	err := s.db.QueryRowContext(
+	err := database.conn.QueryRowContext(
 		ctx,
 		"SELECT id, nick FROM users WHERE token = ?",
 		token,
-	).Scan(&id, &nick)
+	).Scan(&userID, &nick)
 	if err != nil {
-		return 0, "", err
+		return 0, "", fmt.Errorf("get user by token: %w", err)
 	}
 
-	_, _ = s.db.ExecContext(
+	_, _ = database.conn.ExecContext(
 		ctx,
 		"UPDATE users SET last_seen = ? WHERE id = ?",
-		time.Now(), id,
+		time.Now(), userID,
 	)
 
-	return id, nick, nil
+	return userID, nick, nil
 }
 
 // GetUserByNick returns user id for a given nick.
-func (s *Database) GetUserByNick(
+func (database *Database) GetUserByNick(
 	ctx context.Context,
 	nick string,
 ) (int64, error) {
-	var id int64
+	var userID int64
 
-	err := s.db.QueryRowContext(
+	err := database.conn.QueryRowContext(
 		ctx,
 		"SELECT id FROM users WHERE nick = ?",
 		nick,
-	).Scan(&id)
+	).Scan(&userID)
+	if err != nil {
+		return 0, fmt.Errorf("get user by nick: %w", err)
+	}
 
-	return id, err
+	return userID, nil
 }
 
 // GetChannelByName returns the channel ID for a name.
-func (s *Database) GetChannelByName(
+func (database *Database) GetChannelByName(
 	ctx context.Context,
 	name string,
 ) (int64, error) {
-	var id int64
+	var channelID int64
 
-	err := s.db.QueryRowContext(
+	err := database.conn.QueryRowContext(
 		ctx,
 		"SELECT id FROM channels WHERE name = ?",
 		name,
-	).Scan(&id)
+	).Scan(&channelID)
+	if err != nil {
+		return 0, fmt.Errorf(
+			"get channel by name: %w", err,
+		)
+	}
 
-	return id, err
+	return channelID, nil
 }
 
 // GetOrCreateChannel returns channel id, creating if needed.
-func (s *Database) GetOrCreateChannel(
+// Uses INSERT OR IGNORE to avoid TOCTOU races.
+func (database *Database) GetOrCreateChannel(
 	ctx context.Context,
 	name string,
 ) (int64, error) {
-	var id int64
-
-	err := s.db.QueryRowContext(
-		ctx,
-		"SELECT id FROM channels WHERE name = ?",
-		name,
-	).Scan(&id)
-	if err == nil {
-		return id, nil
-	}
-
 	now := time.Now()
 
-	res, err := s.db.ExecContext(ctx,
-		`INSERT INTO channels
+	_, err := database.conn.ExecContext(ctx,
+		`INSERT OR IGNORE INTO channels
 		 (name, created_at, updated_at)
 		 VALUES (?, ?, ?)`,
 		name, now, now)
@@ -159,51 +165,71 @@ func (s *Database) GetOrCreateChannel(
 		return 0, fmt.Errorf("create channel: %w", err)
 	}
 
-	id, _ = res.LastInsertId()
+	var channelID int64
 
-	return id, nil
+	err = database.conn.QueryRowContext(
+		ctx,
+		"SELECT id FROM channels WHERE name = ?",
+		name,
+	).Scan(&channelID)
+	if err != nil {
+		return 0, fmt.Errorf("get channel: %w", err)
+	}
+
+	return channelID, nil
 }
 
 // JoinChannel adds a user to a channel.
-func (s *Database) JoinChannel(
+func (database *Database) JoinChannel(
 	ctx context.Context,
 	channelID, userID int64,
 ) error {
-	_, err := s.db.ExecContext(ctx,
+	_, err := database.conn.ExecContext(ctx,
 		`INSERT OR IGNORE INTO channel_members
 		 (channel_id, user_id, joined_at)
 		 VALUES (?, ?, ?)`,
 		channelID, userID, time.Now())
+	if err != nil {
+		return fmt.Errorf("join channel: %w", err)
+	}
 
-	return err
+	return nil
 }
 
 // PartChannel removes a user from a channel.
-func (s *Database) PartChannel(
+func (database *Database) PartChannel(
 	ctx context.Context,
 	channelID, userID int64,
 ) error {
-	_, err := s.db.ExecContext(ctx,
+	_, err := database.conn.ExecContext(ctx,
 		`DELETE FROM channel_members
 		 WHERE channel_id = ? AND user_id = ?`,
 		channelID, userID)
+	if err != nil {
+		return fmt.Errorf("part channel: %w", err)
+	}
 
-	return err
+	return nil
 }
 
 // DeleteChannelIfEmpty removes a channel with no members.
-func (s *Database) DeleteChannelIfEmpty(
+func (database *Database) DeleteChannelIfEmpty(
 	ctx context.Context,
 	channelID int64,
 ) error {
-	_, err := s.db.ExecContext(ctx,
+	_, err := database.conn.ExecContext(ctx,
 		`DELETE FROM channels WHERE id = ?
 		 AND NOT EXISTS
 		 (SELECT 1 FROM channel_members
 		  WHERE channel_id = ?)`,
 		channelID, channelID)
+	if err != nil {
+		return fmt.Errorf(
+			"delete channel if empty: %w", err,
+		)
+	}
 
-	return err
+	return nil
 }
 
 // scanChannels scans rows into a ChannelInfo slice.
@@ -215,19 +241,21 @@ func scanChannels(
 	var out []ChannelInfo
 
 	for rows.Next() {
-		var ch ChannelInfo
+		var chanInfo ChannelInfo
 
-		err := rows.Scan(&ch.ID, &ch.Name, &ch.Topic)
+		err := rows.Scan(
+			&chanInfo.ID, &chanInfo.Name, &chanInfo.Topic,
+		)
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("scan channel: %w", err)
 		}
 
-		out = append(out, ch)
+		out = append(out, chanInfo)
 	}
 
 	err := rows.Err()
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("rows error: %w", err)
 	}
 
 	if out == nil {
@@ -238,11 +266,11 @@ func scanChannels(
 }
 
 // ListChannels returns channels the user has joined.
-func (s *Database) ListChannels(
+func (database *Database) ListChannels(
 	ctx context.Context,
 	userID int64,
 ) ([]ChannelInfo, error) {
-	rows, err := s.db.QueryContext(ctx,
+	rows, err := database.conn.QueryContext(ctx,
 		`SELECT c.id, c.name, c.topic
 		 FROM channels c
 		 INNER JOIN channel_members cm
@@ -250,32 +278,34 @@ func (s *Database) ListChannels(
 		 WHERE cm.user_id = ?
 		 ORDER BY c.name`, userID)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("list channels: %w", err)
 	}
 
 	return scanChannels(rows)
 }
 
 // ListAllChannels returns every channel.
-func (s *Database) ListAllChannels(
+func (database *Database) ListAllChannels(
 	ctx context.Context,
 ) ([]ChannelInfo, error) {
-	rows, err := s.db.QueryContext(ctx,
+	rows, err := database.conn.QueryContext(ctx,
 		`SELECT id, name, topic
 		 FROM channels ORDER BY name`)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf(
+			"list all channels: %w", err,
+		)
 	}
 
 	return scanChannels(rows)
 }
 
 // ChannelMembers returns all members of a channel.
-func (s *Database) ChannelMembers(
+func (database *Database) ChannelMembers(
 	ctx context.Context,
 	channelID int64,
 ) ([]MemberInfo, error) {
-	rows, err := s.db.QueryContext(ctx,
+	rows, err := database.conn.QueryContext(ctx,
 		`SELECT u.id, u.nick, u.last_seen
 		 FROM users u
 		 INNER JOIN channel_members cm
@@ -283,7 +313,9 @@ func (s *Database) ChannelMembers(
 		 WHERE cm.channel_id = ?
 		 ORDER BY u.nick`, channelID)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf(
+			"query channel members: %w", err,
+		)
 	}
 
 	defer func() { _ = rows.Close() }()
@@ -291,19 +323,23 @@ func (s *Database) ChannelMembers(
 	var members []MemberInfo
 
 	for rows.Next() {
-		var m MemberInfo
+		var member MemberInfo
 
-		err = rows.Scan(&m.ID, &m.Nick, &m.LastSeen)
+		err = rows.Scan(
+			&member.ID, &member.Nick, &member.LastSeen,
+		)
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf(
+				"scan member: %w", err,
+			)
 		}
 
-		members = append(members, m)
+		members = append(members, member)
 	}
 
 	err = rows.Err()
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("rows error: %w", err)
 	}
 
 	if members == nil {
@@ -313,6 +349,27 @@ func (s *Database) ChannelMembers(
 	return members, nil
 }
 
+// IsChannelMember checks if a user belongs to a channel.
+func (database *Database) IsChannelMember(
+	ctx context.Context,
+	channelID, userID int64,
+) (bool, error) {
+	var count int
+
+	err := database.conn.QueryRowContext(ctx,
+		`SELECT COUNT(*) FROM channel_members
+		 WHERE channel_id = ? AND user_id = ?`,
+		channelID, userID,
+	).Scan(&count)
+	if err != nil {
+		return false, fmt.Errorf(
+			"check membership: %w", err,
+		)
+	}
+
+	return count > 0, nil
+}
+
 // scanInt64s scans rows into an int64 slice.
 func scanInt64s(rows *sql.Rows) ([]int64, error) {
 	defer func() { _ = rows.Close() }()
@@ -320,58 +377,64 @@ func scanInt64s(rows *sql.Rows) ([]int64, error) {
 	var ids []int64
 
 	for rows.Next() {
-		var id int64
+		var val int64
 
-		err := rows.Scan(&id)
+		err := rows.Scan(&val)
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf(
+				"scan int64: %w", err,
+			)
 		}
 
-		ids = append(ids, id)
+		ids = append(ids, val)
 	}
 
 	err := rows.Err()
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("rows error: %w", err)
 	}
 
 	return ids, nil
 }
 
 // GetChannelMemberIDs returns user IDs in a channel.
-func (s *Database) GetChannelMemberIDs(
+func (database *Database) GetChannelMemberIDs(
 	ctx context.Context,
 	channelID int64,
 ) ([]int64, error) {
-	rows, err := s.db.QueryContext(ctx,
+	rows, err := database.conn.QueryContext(ctx,
 		`SELECT user_id FROM channel_members
 		 WHERE channel_id = ?`, channelID)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf(
+			"get channel member ids: %w", err,
+		)
 	}
 
 	return scanInt64s(rows)
 }
 
 // GetUserChannelIDs returns channel IDs the user is in.
-func (s *Database) GetUserChannelIDs(
+func (database *Database) GetUserChannelIDs(
 	ctx context.Context,
 	userID int64,
 ) ([]int64, error) {
-	rows, err := s.db.QueryContext(ctx,
+	rows, err := database.conn.QueryContext(ctx,
 		`SELECT channel_id FROM channel_members
 		 WHERE user_id = ?`, userID)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf(
+			"get user channel ids: %w", err,
+		)
 	}
 
 	return scanInt64s(rows)
 }
 
 // InsertMessage stores a message and returns its DB ID.
-func (s *Database) InsertMessage(
+func (database *Database) InsertMessage(
 	ctx context.Context,
-	command, from, to string,
+	command, from, target string,
 	body json.RawMessage,
 	meta json.RawMessage,
 ) (int64, string, error) {
@@ -386,38 +449,43 @@ func (s *Database) InsertMessage(
 		meta = json.RawMessage("{}")
 	}
 
-	res, err := s.db.ExecContext(ctx,
+	res, err := database.conn.ExecContext(ctx,
 		`INSERT INTO messages
 		 (uuid, command, msg_from, msg_to,
 		  body, meta, created_at)
 		 VALUES (?, ?, ?, ?, ?, ?, ?)`,
-		msgUUID, command, from, to,
+		msgUUID, command, from, target,
 		string(body), string(meta), now)
 	if err != nil {
-		return 0, "", err
+		return 0, "", fmt.Errorf(
+			"insert message: %w", err,
+		)
 	}
 
-	id, _ := res.LastInsertId()
+	dbID, _ := res.LastInsertId()
 
-	return id, msgUUID, nil
+	return dbID, msgUUID, nil
 }
 
 // EnqueueMessage adds a message to a user's queue.
-func (s *Database) EnqueueMessage(
+func (database *Database) EnqueueMessage(
 	ctx context.Context,
 	userID, messageID int64,
 ) error {
-	_, err := s.db.ExecContext(ctx,
+	_, err := database.conn.ExecContext(ctx,
 		`INSERT OR IGNORE INTO client_queues
 		 (user_id, message_id, created_at)
 		 VALUES (?, ?, ?)`,
 		userID, messageID, time.Now())
+	if err != nil {
+		return fmt.Errorf("enqueue message: %w", err)
+	}
 
-	return err
+	return nil
 }
 
 // PollMessages returns queued messages for a user.
-func (s *Database) PollMessages(
+func (database *Database) PollMessages(
 	ctx context.Context,
 	userID, afterQueueID int64,
 	limit int,
@@ -426,7 +494,7 @@ func (s *Database) PollMessages(
 		limit = defaultPollLimit
 	}
 
-	rows, err := s.db.QueryContext(ctx,
+	rows, err := database.conn.QueryContext(ctx,
 		`SELECT cq.id, m.uuid, m.command,
 		   m.msg_from, m.msg_to,
 		   m.body, m.meta, m.created_at
@@ -437,7 +505,9 @@ func (s *Database) PollMessages(
 		 ORDER BY cq.id ASC LIMIT ?`,
 		userID, afterQueueID, limit)
 	if err != nil {
-		return nil, afterQueueID, err
+		return nil, afterQueueID, fmt.Errorf(
+			"poll messages: %w", err,
+		)
 	}
 
 	msgs, lastQID, scanErr := scanMessages(
@@ -451,7 +521,7 @@ func (s *Database) PollMessages(
 }
 
 // GetHistory returns message history for a target.
-func (s *Database) GetHistory(
+func (database *Database) GetHistory(
 	ctx context.Context,
 	target string,
 	beforeID int64,
@@ -461,7 +531,7 @@ func (s *Database) GetHistory(
 		limit = defaultHistLimit
 	}
 
-	rows, err := s.queryHistory(
+	rows, err := database.queryHistory(
 		ctx, target, beforeID, limit,
 	)
 	if err != nil {
@@ -482,14 +552,14 @@ func (s *Database) GetHistory(
 	return msgs, nil
 }
 
-func (s *Database) queryHistory(
+func (database *Database) queryHistory(
 	ctx context.Context,
 	target string,
 	beforeID int64,
 	limit int,
 ) (*sql.Rows, error) {
 	if beforeID > 0 {
-		return s.db.QueryContext(ctx,
+		rows, err := database.conn.QueryContext(ctx,
 			`SELECT id, uuid, command, msg_from,
 			   msg_to, body, meta, created_at
 			 FROM messages
@@ -497,9 +567,16 @@ func (s *Database) queryHistory(
 			   AND command = 'PRIVMSG'
 			 ORDER BY id DESC LIMIT ?`,
 			target, beforeID, limit)
+		if err != nil {
+			return nil, fmt.Errorf(
+				"query history: %w", err,
+			)
+		}
+
+		return rows, nil
 	}
 
-	return s.db.QueryContext(ctx,
+	rows, err := database.conn.QueryContext(ctx,
 		`SELECT id, uuid, command, msg_from,
 		   msg_to, body, meta, created_at
 		 FROM messages
@@ -507,6 +584,11 @@ func (s *Database) queryHistory(
 		   AND command = 'PRIVMSG'
 		 ORDER BY id DESC LIMIT ?`,
 		target, limit)
+	if err != nil {
+		return nil, fmt.Errorf("query history: %w", err)
+	}
+
+	return rows, nil
 }
 
 func scanMessages(
@@ -521,33 +603,37 @@ func scanMessages(
 
 	for rows.Next() {
 		var (
-			m          IRCMessage
+			msg        IRCMessage
 			qID        int64
 			body, meta string
-			ts         time.Time
+			createdAt  time.Time
 		)
 
 		err := rows.Scan(
-			&qID, &m.ID, &m.Command,
-			&m.From, &m.To,
-			&body, &meta, &ts,
+			&qID, &msg.ID, &msg.Command,
+			&msg.From, &msg.To,
+			&body, &meta, &createdAt,
 		)
 		if err != nil {
-			return nil, fallbackQID, err
+			return nil, fallbackQID, fmt.Errorf(
+				"scan message: %w", err,
+			)
 		}
 
-		m.Body = json.RawMessage(body)
-		m.Meta = json.RawMessage(meta)
-		m.TS = ts.Format(time.RFC3339Nano)
-		m.DBID = qID
+		msg.Body = json.RawMessage(body)
+		msg.Meta = json.RawMessage(meta)
+		msg.TS = createdAt.Format(time.RFC3339Nano)
+		msg.DBID = qID
 		lastQID = qID
 
-		msgs = append(msgs, m)
+		msgs = append(msgs, msg)
 	}
 
 	err := rows.Err()
 	if err != nil {
-		return nil, fallbackQID, err
+		return nil, fallbackQID, fmt.Errorf(
+			"rows error: %w", err,
+		)
 	}
 
 	if msgs == nil {
@@ -564,59 +650,70 @@ func reverseMessages(msgs []IRCMessage) {
 }
 
 // ChangeNick updates a user's nickname.
-func (s *Database) ChangeNick(
+func (database *Database) ChangeNick(
 	ctx context.Context,
 	userID int64,
 	newNick string,
 ) error {
-	_, err := s.db.ExecContext(ctx,
+	_, err := database.conn.ExecContext(ctx,
 		"UPDATE users SET nick = ? WHERE id = ?",
 		newNick, userID)
+	if err != nil {
+		return fmt.Errorf("change nick: %w", err)
+	}
 
-	return err
+	return nil
 }
 
 // SetTopic sets the topic for a channel.
-func (s *Database) SetTopic(
+func (database *Database) SetTopic(
 	ctx context.Context,
 	channelName, topic string,
 ) error {
-	_, err := s.db.ExecContext(ctx,
+	_, err := database.conn.ExecContext(ctx,
 		`UPDATE channels SET topic = ?,
 		 updated_at = ? WHERE name = ?`,
 		topic, time.Now(), channelName)
+	if err != nil {
+		return fmt.Errorf("set topic: %w", err)
+	}
 
-	return err
+	return nil
 }
 
 // DeleteUser removes a user and all their data.
-func (s *Database) DeleteUser(
+func (database *Database) DeleteUser(
 	ctx context.Context,
 	userID int64,
 ) error {
-	_, err := s.db.ExecContext(
+	_, err := database.conn.ExecContext(
 		ctx,
 		"DELETE FROM users WHERE id = ?",
 		userID,
 	)
+	if err != nil {
+		return fmt.Errorf("delete user: %w", err)
+	}
 
-	return err
+	return nil
 }
 
 // GetAllChannelMembershipsForUser returns channels
 // a user belongs to.
-func (s *Database) GetAllChannelMembershipsForUser(
+func (database *Database) GetAllChannelMembershipsForUser(
 	ctx context.Context,
 	userID int64,
 ) ([]ChannelInfo, error) {
-	rows, err := s.db.QueryContext(ctx,
+	rows, err := database.conn.QueryContext(ctx,
 		`SELECT c.id, c.name, c.topic
 		 FROM channels c
 		 INNER JOIN channel_members cm
 		   ON cm.channel_id = c.id
 		 WHERE cm.user_id = ?`, userID)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf(
+			"get memberships: %w", err,
+		)
 	}
 
 	return scanChannels(rows)

internal/db/queries_test.go

@@ -1,7 +1,6 @@
 package db_test
 
 import (
-	"context"
 	"encoding/json"
 	"testing"
 
@@ -13,26 +12,26 @@ import (
 func setupTestDB(t *testing.T) *db.Database {
 	t.Helper()
 
-	d, err := db.NewTestDatabase()
+	database, err := db.NewTestDatabase()
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	t.Cleanup(func() {
-		closeErr := d.Close()
+		closeErr := database.Close()
 		if closeErr != nil {
 			t.Logf("close db: %v", closeErr)
 		}
 	})
 
-	return d
+	return database
 }
 
 func TestCreateUser(t *testing.T) {
 	t.Parallel()
 
 	database := setupTestDB(t)
-	ctx := context.Background()
+	ctx := t.Context()
 
 	id, token, err := database.CreateUser(ctx, "alice")
 	if err != nil {
@@ -53,7 +52,7 @@ func TestGetUserByToken(t *testing.T) {
 	t.Parallel()
 
 	database := setupTestDB(t)
-	ctx := context.Background()
+	ctx := t.Context()
 
 	_, token, err := database.CreateUser(ctx, "bob")
 	if err != nil {
@@ -79,7 +78,7 @@ func TestGetUserByNick(t *testing.T) {
 	t.Parallel()
 
 	database := setupTestDB(t)
-	ctx := context.Background()
+	ctx := t.Context()
 
 	_, _, err := database.CreateUser(ctx, "charlie")
 	if err != nil {
@@ -101,7 +100,7 @@ func TestChannelOperations(t *testing.T) {
 	t.Parallel()
 
 	database := setupTestDB(t)
-	ctx := context.Background()
+	ctx := t.Context()
 
 	chID, err := database.GetOrCreateChannel(ctx, "#test")
 	if err != nil || chID == 0 {
@@ -128,7 +127,7 @@ func TestJoinAndPart(t *testing.T) {
 	t.Parallel()
 
 	database := setupTestDB(t)
-	ctx := context.Background()
+	ctx := t.Context()
 
 	uid, _, err := database.CreateUser(ctx, "user1")
 	if err != nil {
@@ -170,7 +169,7 @@ func TestDeleteChannelIfEmpty(t *testing.T) {
 	t.Parallel()
 
 	database := setupTestDB(t)
-	ctx := context.Background()
+	ctx := t.Context()
 
 	chID, err := database.GetOrCreateChannel(
 		ctx, "#empty",
@@ -212,7 +211,7 @@ func createUserWithChannels(
 ) (int64, int64, int64) {
 	t.Helper()
 
-	ctx := context.Background()
+	ctx := t.Context()
 
 	uid, _, err := database.CreateUser(ctx, nick)
 	if err != nil {
@@ -255,7 +254,7 @@ func TestListChannels(t *testing.T) {
 	)
 
 	channels, err := database.ListChannels(
-		context.Background(), uid,
+		t.Context(), uid,
 	)
 	if err != nil || len(channels) != 2 {
 		t.Fatalf(
@@ -269,7 +268,7 @@ func TestListAllChannels(t *testing.T) {
 	t.Parallel()
 
 	database := setupTestDB(t)
-	ctx := context.Background()
+	ctx := t.Context()
 
 	_, err := database.GetOrCreateChannel(ctx, "#x")
 	if err != nil {
@@ -294,7 +293,7 @@ func TestChangeNick(t *testing.T) {
 	t.Parallel()
 
 	database := setupTestDB(t)
-	ctx := context.Background()
+	ctx := t.Context()
 
 	uid, token, err := database.CreateUser(ctx, "old")
 	if err != nil {
@@ -320,7 +319,7 @@ func TestSetTopic(t *testing.T) {
 	t.Parallel()
 
 	database := setupTestDB(t)
-	ctx := context.Background()
+	ctx := t.Context()
 
 	_, err := database.GetOrCreateChannel(
 		ctx, "#topictest",
@@ -350,11 +349,31 @@ func TestSetTopic(t *testing.T) {
 	}
 }
 
-func TestInsertAndPollMessages(t *testing.T) {
+func TestInsertMessage(t *testing.T) {
 	t.Parallel()
 
 	database := setupTestDB(t)
-	ctx := context.Background()
+	ctx := t.Context()
+
+	body := json.RawMessage(`["hello"]`)
+
+	dbID, msgUUID, err := database.InsertMessage(
+		ctx, "PRIVMSG", "poller", "#test", body, nil,
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if dbID == 0 || msgUUID == "" {
+		t.Fatal("expected valid id and uuid")
+	}
+}
+
+func TestPollMessages(t *testing.T) {
+	t.Parallel()
+
+	database := setupTestDB(t)
+	ctx := t.Context()
 
 	uid, _, err := database.CreateUser(ctx, "poller")
 	if err != nil {
@@ -363,11 +382,11 @@ func TestInsertAndPollMessages(t *testing.T) {
 
 	body := json.RawMessage(`["hello"]`)
 
-	dbID, msgUUID, err := database.InsertMessage(
+	dbID, _, err := database.InsertMessage(
 		ctx, "PRIVMSG", "poller", "#test", body, nil,
 	)
-	if err != nil || dbID == 0 || msgUUID == "" {
-		t.Fatal("insert failed")
+	if err != nil {
+		t.Fatal(err)
 	}
 
 	err = database.EnqueueMessage(ctx, uid, dbID)
@@ -415,7 +434,7 @@ func TestGetHistory(t *testing.T) {
 	t.Parallel()
 
 	database := setupTestDB(t)
-	ctx := context.Background()
+	ctx := t.Context()
 
 	const msgCount = 10
 
@@ -452,7 +471,7 @@ func TestDeleteUser(t *testing.T) {
 	t.Parallel()
 
 	database := setupTestDB(t)
-	ctx := context.Background()
+	ctx := t.Context()
 
 	uid, _, err := database.CreateUser(ctx, "deleteme")
 	if err != nil {
@@ -491,7 +510,7 @@ func TestChannelMembers(t *testing.T) {
 	t.Parallel()
 
 	database := setupTestDB(t)
-	ctx := context.Background()
+	ctx := t.Context()
 
 	uid1, _, err := database.CreateUser(ctx, "m1")
 	if err != nil {
@@ -539,7 +558,7 @@ func TestGetAllChannelMembershipsForUser(t *testing.T) {
 
 	channels, err :=
 		database.GetAllChannelMembershipsForUser(
-			context.Background(), uid,
+			t.Context(), uid,
 		)
 	if err != nil || len(channels) != 2 {
 		t.Fatalf(

internal/handlers/handlers.go

@@ -40,40 +40,59 @@ type Handlers struct {
 
 // New creates a new Handlers instance.
 func New(
-	lc fx.Lifecycle,
+	lifecycle fx.Lifecycle,
 	params Params,
 ) (*Handlers, error) {
-	s := new(Handlers)
-	s.params = &params
-	s.log = params.Logger.Get()
-	s.hc = params.Healthcheck
-	s.broker = broker.New()
+	hdlr := &Handlers{
+		params: &params,
+		log:    params.Logger.Get(),
+		hc:     params.Healthcheck,
+		broker: broker.New(),
+	}
 
-	lc.Append(fx.Hook{
+	lifecycle.Append(fx.Hook{
 		OnStart: func(_ context.Context) error {
 			return nil
 		},
+		OnStop: func(_ context.Context) error {
+			return nil
+		},
 	})
 
-	return s, nil
+	return hdlr, nil
 }
 
-func (s *Handlers) respondJSON(
-	w http.ResponseWriter,
+func (hdlr *Handlers) respondJSON(
+	writer http.ResponseWriter,
 	_ *http.Request,
 	data any,
 	status int,
 ) {
-	w.Header().Set(
+	writer.Header().Set(
 		"Content-Type",
 		"application/json; charset=utf-8",
 	)
-	w.WriteHeader(status)
+	writer.WriteHeader(status)
 
 	if data != nil {
-		err := json.NewEncoder(w).Encode(data)
+		err := json.NewEncoder(writer).Encode(data)
 		if err != nil {
-			s.log.Error("json encode error", "error", err)
+			hdlr.log.Error(
+				"json encode error", "error", err,
+			)
 		}
 	}
 }
+
+func (hdlr *Handlers) respondError(
+	writer http.ResponseWriter,
+	request *http.Request,
+	msg string,
+	status int,
+) {
+	hdlr.respondJSON(
+		writer, request,
+		map[string]string{"error": msg},
+		status,
+	)
+}

internal/handlers/healthcheck.go

@@ -7,9 +7,12 @@ import (
 const httpStatusOK = 200
 
 // HandleHealthCheck returns an HTTP handler for the health check endpoint.
-func (s *Handlers) HandleHealthCheck() http.HandlerFunc {
-	return func(w http.ResponseWriter, req *http.Request) {
-		resp := s.hc.Healthcheck()
-		s.respondJSON(w, req, resp, httpStatusOK)
+func (hdlr *Handlers) HandleHealthCheck() http.HandlerFunc {
+	return func(
+		writer http.ResponseWriter,
+		request *http.Request,
+	) {
+		resp := hdlr.hc.Healthcheck()
+		hdlr.respondJSON(writer, request, resp, httpStatusOK)
 	}
 }

internal/healthcheck/healthcheck.go

@@ -33,14 +33,17 @@ type Healthcheck struct {
 }
 
 // New creates a new Healthcheck instance.
-func New(lc fx.Lifecycle, params Params) (*Healthcheck, error) {
-	s := new(Healthcheck)
-	s.params = &params
-	s.log = params.Logger.Get()
+func New(
+	lifecycle fx.Lifecycle, params Params,
+) (*Healthcheck, error) {
+	hcheck := &Healthcheck{ //nolint:exhaustruct // StartupTime set in OnStart
+		params: &params,
+		log:    params.Logger.Get(),
+	}
 
-	lc.Append(fx.Hook{
+	lifecycle.Append(fx.Hook{
 		OnStart: func(_ context.Context) error {
-			s.StartupTime = time.Now()
+			hcheck.StartupTime = time.Now()
 
 			return nil
 		},
@@ -49,7 +52,7 @@ func New(lc fx.Lifecycle, params Params) (*Healthcheck, error) {
 		},
 	})
 
-	return s, nil
+	return hcheck, nil
 }
 
 // Response is the JSON response returned by the health endpoint.
@@ -64,19 +67,18 @@ type Response struct {
 }
 
 // Healthcheck returns the current health status of the server.
-func (s *Healthcheck) Healthcheck() *Response {
-	resp := &Response{
+func (hcheck *Healthcheck) Healthcheck() *Response {
+	return &Response{
 		Status:        "ok",
 		Now:           time.Now().UTC().Format(time.RFC3339Nano),
-		UptimeSeconds: int64(s.uptime().Seconds()),
-		UptimeHuman:   s.uptime().String(),
-		Appname:       s.params.Globals.Appname,
-		Version:       s.params.Globals.Version,
+		UptimeSeconds: int64(hcheck.uptime().Seconds()),
+		UptimeHuman:   hcheck.uptime().String(),
+		Appname:       hcheck.params.Globals.Appname,
+		Version:       hcheck.params.Globals.Version,
+		Maintenance:   hcheck.params.Config.MaintenanceMode,
 	}
-
-	return resp
 }
 
-func (s *Healthcheck) uptime() time.Duration {
-	return time.Since(s.StartupTime)
+func (hcheck *Healthcheck) uptime() time.Duration {
+	return time.Since(hcheck.StartupTime)
 }

internal/logger/logger.go

@@ -23,51 +23,56 @@ type Logger struct {
 	params Params
 }
 
-// New creates a new Logger with appropriate handler based on terminal detection.
-func New(_ fx.Lifecycle, params Params) (*Logger, error) {
-	l := new(Logger)
-	l.level = new(slog.LevelVar)
-	l.level.Set(slog.LevelInfo)
+// New creates a new Logger with appropriate handler
+// based on terminal detection.
+func New(
+	_ fx.Lifecycle, params Params,
+) (*Logger, error) {
+	logger := new(Logger)
+	logger.level = new(slog.LevelVar)
+	logger.level.Set(slog.LevelInfo)
 
 	tty := false
+
 	if fileInfo, _ := os.Stdout.Stat(); (fileInfo.Mode() & os.ModeCharDevice) != 0 {
 		tty = true
 	}
 
-	var handler slog.Handler
-	if tty {
-		handler = slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
-			Level:     l.level,
-			AddSource: true,
-		})
-	} else {
-		handler = slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
-			Level:     l.level,
-			AddSource: true,
-		})
+	opts := &slog.HandlerOptions{ //nolint:exhaustruct // ReplaceAttr optional
+		Level:     logger.level,
+		AddSource: true,
 	}
 
-	l.log = slog.New(handler)
-	l.params = params
+	var handler slog.Handler
+	if tty {
+		handler = slog.NewTextHandler(os.Stdout, opts)
+	} else {
+		handler = slog.NewJSONHandler(os.Stdout, opts)
+	}
 
-	return l, nil
+	logger.log = slog.New(handler)
+	logger.params = params
+
+	return logger, nil
 }
 
 // EnableDebugLogging switches the log level to debug.
-func (l *Logger) EnableDebugLogging() {
-	l.level.Set(slog.LevelDebug)
-	l.log.Debug("debug logging enabled", "debug", true)
+func (logger *Logger) EnableDebugLogging() {
+	logger.level.Set(slog.LevelDebug)
+	logger.log.Debug(
+		"debug logging enabled", "debug", true,
+	)
 }
 
 // Get returns the underlying slog.Logger.
-func (l *Logger) Get() *slog.Logger {
-	return l.log
+func (logger *Logger) Get() *slog.Logger {
+	return logger.log
 }
 
 // Identify logs the application name and version at startup.
-func (l *Logger) Identify() {
-	l.log.Info("starting",
-		"appname", l.params.Globals.Appname,
-		"version", l.params.Globals.Version,
+func (logger *Logger) Identify() {
+	logger.log.Info("starting",
+		"appname", logger.params.Globals.Appname,
+		"version", logger.params.Globals.Version,
 	)
 }

internal/middleware/middleware.go

@@ -11,7 +11,7 @@ import (
 	"git.eeqj.de/sneak/chat/internal/globals"
 	"git.eeqj.de/sneak/chat/internal/logger"
 	basicauth "github.com/99designs/basicauth-go"
-	"github.com/go-chi/chi/middleware"
+	chimw "github.com/go-chi/chi/middleware"
 	"github.com/go-chi/cors"
 	metrics "github.com/slok/go-http-metrics/metrics/prometheus"
 	ghmm "github.com/slok/go-http-metrics/middleware"
@@ -38,25 +38,28 @@ type Middleware struct {
 }
 
 // New creates a new Middleware instance.
-func New(_ fx.Lifecycle, params Params) (*Middleware, error) {
-	s := new(Middleware)
-	s.params = &params
-	s.log = params.Logger.Get()
+func New(
+	_ fx.Lifecycle, params Params,
+) (*Middleware, error) {
+	mware := &Middleware{
+		params: &params,
+		log:    params.Logger.Get(),
+	}
 
-	return s, nil
+	return mware, nil
 }
 
-func ipFromHostPort(hp string) string {
-	h, _, err := net.SplitHostPort(hp)
+func ipFromHostPort(hostPort string) string {
+	host, _, err := net.SplitHostPort(hostPort)
 	if err != nil {
 		return ""
 	}
 
-	if len(h) > 0 && h[0] == '[' {
-		return h[1 : len(h)-1]
+	if len(host) > 0 && host[0] == '[' {
+		return host[1 : len(host)-1]
 	}
 
-	return h
+	return host
 }
 
 type loggingResponseWriter struct {
@@ -65,9 +68,15 @@ type loggingResponseWriter struct {
 	statusCode int
 }
 
-// newLoggingResponseWriter wraps a ResponseWriter to capture the status code.
-func newLoggingResponseWriter(w http.ResponseWriter) *loggingResponseWriter {
-	return &loggingResponseWriter{w, http.StatusOK}
+// newLoggingResponseWriter wraps a ResponseWriter
+// to capture the status code.
+func newLoggingResponseWriter(
+	writer http.ResponseWriter,
+) *loggingResponseWriter {
+	return &loggingResponseWriter{
+		ResponseWriter: writer,
+		statusCode:     http.StatusOK,
+	}
 }
 
 func (lrw *loggingResponseWriter) WriteHeader(code int) {
@@ -76,43 +85,57 @@ func (lrw *loggingResponseWriter) WriteHeader(code int) {
 }
 
 // Logging returns middleware that logs each HTTP request.
-func (s *Middleware) Logging() func(http.Handler) http.Handler {
+func (mware *Middleware) Logging() func(http.Handler) http.Handler {
 	return func(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			start := time.Now()
-			lrw := newLoggingResponseWriter(w)
-			ctx := r.Context()
+		return http.HandlerFunc(
+			func(
+				writer http.ResponseWriter,
+				request *http.Request,
+			) {
+				start := time.Now()
+				lrw := newLoggingResponseWriter(writer)
+				ctx := request.Context()
 
-			defer func() {
-				latency := time.Since(start)
+				defer func() {
+					latency := time.Since(start)
 
-				reqID, _ := ctx.Value(middleware.RequestIDKey).(string)
+					reqID, _ := ctx.Value(
+						chimw.RequestIDKey,
+					).(string)
 
-				s.log.InfoContext(ctx, "request",
-					"request_start", start,
-					"method", r.Method,
-					"url", r.URL.String(),
-					"useragent", r.UserAgent(),
-					"request_id", reqID,
-					"referer", r.Referer(),
-					"proto", r.Proto,
-					"remoteIP", ipFromHostPort(r.RemoteAddr),
-					"status", lrw.statusCode,
-					"latency_ms", latency.Milliseconds(),
-				)
-			}()
+					mware.log.InfoContext(
+						ctx, "request",
+						"request_start", start,
+						"method", request.Method,
+						"url", request.URL.String(),
+						"useragent", request.UserAgent(),
+						"request_id", reqID,
+						"referer", request.Referer(),
+						"proto", request.Proto,
+						"remoteIP",
+						ipFromHostPort(request.RemoteAddr),
+						"status", lrw.statusCode,
+						"latency_ms",
+						latency.Milliseconds(),
+					)
+				}()
 
-			next.ServeHTTP(lrw, r)
-		})
+				next.ServeHTTP(lrw, request)
+			})
 	}
 }
 
 // CORS returns middleware that handles Cross-Origin Resource Sharing.
-func (s *Middleware) CORS() func(http.Handler) http.Handler {
-	return cors.Handler(cors.Options{
-		AllowedOrigins:   []string{"*"},
-		AllowedMethods:   []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
-		AllowedHeaders:   []string{"Accept", "Authorization", "Content-Type", "X-CSRF-Token"},
+func (mware *Middleware) CORS() func(http.Handler) http.Handler {
+	return cors.Handler(cors.Options{ //nolint:exhaustruct // optional fields
+		AllowedOrigins: []string{"*"},
+		AllowedMethods: []string{
+			"GET", "POST", "PUT", "DELETE", "OPTIONS",
+		},
+		AllowedHeaders: []string{
+			"Accept", "Authorization",
+			"Content-Type", "X-CSRF-Token",
+		},
 		ExposedHeaders:   []string{"Link"},
 		AllowCredentials: false,
 		MaxAge:           corsMaxAge,
@@ -120,28 +143,34 @@ func (s *Middleware) CORS() func(http.Handler) http.Handler {
 }
 
 // Auth returns middleware that performs authentication.
-func (s *Middleware) Auth() func(http.Handler) http.Handler {
+func (mware *Middleware) Auth() func(http.Handler) http.Handler {
 	return func(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			s.log.Info("AUTH: before request")
-			next.ServeHTTP(w, r)
-		})
+		return http.HandlerFunc(
+			func(
+				writer http.ResponseWriter,
+				request *http.Request,
+			) {
+				mware.log.Info("AUTH: before request")
+				next.ServeHTTP(writer, request)
+			})
 	}
 }
 
 // Metrics returns middleware that records HTTP metrics.
-func (s *Middleware) Metrics() func(http.Handler) http.Handler {
-	mdlw := ghmm.New(ghmm.Config{
-		Recorder: metrics.NewRecorder(metrics.Config{}),
+func (mware *Middleware) Metrics() func(http.Handler) http.Handler {
+	metricsMiddleware := ghmm.New(ghmm.Config{ //nolint:exhaustruct // optional fields
+		Recorder: metrics.NewRecorder(
+			metrics.Config{}, //nolint:exhaustruct // defaults
+		),
 	})
 
 	return func(next http.Handler) http.Handler {
-		return std.Handler("", mdlw, next)
+		return std.Handler("", metricsMiddleware, next)
 	}
 }
 
 // MetricsAuth returns middleware that protects metrics with basic auth.
-func (s *Middleware) MetricsAuth() func(http.Handler) http.Handler {
+func (mware *Middleware) MetricsAuth() func(http.Handler) http.Handler {
 	return basicauth.New(
 		"metrics",
 		map[string][]string{

internal/server/routes.go

@@ -17,67 +17,94 @@ import (
 const routeTimeout = 60 * time.Second
 
 // SetupRoutes configures the HTTP routes and middleware.
-func (s *Server) SetupRoutes() {
-	s.router = chi.NewRouter()
+func (srv *Server) SetupRoutes() {
+	srv.router = chi.NewRouter()
 
-	s.router.Use(middleware.Recoverer)
-	s.router.Use(middleware.RequestID)
-	s.router.Use(s.mw.Logging())
+	srv.router.Use(middleware.Recoverer)
+	srv.router.Use(middleware.RequestID)
+	srv.router.Use(srv.mw.Logging())
 
 	if viper.GetString("METRICS_USERNAME") != "" {
-		s.router.Use(s.mw.Metrics())
+		srv.router.Use(srv.mw.Metrics())
 	}
 
-	s.router.Use(s.mw.CORS())
-	s.router.Use(middleware.Timeout(routeTimeout))
+	srv.router.Use(srv.mw.CORS())
+	srv.router.Use(middleware.Timeout(routeTimeout))
 
-	if s.sentryEnabled {
-		sentryHandler := sentryhttp.New(sentryhttp.Options{
-			Repanic: true,
-		})
-		s.router.Use(sentryHandler.Handle)
+	if srv.sentryEnabled {
+		sentryHandler := sentryhttp.New(
+			sentryhttp.Options{ //nolint:exhaustruct // optional fields
+				Repanic: true,
+			},
+		)
+
+		srv.router.Use(sentryHandler.Handle)
 	}
 
-	// Health check
-	s.router.Get(
+	// Health check.
+	srv.router.Get(
 		"/.well-known/healthcheck.json",
-		s.h.HandleHealthCheck(),
+		srv.handlers.HandleHealthCheck(),
 	)
 
-	// Protected metrics endpoint
+	// Protected metrics endpoint.
 	if viper.GetString("METRICS_USERNAME") != "" {
-		s.router.Group(func(r chi.Router) {
-			r.Use(s.mw.MetricsAuth())
-			r.Get("/metrics",
+		srv.router.Group(func(router chi.Router) {
+			router.Use(srv.mw.MetricsAuth())
+			router.Get("/metrics",
 				http.HandlerFunc(
 					promhttp.Handler().ServeHTTP,
 				))
 		})
 	}
 
-	// API v1
-	s.router.Route("/api/v1", func(r chi.Router) {
-		r.Get("/server", s.h.HandleServerInfo())
-		r.Post("/session", s.h.HandleCreateSession())
-		r.Get("/state", s.h.HandleState())
-		r.Get("/messages", s.h.HandleGetMessages())
-		r.Post("/messages", s.h.HandleSendCommand())
-		r.Get("/history", s.h.HandleGetHistory())
-		r.Get("/channels", s.h.HandleListAllChannels())
-		r.Get(
-			"/channels/{channel}/members",
-			s.h.HandleChannelMembers(),
-		)
-	})
+	// API v1.
+	srv.router.Route(
+		"/api/v1",
+		func(router chi.Router) {
+			router.Get(
+				"/server",
+				srv.handlers.HandleServerInfo(),
+			)
+			router.Post(
+				"/session",
+				srv.handlers.HandleCreateSession(),
+			)
+			router.Get(
+				"/state",
+				srv.handlers.HandleState(),
+			)
+			router.Get(
+				"/messages",
+				srv.handlers.HandleGetMessages(),
+			)
+			router.Post(
+				"/messages",
+				srv.handlers.HandleSendCommand(),
+			)
+			router.Get(
+				"/history",
+				srv.handlers.HandleGetHistory(),
+			)
+			router.Get(
+				"/channels",
+				srv.handlers.HandleListAllChannels(),
+			)
+			router.Get(
+				"/channels/{channel}/members",
+				srv.handlers.HandleChannelMembers(),
+			)
+		},
+	)
 
-	// Serve embedded SPA
-	s.setupSPA()
+	// Serve embedded SPA.
+	srv.setupSPA()
 }
 
-func (s *Server) setupSPA() {
+func (srv *Server) setupSPA() {
 	distFS, err := fs.Sub(web.Dist, "dist")
 	if err != nil {
-		s.log.Error(
+		srv.log.Error(
 			"failed to get web dist filesystem",
 			"error", err,
 		)
@@ -87,38 +114,40 @@ func (s *Server) setupSPA() {
 
 	fileServer := http.FileServer(http.FS(distFS))
 
-	s.router.Get("/*", func(
-		w http.ResponseWriter,
-		r *http.Request,
+	srv.router.Get("/*", func(
+		writer http.ResponseWriter,
+		request *http.Request,
 	) {
 		readFS, ok := distFS.(fs.ReadFileFS)
 		if !ok {
-			fileServer.ServeHTTP(w, r)
+			fileServer.ServeHTTP(writer, request)
 
 			return
 		}
 
-		f, readErr := readFS.ReadFile(r.URL.Path[1:])
-		if readErr != nil || len(f) == 0 {
+		fileData, readErr := readFS.ReadFile(
+			request.URL.Path[1:],
+		)
+		if readErr != nil || len(fileData) == 0 {
 			indexHTML, indexErr := readFS.ReadFile(
 				"index.html",
 			)
 			if indexErr != nil {
-				http.NotFound(w, r)
+				http.NotFound(writer, request)
 
 				return
 			}
 
-			w.Header().Set(
+			writer.Header().Set(
 				"Content-Type",
 				"text/html; charset=utf-8",
 			)
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write(indexHTML)
+			writer.WriteHeader(http.StatusOK)
+			_, _ = writer.Write(indexHTML)
 
 			return
 		}
 
-		fileServer.ServeHTTP(w, r)
+		fileServer.ServeHTTP(writer, request)
 	})
 }

internal/server/server.go

@@ -41,7 +41,8 @@ type Params struct {
 	Handlers   *handlers.Handlers
 }
 
-// Server is the main HTTP server. It manages routing, middleware, and lifecycle.
+// Server is the main HTTP server.
+// It manages routing, middleware, and lifecycle.
 type Server struct {
 	startupTime   time.Time
 	exitCode      int
@@ -53,21 +54,24 @@ type Server struct {
 	router        *chi.Mux
 	params        Params
 	mw            *middleware.Middleware
-	h             *handlers.Handlers
+	handlers      *handlers.Handlers
 }
 
 // New creates a new Server and registers its lifecycle hooks.
-func New(lc fx.Lifecycle, params Params) (*Server, error) {
-	s := new(Server)
-	s.params = params
-	s.mw = params.Middleware
-	s.h = params.Handlers
-	s.log = params.Logger.Get()
+func New(
+	lifecycle fx.Lifecycle, params Params,
+) (*Server, error) {
+	srv := &Server{ //nolint:exhaustruct // fields set during lifecycle
+		params:   params,
+		mw:       params.Middleware,
+		handlers: params.Handlers,
+		log:      params.Logger.Get(),
+	}
 
-	lc.Append(fx.Hook{
+	lifecycle.Append(fx.Hook{
 		OnStart: func(_ context.Context) error {
-			s.startupTime = time.Now()
-			go s.Run() //nolint:contextcheck
+			srv.startupTime = time.Now()
+			go srv.Run() //nolint:contextcheck
 
 			return nil
 		},
@@ -76,122 +80,140 @@ func New(lc fx.Lifecycle, params Params) (*Server, error) {
 		},
 	})
 
-	return s, nil
+	return srv, nil
 }
 
 // Run starts the server configuration, Sentry, and begins serving.
-func (s *Server) Run() {
-	s.configure()
-	s.enableSentry()
-	s.serve()
+func (srv *Server) Run() {
+	srv.configure()
+	srv.enableSentry()
+	srv.serve()
 }
 
 // ServeHTTP delegates to the chi router.
-func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	s.router.ServeHTTP(w, r)
+func (srv *Server) ServeHTTP(
+	writer http.ResponseWriter,
+	request *http.Request,
+) {
+	srv.router.ServeHTTP(writer, request)
 }
 
 // MaintenanceMode reports whether the server is in maintenance mode.
-func (s *Server) MaintenanceMode() bool {
-	return s.params.Config.MaintenanceMode
+func (srv *Server) MaintenanceMode() bool {
+	return srv.params.Config.MaintenanceMode
 }
 
-func (s *Server) enableSentry() {
-	s.sentryEnabled = false
+func (srv *Server) enableSentry() {
+	srv.sentryEnabled = false
 
-	if s.params.Config.SentryDSN == "" {
+	if srv.params.Config.SentryDSN == "" {
 		return
 	}
 
-	err := sentry.Init(sentry.ClientOptions{
-		Dsn:     s.params.Config.SentryDSN,
-		Release: fmt.Sprintf("%s-%s", s.params.Globals.Appname, s.params.Globals.Version),
+	err := sentry.Init(sentry.ClientOptions{ //nolint:exhaustruct // only essential fields
+		Dsn: srv.params.Config.SentryDSN,
+		Release: fmt.Sprintf(
+			"%s-%s",
+			srv.params.Globals.Appname,
+			srv.params.Globals.Version,
+		),
 	})
 	if err != nil {
-		s.log.Error("sentry init failure", "error", err)
+		srv.log.Error("sentry init failure", "error", err)
 		os.Exit(1)
 	}
 
-	s.log.Info("sentry error reporting activated")
-	s.sentryEnabled = true
+	srv.log.Info("sentry error reporting activated")
+	srv.sentryEnabled = true
 }
 
-func (s *Server) serve() int {
-	s.ctx, s.cancelFunc = context.WithCancel(context.Background())
+func (srv *Server) serve() int {
+	srv.ctx, srv.cancelFunc = context.WithCancel(
+		context.Background(),
+	)
 
 	go func() {
-		c := make(chan os.Signal, 1)
+		sigCh := make(chan os.Signal, 1)
 
 		signal.Ignore(syscall.SIGPIPE)
-		signal.Notify(c, os.Interrupt, syscall.SIGTERM)
-		sig := <-c
-		s.log.Info("signal received", "signal", sig)
+		signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM)
 
-		if s.cancelFunc != nil {
-			s.cancelFunc()
+		sig := <-sigCh
+
+		srv.log.Info("signal received", "signal", sig)
+
+		if srv.cancelFunc != nil {
+			srv.cancelFunc()
 		}
 	}()
 
-	go s.serveUntilShutdown()
+	go srv.serveUntilShutdown()
 
-	<-s.ctx.Done()
+	<-srv.ctx.Done()
 
-	s.cleanShutdown()
+	srv.cleanShutdown()
 
-	return s.exitCode
+	return srv.exitCode
 }
 
-func (s *Server) cleanupForExit() {
-	s.log.Info("cleaning up")
+func (srv *Server) cleanupForExit() {
+	srv.log.Info("cleaning up")
 }
 
-func (s *Server) cleanShutdown() {
-	s.exitCode = 0
+func (srv *Server) cleanShutdown() {
+	srv.exitCode = 0
 
 	ctxShutdown, shutdownCancel := context.WithTimeout(
 		context.Background(), shutdownTimeout,
 	)
 
-	err := s.httpServer.Shutdown(ctxShutdown)
+	err := srv.httpServer.Shutdown(ctxShutdown)
 	if err != nil {
-		s.log.Error("server clean shutdown failed", "error", err)
+		srv.log.Error(
+			"server clean shutdown failed", "error", err,
+		)
 	}
 
 	if shutdownCancel != nil {
 		shutdownCancel()
 	}
 
-	s.cleanupForExit()
+	srv.cleanupForExit()
 
-	if s.sentryEnabled {
+	if srv.sentryEnabled {
 		sentry.Flush(sentryFlushTime)
 	}
 }
 
-func (s *Server) configure() {
-	// server configuration placeholder
+func (srv *Server) configure() {
+	// Server configuration placeholder.
 }
 
-func (s *Server) serveUntilShutdown() {
-	listenAddr := fmt.Sprintf(":%d", s.params.Config.Port)
-	s.httpServer = &http.Server{
+func (srv *Server) serveUntilShutdown() {
+	listenAddr := fmt.Sprintf(
+		":%d", srv.params.Config.Port,
+	)
+
+	srv.httpServer = &http.Server{ //nolint:exhaustruct // optional fields
 		Addr:           listenAddr,
 		ReadTimeout:    httpReadTimeout,
 		WriteTimeout:   httpWriteTimeout,
 		MaxHeaderBytes: maxHeaderBytes,
-		Handler:        s,
+		Handler:        srv,
 	}
 
-	s.SetupRoutes()
+	srv.SetupRoutes()
 
-	s.log.Info("http begin listen", "listenaddr", listenAddr)
+	srv.log.Info(
+		"http begin listen", "listenaddr", listenAddr,
+	)
 
-	err := s.httpServer.ListenAndServe()
+	err := srv.httpServer.ListenAndServe()
 	if err != nil && !errors.Is(err, http.ErrServerClosed) {
-		s.log.Error("listen error", "error", err)
+		srv.log.Error("listen error", "error", err)
 
-		if s.cancelFunc != nil {
-			s.cancelFunc()
+		if srv.cancelFunc != nil {
+			srv.cancelFunc()
 		}
 	}
 }