Phase 3: sending domains + per-domain OpenDKIM signing

Add/list/delete of sending domains with per-domain DKIM keys and the
OpenDKIM tables that drive signing (spec 6, 7.2.2-4, 7.2.10).

internal/domain:
- Pure-Go RSA-2048 keygen; PKCS#1 PEM written atomically at 0640; the
  published DNS TXT record is derived from the key on disk (single source
  of truth) rather than persisted. No os/exec for key generation.
- KeyTable/SigningTable fully regenerated from the registry on every
  add/delete (idempotent), written atomically; SigningTable via refile:
  with *@domain, KeyTable with absolute key paths. Table writer refuses
  any unsafe character as a backstop (spec 7.6.4).
- Reload without root: the unprivileged panel signals OpenDKIM through
  supervisord (`supervisorctl signal USR1 opendkim`, fixed args, no
  shell, no user input — spec 7.6.3). An existing key is reused, never
  overwritten, so re-adding a domain keeps its published DNS valid.
- Service orchestrates registry -> key -> table rebuild -> reload, with
  rollback of the row if a downstream step fails; delete cascades apps
  via the DB FK and removes the key + table entries.

Infra:
- Shared `selfpost` group bridges panel (writes keys) and opendkim
  (reads them); /data/opendkim is setgid so panel-created files inherit
  the group, keys are 0640, RequireSafeKeys is disabled by design.
- opendkim.conf moves from verify-only (Mode v) to signing (Mode s).
- entrypoint.sh normalises the DKIM tree on every start (ownership,
  setgid, perms, empty tables before opendkim starts) — self-healing
  after a restore.
- supervisord control socket opened to the `selfpost` group so the panel
  can request the reload.

web/store:
- Strict domain-name validation (whitelist [a-z0-9.-], DNS shape, >=2
  labels), lower-case normalisation (spec 7.6.2).
- Domain queries with application counts; delete relies on ON DELETE
  CASCADE. Dashboard lists domains + add form; domain page shows the
  DKIM record; a dedicated confirm page warns about the app cascade
  before deletion (spec 7.2.4); manual reload button (spec 7.2.12,
  OpenDKIM side; Postfix reload lands in Phase 5).
- Authenticated routes moved to a sub-mux using Go 1.22 method/wildcard
  patterns.

Tests: validateDomain, DKIM keygen/record roundtrip, table rendering +
injection-safety, key reuse, store cascade. Verified on the dev server:
gofmt/vet/test green, image builds, container e2e (add/delete a domain,
DKIM record shown, OpenDKIM reads panel keys and reloads, keys and
tables persist across a restart).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

internal/domain/service.go

@@ -0,0 +1,117 @@
+package domain
+
+import (
+	"fmt"
+
+	"codeberg.org/mix/selfpost/internal/store"
+)
+
+// Service coordinates the three places a sending domain lives: the SQLite
+// registry, the on-disk DKIM keys and OpenDKIM's tables. Callers (the web
+// handlers) validate user input first; Service keeps the three stores in
+// agreement and drives the OpenDKIM reload (spec 6, 7.2.2-4, 7.2.10).
+type Service struct {
+	store    *store.Store
+	odk      *OpenDKIM
+	selector string
+}
+
+// NewService builds the domain service. selectorDefault is the DKIM selector
+// assigned to new domains (spec 8: DKIM_SELECTOR_DEFAULT); it is
+// operator-configured, not user input.
+func NewService(st *store.Store, odk *OpenDKIM, selectorDefault string) *Service {
+	return &Service{store: st, odk: odk, selector: selectorDefault}
+}
+
+// List returns all domains with application counts (spec 7.2.2).
+func (s *Service) List() ([]store.Domain, error) {
+	return s.store.ListDomains()
+}
+
+// Get returns one domain by id (store.ErrDomainNotFound if absent).
+func (s *Service) Get(id int64) (store.Domain, error) {
+	return s.store.GetDomain(id)
+}
+
+// Add registers a new sending domain: it records the row, ensures a DKIM key
+// exists on disk, and regenerates + reloads the OpenDKIM tables (spec 7.2.3).
+// name must already be normalised and validated by the caller. A duplicate
+// returns store.ErrDomainExists.
+//
+// The registry row is written first so its UNIQUE constraint is the single
+// arbiter of "already exists" (avoiding a check-then-act race). An existing
+// on-disk key is reused rather than overwritten, so re-adding a domain whose DB
+// row was lost keeps its published DNS record valid. If key generation or the
+// OpenDKIM rebuild fails, the row is rolled back so we never leave a registered
+// domain that OpenDKIM cannot sign.
+func (s *Service) Add(name string) (store.Domain, error) {
+	d, err := s.store.AddDomain(name, s.selector)
+	if err != nil {
+		return store.Domain{}, err
+	}
+
+	if _, err := s.odk.EnsureKey(d.Name, d.DKIMSelector); err != nil {
+		s.rollbackAdd(d.ID)
+		return store.Domain{}, err
+	}
+	if err := s.resync(); err != nil {
+		s.rollbackAdd(d.ID)
+		return store.Domain{}, err
+	}
+	return d, nil
+}
+
+// rollbackAdd best-effort removes a half-created domain after a downstream
+// failure. Errors here are logged by the caller's returned error path; the key
+// (if freshly generated) is left in place harmlessly and reused on retry.
+func (s *Service) rollbackAdd(id int64) {
+	_ = s.store.DeleteDomain(id)
+}
+
+// Delete removes a domain and everything bound to it — applications and their
+// SASL/binding rows go via the DB cascade, and the DKIM key and table entries
+// are removed here (spec 7.2.4, 6.5). The registry row and tables are updated
+// (so OpenDKIM stops signing for the domain) before the key is deleted.
+func (s *Service) Delete(id int64) error {
+	d, err := s.store.GetDomain(id)
+	if err != nil {
+		return err
+	}
+	if err := s.store.DeleteDomain(id); err != nil {
+		return err
+	}
+	if err := s.resync(); err != nil {
+		return err
+	}
+	if err := s.odk.RemoveKey(d.Name); err != nil {
+		// The domain is gone from the registry and tables; a leftover key
+		// directory is harmless. Surface it so it is not silently ignored.
+		return fmt.Errorf("domain deleted but key cleanup failed: %w", err)
+	}
+	return nil
+}
+
+// DKIMRecord returns the DNS TXT record to publish for a domain (spec 7.2.10).
+func (s *Service) DKIMRecord(d store.Domain) (DKIMRecord, error) {
+	return s.odk.Record(d.Name, d.DKIMSelector)
+}
+
+// Resync regenerates the OpenDKIM tables from the registry and reloads OpenDKIM.
+// It backs the manual reload button (spec 7.2.12) and doubles as a recovery path
+// if the tables ever drift from the database.
+func (s *Service) Resync() error {
+	return s.resync()
+}
+
+// resync rebuilds KeyTable/SigningTable from the current domain set and reloads.
+func (s *Service) resync() error {
+	domains, err := s.store.ListDomains()
+	if err != nil {
+		return err
+	}
+	signing := make([]SigningDomain, 0, len(domains))
+	for _, d := range domains {
+		signing = append(signing, SigningDomain{Name: d.Name, Selector: d.DKIMSelector})
+	}
+	return s.odk.Rebuild(signing)
+}