Derive the image's version from the .git in the build context (closes #366)

A plain docker build, as upaas runs it, passed no VERSION build arg and
had no .git, so every such image stamped "unknown". .dockerignore now
sends .git and every tracked file (an excluded one would read as
deleted and mark the version -dirty), and the VERSION build arg loses
its "unknown" default, so script/version derives the version inside the
build. A VERSION build arg still takes precedence.

The builder stage installs git and fails when its context carries .git
and the version still comes out "unknown".

Model: opus-5-5

.dockerignore

@@ -1,14 +1,15 @@
+# .git is deliberately NOT excluded: the build derives the version it stamps
+# into the binary from it (script/version). Nor is any tracked file: git in
+# the build would see it as deleted and mark the version -dirty. Only
+# untracked files belong here.
+#
 # .ci-fingerprint is deliberately NOT excluded: it is the CI cache barrier
 # that keeps the check stages from replaying a cached pass. See the lint
 # stage of the Dockerfile.
-.git/
 bin/
 # Extracted from 3p/ by `make assets` inside the build; a host copy is not
 # needed. The tarball in 3p/ must stay in the context.
 static/js/alpine.min.js
-*.md
-LICENSE
-.editorconfig
 .env
 .env.*
 *.db

.gitea/workflows/check.yml

@@ -28,12 +28,11 @@ jobs:
         run: script/ci-mark-superseded
 
       - name: Fingerprint the build context
-        # `.dockerignore` keeps docs out of the build context, so a docs-only
+        # Every commit that changes more than docs writes a new fingerprint
-        # commit legitimately replays the whole image from cache and stays
+        # into the context, which invalidates the `COPY . .` layer of both
-        # cheap. Every other commit writes a new fingerprint into the context,
+        # check stages: a commit that was never linted, formatted-checked,
-        # which invalidates the `COPY . .` layer of both check stages: a
+        # tested and built cannot report success from cache. Docs-only
-        # commit that was never linted, formatted-checked, tested and built
+        # commits rebuild too, since the context also carries `.git`.
-        # cannot report success from cache.
         run: |
           set -eu
           fp="$(git log -1 --format=%H -- . ':!*.md' ':!LICENSE' ':!.editorconfig')"

Dockerfile

@@ -38,8 +38,8 @@ FROM golang:1.26.1-bookworm@sha256:4465644228bc2857a954b092167e12aa59c006a349228
 COPY --from=lint /src/go.sum /dev/null
 
 # jq is a runtime dependency of script/ci-mark-superseded, which the test
-# suite executes.
+# suite executes. git is what script/version derives the version with.
-RUN apt-get update && apt-get install -y --no-install-recommends make curl ca-certificates jq && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y --no-install-recommends make curl ca-certificates jq git && rm -rf /var/lib/apt/lists/*
 
 WORKDIR /build
 
@@ -55,14 +55,22 @@ COPY . .
 # from its tarball in 3p/.
 RUN make test
 
-# Version stamped into the binary. .dockerignore excludes .git/, so
+# Version stamped into the binary: the VERSION build arg when one is
-# nothing in this stage can derive it: script/docker resolves it on the
+# given, otherwise what script/version derives from the .git the build
-# host and passes it in. The default is what a bare `docker build .`
+# context carries, so any `docker build .` of a clone stamps its commit.
-# with no --build-arg gets, and it names no tag the tree may not be at.
+# With neither, as from a source tarball, it is "unknown".
 #
 # Declared here, below the test step, so a changed version does not
 # invalidate its cached layer.
-ARG VERSION=unknown
+ARG VERSION
+
+# A context that carries .git must not stamp "unknown": that means git is
+# missing here or refused to read the checkout, and the image could not be
+# traced back to its commit.
+RUN if [ -d .git ] && [ "$(make version VERSION="$VERSION")" = unknown ]; then \
+        echo "version is unknown although the build context carries .git" >&2; \
+        exit 1; \
+    fi
 
 RUN make build VERSION="$VERSION"
 

Makefile

@@ -4,12 +4,12 @@
 .DEFAULT_GOAL := check
 
 # Version stamped into the binary. Derived from git by script/version;
-# override it (`make build VERSION=v1.2.3`) where git metadata is
+# override it (`make build VERSION=v1.2.3`) to stamp a given value, which is
-# unavailable, which is how the Dockerfile passes its build arg in.
+# how the Dockerfile passes its build arg in.
 VERSION ?= $(shell script/version)
 
-# An empty override (`make build VERSION=`, or a `--build-arg VERSION=`
+# An empty override (`make build VERSION=`, or the Dockerfile's `make build
-# landing on the Dockerfile's `make build VERSION="$VERSION"`) means unset,
+# VERSION="$VERSION"` when no VERSION build arg was given) means unset,
 # exactly as it does in script/version -- stamping "" would leave the binary
 # reporting no version and the footer back on its "dev" fallback. `override`
 # is required: a plain assignment loses to the command-line definition it

README.md

@@ -7,7 +7,7 @@ services, durably stores them, and delivers them to configured targets
 with retry support, logging, and observability. Category: infrastructure
 / web service. License: MIT.
 
-Each entrypoint is a version 4 UUID served at `/h/{uuid}`, and
+Each entrypoint is a version 4 UUID served at `/webhook/{uuid}`, and
 that UUID is the entrypoint's only credential. webhooker does not use
 shared secrets, HMAC signatures or token headers on the receiver, and
 will not add them — read
@@ -142,7 +142,7 @@ TTY detection, and security headers are always applied.
 | `RETENTION_SWEEP_INTERVAL` | How often the retention reaper and archive sweeper run (Go duration, must be positive) | `1h` |
 | `SESSION_IDLE_TIMEOUT`  | Idle session timeout (Go duration)  | `24h`    |
 | `RECEIVER_RATE_LIMIT`   | Receiver requests/minute per IP per entrypoint (10x that per IP across the route) | `120` |
-| `TRUSTED_PROXIES`       | CIDRs whose forwarded headers are trusted. A set value replaces the default. If any client can reach webhooker, or the proxy in front of it, from an RFC 1918 source address, set it to the proxy's address alone. See [Trusted proxies](#trusted-proxies) | `10.0.0.0/8,172.16.0.0/12,192.168.0.0/16` (RFC 1918) |
+| `TRUSTED_PROXIES`       | CIDRs whose forwarded headers are trusted (unset: all clients behind a proxy share one rate-limit bucket; a correct login password is never throttled either way) | `""` (none) |
 | `ALLOWED_EGRESS_CIDRS`  | CIDRs that delivery targets may reach despite the SSRF blocklist. Read [Allowing egress to your own network](#allowing-egress-to-your-own-network) before setting it | `""` (none) |
 
 #### Allowing egress to your own network
@@ -157,21 +157,6 @@ public cloud metadata addresses: currently only `168.63.129.16`, Azure's
 WireServer, which serves an Azure VM its credentials. Because it is a
 public address, listing it in `ALLOWED_EGRESS_CIDRS` reopens it.
 
-That is all the default blocklist covers: the IPv4 private and reserved
-ranges; of IPv6, only loopback (`::1`), unique local addresses
-(`fc00::/7`) and link-local addresses (`fe80::/10`); and certain public
-addresses. A public address belongs on the default blocklist only if it
-hands credentials, user data or bootstrap material to whatever can reach
-it, without the caller presenting anything. A provider's other public
-addresses are not refused. IBM Cloud, for example, serves its package
-mirrors, time servers and object storage on `161.26.0.0/16`, and the
-private endpoints of its own cloud services on `166.8.0.0/14`. Neither
-range hands out credentials that way: the token service among those
-endpoints issues a token only in exchange for something the caller
-presents, such as an API key. Reaching these services can be a
-legitimate delivery, and every cloud has some, so a partial list would
-promise coverage it does not give.
-
 That default is also inconvenient for the thing webhooker is mostly
 for: taking a public webhook and forwarding it to something on your own
 network. A container on the same Docker network, a box on `10.x`, a
@@ -389,37 +374,41 @@ unlocked.
 `TRUSTED_PROXIES` is a comma-separated list of CIDR blocks (a bare
 address such as `192.168.1.7` is accepted and treated as a single
 host), for example `192.168.1.7, 2001:db8::5`. It decides whose
-`X-Forwarded-For` header the rate limiters believe, so it should cover
+`X-Forwarded-For` header the rate limiters believe, so it should name
-the addresses of your reverse proxies.
+the addresses of your reverse proxies and nothing else.
 
 `X-Forwarded-For` is honoured **only** when the connecting peer is
 inside one of these blocks; for every other peer the client identity is
-the connection's own address and the header is ignored. Unset (or
+the connection's own address and the header is ignored. The default is
-empty), the list is the RFC 1918 private ranges: `10.0.0.0/8`,
+the empty list, which trusts nobody — anything else would let any
-`172.16.0.0/12` and `192.168.0.0/16`. A set value replaces the default
+client pick its own rate limit bucket, minting a fresh one per request
-entirely. A set but unparseable value aborts startup.
+or draining someone else's. Set it to the address of your reverse
+proxy, and to nothing wider. A set but unparseable value aborts
+startup.
 
-If any client can reach webhooker, or the proxy in front of it, from an
+That default is safe against forged headers, but leaving it unset in
-RFC 1918 source address (directly, or through anything that can
+production has a cost you must know about. Production runs behind a
-rewrite source addresses, such as NAT or a published container port),
+TLS-terminating reverse proxy, so with `TRUSTED_PROXIES` unset every
-set `TRUSTED_PROXIES` to the proxy's address alone, or every rate
+request keys on the proxy's own address and all clients share a single
-limit, the webhook receiver's included, can be bypassed by those
+bucket per limit. The receiver limits become service-wide ceilings,
-clients. The address to set is the `remoteIP` field of the
+and the login endpoint's failure counting collapses onto one key, so a
-`http request` log line for a request that came through the proxy.
+stranger's wrong passwords throttle every other client's wrong
-
+passwords.
-Behind a proxy the list does not cover, every request keys on the
-proxy's own address and all clients share a single bucket per limit.
-The receiver limits become service-wide ceilings, and the login
-endpoint's failure counting collapses onto one key, so a stranger's
-wrong passwords throttle every other client's wrong passwords. Set
-`TRUSTED_PROXIES` to that proxy's address to restore per-client
-buckets.
 
 What it cannot do is lock the operator out. The login endpoint
 verifies credentials **before** it consults any limit and charges only
 failures, so a correct password is never throttled no matter how full
 the bucket is. See [Rate Limiting](#rate-limiting).
 
+The remedy is to set `TRUSTED_PROXIES` to your reverse proxy's
+address, which restores per-client buckets. webhooker logs a warning
+at startup whenever `TRUSTED_PROXIES` is empty, in every environment,
+because behind a proxy every client shares one bucket in `dev` and
+`prod` alike. The warning is informational when nothing proxies to the
+process: with no proxy in front, the peer address is the client's own
+and the buckets are already per-client. See
+[Rate Limiting](#rate-limiting) for what each limit shares.
+
 `X-Real-IP` and `True-Client-IP` are **never** read, from any peer.
 Reverse proxies append to `X-Forwarded-For` but forward other client
 headers verbatim, so a single-valued header is client-controlled even
@@ -435,10 +424,20 @@ instead, since past such an entry the chain is not the shape assumed
 here. The peer address is likewise used when the header is absent or
 every hop in it is a trusted proxy.
 
-Your proxy must therefore **append** the peer address to
+Two operator requirements follow:
-`X-Forwarded-For` (nginx `$proxy_add_x_forwarded_for`, HAProxy
+
-`option forwardfor`, Caddy and AWS ALB by default), and must append a
+- Your proxy must **append** the peer address to `X-Forwarded-For`
-bare address with no port.
+  (nginx `$proxy_add_x_forwarded_for`, HAProxy `option forwardfor`,
+  Caddy and AWS ALB by default), and must append a bare address with
+  no port.
+- List proxy hosts **only**. Any address inside `TRUSTED_PROXIES`
+  chooses its own rate-limit key: its `X-Forwarded-For` is walked, so
+  it can name a different address on every request to get a fresh
+  bucket each time, or name another client's address to drain that
+  client's bucket. Never list a block that also covers clients — a
+  broad `10.0.0.0/8` on a network where clients live in the same range
+  makes all three limits, including the unauthenticated webhook
+  receiver, silently bypassable by every client in the block.
 
 #### Sessions
 
@@ -737,15 +736,10 @@ repository's `Dockerfile` and runs it. The app needs:
 - **Volume:** one host directory mounted at `/var/lib/webhooker`.
 - **Environment variables:**
     - `WEBHOOKER_ENVIRONMENT=prod`
-    - `TRUSTED_PROXIES`: unset, it is the RFC 1918 ranges. Set it to
+    - `TRUSTED_PROXIES`: your reverse proxy's address on that Docker
-      your reverse proxy's address alone if that address is outside
+      network. The `remoteIP` field of the `http request` log line for a
-      those ranges, or if any client can reach webhooker, or the proxy,
+      request that came through the proxy shows it; the health check's
-      from an RFC 1918 source address (directly, or through anything
+      own lines show `::1`. See [Trusted proxies](#trusted-proxies).
-      that can rewrite source addresses, such as NAT or a published
-      container port). The `remoteIP` field of the `http request` log
-      line for a request that came through the proxy shows that
-      address; the health check's own lines show `::1`. See
-      [Trusted proxies](#trusted-proxies).
     - Leave `BIND_ADDRESS` and `DATA_DIR` unset: the image sets
       `BIND_ADDRESS` to `0.0.0.0`, and `DATA_DIR` defaults to
       `/var/lib/webhooker`.
@@ -808,16 +802,12 @@ reports.
    behind a proxy means the `X-Forwarded-Proto` header. The block below
    sets it; without it every request is read as plaintext and cookies
    ship without `Secure`. See [Configuration](#configuration).
-3. **Make sure `TRUSTED_PROXIES` covers the proxy's address.** For a
+3. **Set `TRUSTED_PROXIES` to the proxy's address.** Unset, every rate
-   proxy it does not cover, every rate limiter keys on the proxy, so
+   limiter keys on the connecting peer, which behind a proxy is the
-   all clients share one bucket per limit. Unset, the list is the RFC
+   proxy on every request: all clients collapse into one global bucket
-   1918 ranges, which do not cover a proxy that reaches the binary
+   per limit and the receiver's per-IP limits become service-wide
-   itself over loopback (the binary bound to `127.0.0.1`). With the
+   ceilings. See [Trusted proxies](#trusted-proxies). List the proxy
-   image, the address to check is the `remoteIP` field of the
+   and nothing else.
-   `http request` log line for a request that came through the proxy.
-   If any client can reach webhooker, or the proxy, from an RFC 1918
-   source address, set the list to the proxy's address alone. See
-   [Trusted proxies](#trusted-proxies).
 4. **Send `Host` as `$http_host`, not `$host`.** `$host` strips the
    port. webhooker's Origin/Referer check compares against the host it
    was given, so on any port other than 443 `$host` makes every form
@@ -1133,13 +1123,21 @@ build itself.
 | Uncommitted changes | the above with a `-dirty` suffix |
 | No git metadata | `unknown` |
 
-`unknown` is what a source tarball or a `docker build .` with no
+The image derives it the same way, from the `.git` that the build
-`--build-arg VERSION=...` reports. `.dockerignore` excludes `.git/`, so
+context carries, so any `docker build .` of a clone stamps the commit it
-the build context carries no git metadata and the image cannot derive
+was built from; a shallow clone of one branch has no tags and stamps the
-the version itself: `script/docker` (and so `make docker`) resolves it
+short SHA. `.dockerignore` must therefore leave out neither `.git` nor
-on the host and passes it in as the `VERSION` build arg. A build that
+any tracked file, which git in the build would see as deleted, marking
-reports `unknown` is a build nobody told what it was; it is not a
+the version `-dirty`. A `VERSION` build arg (`--build-arg VERSION=...`)
-failure, but it cannot be traced back to a commit.
+takes precedence; `script/docker` (and so `make docker`) passes the one
+`script/version` resolves on the host. The image build fails if its
+context carries `.git` and the version still comes out `unknown`, which
+means git in the build could not read the checkout.
+
+`unknown` is what a source tarball, or a `docker build` with no `.git`
+in its context and no `VERSION` build arg, reports. A build that reports
+`unknown` is a build nobody told what it was; it is not a failure, but
+it cannot be traced back to a commit.
 
 `make version` prints what the current checkout would stamp, and
 `make build VERSION=v1.2.3` overrides it. An empty override — from
@@ -1188,7 +1186,7 @@ backups at rest and restrict who can read them.
 
 **The entrypoint UUID is the credential, and it is the only one.**
 webhooker mints a version 4 UUID per entrypoint and serves it at
-`/h/{uuid}`. Possession of that URL is the authentication:
+`/webhook/{uuid}`. Possession of that URL is the authentication:
 anyone who holds it can submit events to the entrypoint, and the
 receiver verifies nothing else about the sender.
 
@@ -1370,11 +1368,10 @@ It uses:
 - **[go-chi/httprate](https://github.com/go-chi/httprate)** for
   sliding-window rate limiting of the password-change and webhook
   receiver endpoints. The bucket is per client IP only when
-  `TRUSTED_PROXIES` covers the reverse proxy (by default it covers the
+  `TRUSTED_PROXIES` names the reverse proxy; unset, every client
-  RFC 1918 private ranges); otherwise every client behind that proxy
+  behind that proxy shares one bucket per limit. The login endpoint
-  shares one bucket per limit. The login endpoint counts failed
+  counts failed attempts itself instead, so that a correct password is
-  attempts itself instead, so that a correct password is never
+  never throttled (see [Rate Limiting](#rate-limiting))
-  throttled (see [Rate Limiting](#rate-limiting))
 - **[Prometheus](https://prometheus.io)** for metrics, served at
   `/metrics` behind basic auth
 - **[Sentry](https://sentry.io)** for optional error reporting
@@ -1523,7 +1520,7 @@ the full request and creates an Event.
 | -------------- | ------- | ----------- |
 | `id`           | UUID    | Primary key |
 | `webhook_id`   | UUID    | Foreign key → Webhook |
-| `path`         | string  | Unique bare UUID, generated at creation. The `/h/` prefix is route only and is not stored: the receiver matches this column against the raw `{uuid}` path segment. It is also the entrypoint's credential; see [The entrypoint URL is the authentication secret](#the-entrypoint-url-is-the-authentication-secret) |
+| `path`         | string  | Unique bare UUID, generated at creation. The `/webhook/` prefix is route only and is not stored: the receiver matches this column against the raw `{uuid}` path segment. It is also the entrypoint's credential; see [The entrypoint URL is the authentication secret](#the-entrypoint-url-is-the-authentication-secret) |
 | `description`  | string  | Optional description |
 | `active`       | boolean | Whether this entrypoint accepts events (default: true) |
 
@@ -1905,7 +1902,7 @@ runtime, though CGO is required at build time due to the transitive
 ```
 External Service
        │
-       │  POST /h/{uuid}
+       │  POST /webhook/{uuid}
        ▼
 ┌─────────────┐     ┌──────────────┐     ┌──────────────┐
 │  chi Router │────►│  Middleware   │────►│   Webhook    │
@@ -2131,7 +2128,7 @@ The middleware records three more on the same registry:
 Two of those labels are written once per request from bytes the client
 chose, so both are bounded to something this service registers:
 
-- `handler` is the chi route pattern — `/h/{uuid}`, never the
+- `handler` is the chi route pattern — `/webhook/{uuid}`, never the
   concrete path. A request matching no route carries `(unmatched)`,
   and no entrypoint UUID ever reaches a label.
 - `method` is the request method when the router can route it, and
@@ -2161,7 +2158,7 @@ unpredictable rates, and blanket limits shared with other routes would
 cause legitimate deliveries to be dropped.
 
 The receiver instead has its own dedicated abuse limit, scoped to the
-`/h/{uuid}` route only and keyed per client IP per request path
+`/webhook/{uuid}` route only and keyed per client IP per request path
 (`httprate.KeyByEndpoint`): one misbehaving sender is throttled without
 affecting other senders of the same entrypoint or the same sender's
 other entrypoints. Keying on the path rather than on the entrypoint
@@ -2198,7 +2195,7 @@ log spends. The access log is bounded by neither limit: every request
 is recorded once at `INFO`, served or rejected alike.
 
 What the access log does bound is the _content_ of those lines. A 3xx
-or 4xx response logs the chi route pattern — `/h/{uuid}`,
+or 4xx response logs the chi route pattern — `/webhook/{uuid}`,
 `/user/{username}//`, or the literal `(unmatched)` when the request hit
 no route at all — in place of the concrete URL. Those are the outcomes
 an unauthenticated client can drive for free: 404 and 429 on any
@@ -2232,12 +2229,12 @@ reduces the headers to a fixed allowlist — `Accept`, `Content-Length`,
 
 The same hook rewrites the request URL. The SDK builds it as
 `scheme://host/path` from the concrete path, which on the receiver
-route is `/h/<uuid>` in full — and that UUID is a write
+route is `/webhook/<uuid>` in full — and that UUID is a write
 capability, not an identifier: anyone holding it can post events this
 service accepts and its targets then deliver. A tracker has its own
 retention, access control and deletion policy, so the rule the access
 log follows above does not carry across that boundary. What is sent is
-the chi route pattern instead: `http://host/h/{uuid}`.
+the chi route pattern instead: `http://host/webhook/{uuid}`.
 
 The scheme and the host are kept, and everything else in the URL is
 discarded rather than edited, so a future SDK version that starts
@@ -2281,8 +2278,8 @@ fallback is never the concrete path. The path becomes the literal
 rewrite cannot parse into a scheme is withheld whole. A transaction
 event additionally carries the SDK's own `METHOD /path` name, built
 from the concrete path as well; it is rewritten on the same terms, to
-`POST /h/{uuid}` where the pattern is known and `POST /(redacted)`
+`POST /webhook/{uuid}` where the pattern is known and `POST
-where it is not.
+/(redacted)` where it is not.
 
 The headers are an allowlist for the same reason the rules above are
 unconditional: the SDK's own filter removes four names and passes
@@ -2417,7 +2414,7 @@ logger printed the fully interpolated SQL — parameters and all — to
 standard output on every statement that returned an error, including a
 plain record-not-found, at a level no operator setting reached. Two of
 this service's lookups miss by design on unauthenticated routes: the
-entrypoint lookup behind `/h/{uuid}` and the user lookup behind
+entrypoint lookup behind `/webhook/{uuid}` and the user lookup behind
 the login form, whose path segment and submitted username the client
 picks outright. Every
 `gorm.Open` in the service now installs the adapter in
@@ -2545,44 +2542,47 @@ the tree is checked out: four checkouts have reported 3,959, 3,961,
 client-supplied field was cut, and that the shipped chain's stack
 arrived uncut — never the numbers.
 
-Every limiter here — receiver, login, password change, delivery replay
+Every limiter here — receiver, login, and password change — identifies
-and event resubmit — identifies the client the same way, through one
+the client the same way, through one shared key function: the
-shared key function: the connection's own address, unless the peer is
+connection's own address, unless the peer is listed in
-inside `TRUSTED_PROXIES`, in which case the forwarded client address is
+`TRUSTED_PROXIES`, in which case the forwarded client address is used
-used instead. That address becomes a bucket by family: IPv4 keys on
+instead. That address becomes a bucket by family: IPv4 keys on the full
-the full address, IPv6 on its `/64` prefix. A routed `/64` is the normal
+address, IPv6 on its `/64` prefix. A routed `/64` is the normal
 residential and mobile IPv6 allocation, so keying IPv6 per address would
 let one subscriber rotate source addresses and mint a fresh bucket per
 request, evading these limits at the network layer without spoofing
 anything; the cost is that distinct clients inside one `/64` share a
 bucket. IPv4-mapped addresses (`::ffff:1.2.3.4`) key as the IPv4 address
-they carry. See [Trusted proxies](#trusted-proxies). When that variable
+they carry. See [Trusted proxies](#trusted-proxies). Deployed without that
-does not cover the reverse proxy, a client behind it shares one bucket
+variable set, a client behind a reverse proxy shares one bucket with
-with every other client behind the same proxy. Set `TRUSTED_PROXIES` to
+every other client behind the same proxy. Set `TRUSTED_PROXIES` to the
-the proxy's address to get per-client limits back. What the shared bucket
+proxy's address to get per-client limits back. What the shared bucket
 costs is not the same for every limiter, and the two cases pull in
 opposite directions:
 
 - For the **receiver** limits it costs throughput, which is the safe
   direction to be wrong in: sharing can only make a limit bind sooner,
   never let a sender past it. It matters more for the aggregate limit
-  than for the per-entrypoint one: with every request keyed on the
+  than for the per-entrypoint one: with `TRUSTED_PROXIES` unset behind
-  proxy, the aggregate limit becomes a service-wide ceiling of 1200
+  the reverse proxy a production deployment is required to run behind,
-  requests per minute across all senders and all entrypoints, where the
+  every request keys on the proxy, so the aggregate limit becomes a
-  per-entrypoint limit's capacity still grows with the number of
+  service-wide ceiling of 1200 requests per minute across all senders
-  entrypoints.
+  and all entrypoints, where the per-entrypoint limit's capacity still
+  grows with the number of entrypoints. Any deployment with more than a
+  handful of busy entrypoints must set `TRUSTED_PROXIES`.
 - For the **login and password-change** limits it costs precision, not
   availability. Login failures from every client land in one counter,
   so a stranger's wrong passwords make the operator's own wrong
   passwords answer `429` sooner; the operator's _correct_ password is
-  never affected, because it is never counted.
+  never affected, because it is never counted. Production deployments
+  should still set `TRUSTED_PROXIES`; webhooker warns at startup
+  whenever it is empty, in any environment.
 
 #### The login endpoint
 
 The login `POST` is the one endpoint with no pre-emptive limiter in
 front of it, and that is deliberate. A limiter that spends budget on
-arrival is a lockout wherever clients share one bucket, as they do
+arrival is a lockout in this deployment shape: sharing one bucket, a
-behind a reverse proxy that `TRUSTED_PROXIES` does not cover: a
 stranger sending five POSTs a minute — about 0.08 requests per second,
 from anywhere — keeps it permanently full, and the operator has no
 second administrative path. So the handler inverts the order:
@@ -2679,10 +2679,8 @@ re-fills both verification slots on its first two requests. The
 remedies are to block the source at the reverse proxy, or to
 rate-limit `POST /pages/login` there — the one place a limit can be
 applied without reintroducing the lockout, because the proxy sees the
-real client address. `TRUSTED_PROXIES` does not stop the saturation.
+real client address. Setting `TRUSTED_PROXIES` does not stop the
-The flood's source is in the proxy's access log: webhooker's own logs
+saturation, but it makes the source visible in the failure logs.
-record the proxy's address, not the client's (see
-[Deployment behind a reverse proxy](#deployment-behind-a-reverse-proxy)).
 
 Finer-grained per-webhook rate limits (configured in the web UI and
 enforced in the webhook handler) can layer on top of this env-level
@@ -2694,10 +2692,10 @@ abuse limit later; they are tracked as future work.
 
 | Method | Path                        | Description |
 | ------ | --------------------------- | ----------- |
-| `GET`  | `/`                         | Root redirect, 303 (authenticated → `/hooks`, unauthenticated → `/pages/login`) |
+| `GET`  | `/`                         | Root redirect, 303 (authenticated → `/sources`, unauthenticated → `/pages/login`) |
 | `GET`  | `/.well-known/healthcheck`  | Health check (JSON: `status`, `now`, `uptimeSeconds`, `uptimeHuman`, `version`, `appname`, `maintenanceMode`) |
 | `GET`, `HEAD` | `/s/*`              | Static file serving (embedded CSS, JS). `GET` and `HEAD` only — `POST`, `PUT`, `PATCH`, `DELETE`, `OPTIONS`, `TRACE` and `CONNECT` are answered `405 Method Not Allowed` with `Allow: GET, HEAD`. Any other method (such as `PROPFIND`) is refused by chi before it reaches this route, and gets `405` without an `Allow` header. Pinned by `TestStaticServesOnlyGetAndHead` |
-| `POST` | `/h/{uuid}`                 | Webhook receiver endpoint. `POST` only — every other method is answered `405 Method Not Allowed` with `Allow: POST`. Rate limited (see [Rate Limiting](#rate-limiting)) |
+| `POST` | `/webhook/{uuid}`           | Webhook receiver endpoint. `POST` only — every other method is answered `405 Method Not Allowed` with `Allow: POST`. Rate limited (see [Rate Limiting](#rate-limiting)) |
 
 #### Authentication Endpoints
 
@@ -2713,25 +2711,25 @@ abuse limit later; they are tracked as future work.
 | ------ | ------------------------ | ----------- |
 | `GET`  | `/user/{username}`       | User profile page |
 | `POST` | `/user/{username}/password` | Change the user's password (5 per minute per bucket, then `429`; `503` if no verification slot frees up within 5s, or immediately if 16 requests are already queued for one) |
-| `GET`  | `/hooks`                 | List user's webhooks |
+| `GET`  | `/sources`               | List user's webhooks |
-| `GET`  | `/hooks/new`             | Create webhook form |
+| `GET`  | `/sources/new`           | Create webhook form |
-| `POST` | `/hooks/new`             | Create webhook submission |
+| `POST` | `/sources/new`           | Create webhook submission |
-| `GET`  | `/hook/{id}`             | Webhook detail view |
+| `GET`  | `/source/{id}`           | Webhook detail view |
-| `GET`  | `/hook/{id}/edit`        | Edit webhook form |
+| `GET`  | `/source/{id}/edit`      | Edit webhook form |
-| `POST` | `/hook/{id}/edit`        | Edit webhook submission |
+| `POST` | `/source/{id}/edit`      | Edit webhook submission |
-| `POST` | `/hook/{id}/delete`      | Delete webhook |
+| `POST` | `/source/{id}/delete`    | Delete webhook |
-| `GET`  | `/hook/{id}/events`      | Full Event Log |
+| `GET`  | `/source/{id}/logs`      | Webhook event logs |
-| `GET`  | `/hook/{id}/events/{eventID}/body` | Download an event's full stored body. The log page renders each body only up to its cap, so this is the only route that serves a whole one; it is offered wherever a body is shown truncated |
+| `GET`  | `/source/{id}/logs/{eventID}/body` | Download an event's full stored body. The log page renders each body only up to its cap, so this is the only route that serves a whole one; it is offered wherever a body is shown truncated |
-| `POST` | `/hook/{id}/deliveries/{deliveryID}/replay` | Replay a finished delivery: creates a new delivery for the same event against the target's current configuration (30 per minute per bucket, then `429`) |
+| `POST` | `/source/{id}/deliveries/{deliveryID}/replay` | Replay a finished delivery: creates a new delivery for the same event against the target's current configuration (30 per minute per bucket, then `429`) |
-| `POST` | `/hook/{id}/events/{eventID}/resubmit` | Resubmit a stored event: creates a new event copying it and fans that out to every currently active target (30 per minute per bucket, then `429`) |
+| `POST` | `/source/{id}/events/{eventID}/resubmit` | Resubmit a stored event: creates a new event copying it and fans that out to every currently active target (30 per minute per bucket, then `429`) |
-| `POST` | `/hook/{id}/entrypoints` | Add entrypoint to webhook |
+| `POST` | `/source/{id}/entrypoints` | Add entrypoint to webhook |
-| `POST` | `/hook/{id}/entrypoints/{entrypointID}/delete` | Delete an entrypoint |
+| `POST` | `/source/{id}/entrypoints/{entrypointID}/delete` | Delete an entrypoint |
-| `POST` | `/hook/{id}/entrypoints/{entrypointID}/toggle` | Enable or disable an entrypoint |
+| `POST` | `/source/{id}/entrypoints/{entrypointID}/toggle` | Enable or disable an entrypoint |
-| `POST` | `/hook/{id}/targets`     | Add target to webhook |
+| `POST` | `/source/{id}/targets`   | Add target to webhook |
-| `GET`  | `/hook/{id}/targets/{targetID}/edit` | Edit target form. The one page that renders a target's destination URL and header values in full, rather than masked |
+| `GET`  | `/source/{id}/targets/{targetID}/edit` | Edit target form. The one page that renders a target's destination URL and header values in full, rather than masked |
-| `POST` | `/hook/{id}/targets/{targetID}/edit` | Edit target submission |
+| `POST` | `/source/{id}/targets/{targetID}/edit` | Edit target submission |
-| `POST` | `/hook/{id}/targets/{targetID}/delete` | Delete a target |
+| `POST` | `/source/{id}/targets/{targetID}/delete` | Delete a target |
-| `POST` | `/hook/{id}/targets/{targetID}/toggle` | Enable or disable a target |
+| `POST` | `/source/{id}/targets/{targetID}/toggle` | Enable or disable a target |
 
 #### Infrastructure Endpoints
 
@@ -2932,8 +2930,8 @@ local record instead of nothing. What that placement gives up is
 recovery of a panic in the six entries above it, none of which does
 more than set a header or start a timer.
 
-Additionally, form endpoints (`/pages`, `/user/*`, `/hooks`,
+Additionally, form endpoints (`/pages`, `/user/*`, `/sources`,
-`/hook/*`) apply a **MaxBodySize** middleware that limits
+`/source/*`) apply a **MaxBodySize** middleware that limits
 POST/PUT/PATCH request bodies to 1 MB. It is registered ahead of the
 CSRF middleware in every one of those route groups, because
 gorilla/csrf parses the form; if the cap were installed after it, form
@@ -2957,7 +2955,7 @@ Those same four route groups then apply **CSRF** and **NoCache**
 `/pages` applies **RequireAuth**. The rate limiters are per-route
 rather than global: **PasswordChangeRateLimit** on
 `/user/{username}/password` and **ReceiverRateLimit** on
-`/h/{uuid}`. There is deliberately none on `/pages/login` — that
+`/webhook/{uuid}`. There is deliberately none on `/pages/login` — that
 endpoint counts failures inside the handler, after the credential
 check, see [The login endpoint](#the-login-endpoint).
 
@@ -2998,8 +2996,8 @@ check, see [The login endpoint](#the-login-endpoint).
   by middleware that runs before CSRF parses the form
 - **CSRF protection** via [gorilla/csrf](https://github.com/gorilla/csrf)
   on all state-changing forms (cookie-based double-submit tokens with
-  HMAC authentication). Applied to `/pages`, `/hooks`, `/hook`, and
+  HMAC authentication). Applied to `/pages`, `/sources`, `/source`, and
-  `/user` routes. Excluded from `/h` (inbound webhook POSTs) and
+  `/user` routes. Excluded from `/webhook` (inbound webhook POSTs) and
   `/api` (stateless API). The middleware detects TLS per-request through
   `internal/reqtls.IsTLS` — the same predicate the session cookie uses —
   to set appropriate cookie security flags and Origin/Referer validation
@@ -3040,9 +3038,10 @@ check, see [The login endpoint](#the-login-endpoint).
   It runs behind session auth, so only a client already holding a
   valid session reaches it, and an operator throttled out of changing
   a password can still log in. The bucket is per client IP only when
-  `TRUSTED_PROXIES` covers the reverse proxy; otherwise every client
+  `TRUSTED_PROXIES` names the reverse proxy; unset, every client
   shares one bucket, which costs precision rather than availability
-  (see [Rate Limiting](#rate-limiting))
+  (see [Rate Limiting](#rate-limiting)). webhooker warns at startup
+  whenever `TRUSTED_PROXIES` is empty
 - Prometheus metrics behind basic auth
 - Static assets embedded in binary (no filesystem access needed at
   runtime)
@@ -3174,8 +3173,9 @@ version is fixed independently of the compiler's:
    rebuilds the binary with `CGO_ENABLED=1` and static linking so it
    runs on musl. Both builds go through `make build`, the relink adding
    its `-extldflags` via `GO_LDFLAGS`, so neither can drop the `-X` that
-   stamps the version. The version arrives as the `VERSION` build arg,
+   stamps the version. The version is the `VERSION` build arg if one is
-   since the context has no `.git` (see
+   given, otherwise derived from the `.git` in the context, and the
+   stage fails if a context with `.git` would stamp `unknown` (see
    [Version stamping](#version-stamping)).
 3. **Runtime stage** (`alpine:3.21`) — copies the static binary and
    `deploy/docker-entrypoint.sh`, creates the `/var/lib/webhooker`
@@ -3207,16 +3207,17 @@ A layer cache lets `docker build .` exit 0 in seconds with the lint and
 test stages replayed rather than executed, which would make a green
 check meaningless. The `check` workflow therefore writes
 `.ci-fingerprint` into the build context before building. Its value is
-the hash of the last commit that touched the build context, so:
+the hash of the last commit that touched anything other than `*.md`,
+`LICENSE` and `.editorconfig`, so:
 
 - Any commit that changes code (including a squash merge whose tree
   matches an already-built branch) gets a new fingerprint, invalidates
   the `COPY . .` layer of both check stages, and really runs
   `make fmt-check`, `golangci-lint`, `make test`, and `make build`. A
   run that reports success ran them.
-- A docs-only commit leaves the fingerprint unchanged — `.dockerignore`
+- A docs-only commit leaves the fingerprint unchanged, but it still
-  excludes `*.md`, `LICENSE` and `.editorconfig` from the context
+  rebuilds in full: the context also carries `.git`, which changes with
-  anyway — so the image replays from cache and costs seconds.
+  every commit (see [Version stamping](#version-stamping)).
 
 The module download layer sits above `COPY . .` and stays cached either
 way.

TODO.md

@@ -387,7 +387,7 @@ point of the branch.
 - 2026-03-05 security headers middleware, session regeneration on
   login, request body size limits (#41)
 - 2026-03-04 tests for delivery, middleware, and session packages
-  (#32); removed the build-architecture global (#31)
+  (#32); removed globals.Buildarch (#31)
 - 2026-03-04 1.0 MVP merge: Webhook/Entrypoint/Target rename, core
   delivery engine with bounded worker pool and circuit breaker,
   parallel fan-out, per-webhook event databases, management UI (#16)

internal/config/config.go

@@ -75,11 +75,6 @@ const (
 	// internet-exposed endpoint.
 	defaultReceiverRateLimit = 120
 
-	// defaultTrustedProxies is TRUSTED_PROXIES when it is unset: the
-	// RFC 1918 private ranges, which a reverse proxy reaching the
-	// process over a Docker network or a private LAN connects from.
-	defaultTrustedProxies = "10.0.0.0/8,172.16.0.0/12,192.168.0.0/16"
-
 	// maxPort is the highest valid TCP port number. The lower
 	// bound (at least 1) is enforced by envPositiveInt.
 	maxPort = 65535
@@ -177,14 +172,13 @@ type Config struct {
 
 	// TrustedProxies is the set of networks whose members are
 	// allowed to speak for the client with X-Forwarded-For, the
-	// only forwarded header read. Unless TRUSTED_PROXIES is set it
+	// only forwarded header read. It is empty unless
-	// is the RFC 1918 private ranges (defaultTrustedProxies); a set
+	// TRUSTED_PROXIES is set, and empty means no peer is
-	// value replaces them. If any client can reach the process, or
+	// trusted: forwarded headers are then ignored entirely and
-	// the proxy in front of it, from an RFC 1918 source address
+	// clients are identified by the connection's own address.
-	// (directly, or through anything that can rewrite source
+	// Members can choose their own rate-limit key, so this must
-	// addresses, such as NAT or a published container port), it
+	// name proxy hosts only, never a block that also covers
-	// must be set to the proxy's address alone, or every rate limit
+	// clients.
-	// can be bypassed by those clients.
 	TrustedProxies []netip.Prefix
 
 	// AllowedEgressCIDRs is the set of networks a delivery target
@@ -466,15 +460,14 @@ func parseCIDR(entry string) (netip.Prefix, error) {
 
 // envPrefixList returns the value of the named environment variable
 // parsed as a comma-separated list of CIDR blocks (bare addresses
-// allowed). An unset, empty, or blank value is read as defaultValue
+// allowed). An unset, empty, or blank value yields an empty list. A
-// instead. A set value containing an unparseable entry is a hard
+// set value containing an unparseable entry is a hard error naming
-// error naming the key and the bad entry, so startup fails loudly
+// the key and the bad entry, so startup fails loudly rather than
-// rather than silently running with a list the operator did not
+// silently running with a list the operator did not intend.
-// intend.
+func envPrefixList(key string) ([]netip.Prefix, error) {
-func envPrefixList(key, defaultValue string) ([]netip.Prefix, error) {
 	v := strings.TrimSpace(os.Getenv(key))
 	if v == "" {
-		v = defaultValue
+		return nil, nil
 	}
 
 	var prefixes []netip.Prefix
@@ -688,12 +681,12 @@ func loadFromEnv() (*Config, error) {
 		return nil, err
 	}
 
-	trustedProxies, err := envPrefixList("TRUSTED_PROXIES", defaultTrustedProxies)
+	trustedProxies, err := envPrefixList("TRUSTED_PROXIES")
 	if err != nil {
 		return nil, err
 	}
 
-	allowedEgressCIDRs, err := envPrefixList("ALLOWED_EGRESS_CIDRS", "")
+	allowedEgressCIDRs, err := envPrefixList("ALLOWED_EGRESS_CIDRS")
 	if err != nil {
 		return nil, err
 	}
@@ -767,6 +760,50 @@ func (c *Config) warnEgressAllowlist(log *slog.Logger) {
 	)
 }
 
+// warnSharedRateLimitBucket logs a startup warning whenever
+// TRUSTED_PROXIES is empty, in any environment.
+//
+// With no trusted proxies every rate limiter keys on the connecting
+// peer's address. Whether that is harmless or dangerous depends on
+// what is in front of the process, which this code cannot observe:
+// with nothing in front, the peer is the client and the limits are
+// per-client as intended; behind a reverse proxy the peer is the proxy
+// for every request, so all clients share one bucket per limiter.
+//
+// The login endpoint no longer spends budget on arrival — it verifies
+// credentials first and charges only failures — so a shared bucket
+// cannot deny the operator a correct password. What it does collapse
+// is the failure counting: one client's wrong passwords throttle
+// everyone else's wrong passwords, and the receiver's limits become
+// service-wide ceilings.
+//
+// The warning is deliberately not gated on WEBHOOKER_ENVIRONMENT:
+// behind a proxy every client shares one bucket in dev and prod alike.
+//
+// The default of trusting nobody is deliberate — trusting forwarded
+// headers from arbitrary peers lets any client choose its own bucket —
+// so this warns rather than failing startup or changing the key.
+func (c *Config) warnSharedRateLimitBucket(log *slog.Logger) {
+	if len(c.TrustedProxies) > 0 {
+		return
+	}
+
+	log.Warn(
+		"TRUSTED_PROXIES is empty: every rate limit keys on the "+
+			"connecting peer's address. With nothing proxying to "+
+			"this process that is the client itself and the limits "+
+			"are per-client as intended. Behind a reverse proxy the "+
+			"peer is the proxy on every request, so all clients "+
+			"share one bucket per limit: the receiver limits become "+
+			"service-wide ceilings, and one client's failed logins "+
+			"throttle every other client's failed logins — a "+
+			"correct password still gets in. If anything proxies to "+
+			"this process, set TRUSTED_PROXIES to its address.",
+		"environment", c.Environment,
+		"trustedProxies", len(c.TrustedProxies),
+	)
+}
+
 // New creates a Config by reading environment variables.
 //
 //nolint:revive // lc parameter is required by fx even if unused.
@@ -812,6 +849,7 @@ func New(lc fx.Lifecycle, params ConfigParams) (*Config, error) {
 		"hasMetricsAuth", s.MetricsAuthEnabled(),
 	)
 
+	s.warnSharedRateLimitBucket(log)
 	s.warnEgressAllowlist(log)
 
 	return s, nil

internal/config/config_test.go

@@ -551,11 +551,6 @@ func testReceiverRateLimitSuccess(
 }
 
 func TestTrustedProxies(t *testing.T) {
-	// Unset, the RFC 1918 private ranges are trusted, so a reverse
-	// proxy on a Docker network or a private LAN is covered without
-	// configuration.
-	defaultProxies := []string{cidrPrivateV4, "172.16.0.0/12", "192.168.0.0/16"}
-
 	tests := []struct {
 		name        string
 		set         bool
@@ -564,21 +559,18 @@ func TestTrustedProxies(t *testing.T) {
 		expected    []string
 	}{
 		{
+			// The default must be "trust nobody": an empty list
+			// means forwarded headers are ignored, never that
+			// every peer may speak for the client.
 			name:     caseUnsetUsesDefault,
 			set:      false,
-			expected: defaultProxies,
+			expected: []string{},
 		},
 		{
-			name:     "blank value uses default",
+			name:     "blank value trusts nothing",
 			set:      true,
 			value:    "  ",
-			expected: defaultProxies,
+			expected: []string{},
-		},
-		{
-			name:     "set value replaces the default entirely",
-			set:      true,
-			value:    "203.0.113.7",
-			expected: []string{"203.0.113.7/32"},
 		},
 		{
 			name:  caseValidValueParsed,
@@ -853,6 +845,101 @@ func TestEgressAllowlistWarning(t *testing.T) {
 	}
 }
 
+// TestSharedRateLimitBucketWarning covers the startup warning that
+// tells an operator a deployment behind a reverse proxy shares one
+// rate-limit bucket between every client, which turns the receiver
+// limits into service-wide ceilings and collapses login failure
+// counting. It must fire whenever TRUSTED_PROXIES is empty, in any
+// environment, because behind a proxy every client shares one bucket
+// in dev and prod alike. It stays quiet once proxies are named.
+func TestSharedRateLimitBucketWarning(t *testing.T) {
+	tests := []struct {
+		name           string
+		environment    string
+		trustedProxies string
+		expectWarning  bool
+	}{
+		{
+			name:          "prod without trusted proxies warns",
+			environment:   config.EnvironmentProd,
+			expectWarning: true,
+		},
+		{
+			name:           "prod with trusted proxies is quiet",
+			environment:    config.EnvironmentProd,
+			trustedProxies: cidrPrivateV4,
+			expectWarning:  false,
+		},
+		{
+			name:          "dev without trusted proxies warns",
+			environment:   config.EnvironmentDev,
+			expectWarning: true,
+		},
+		{
+			name:           "dev with trusted proxies is quiet",
+			environment:    config.EnvironmentDev,
+			trustedProxies: cidrPrivateV4,
+			expectWarning:  false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Cannot use t.Parallel() here because t.Setenv
+			// is incompatible with parallel subtests.
+			t.Setenv("WEBHOOKER_ENVIRONMENT", tt.environment)
+
+			if tt.trustedProxies == "" {
+				require.NoError(
+					t, os.Unsetenv("TRUSTED_PROXIES"),
+				)
+			} else {
+				t.Setenv("TRUSTED_PROXIES", tt.trustedProxies)
+			}
+
+			var buf bytes.Buffer
+
+			log := slog.New(slog.NewJSONHandler(
+				&buf, &slog.HandlerOptions{
+					Level: slog.LevelDebug,
+				},
+			))
+
+			require.NoError(
+				t,
+				config.WarnSharedRateLimitBucketForTest(log),
+			)
+
+			if !tt.expectWarning {
+				assert.Empty(t, buf.String())
+
+				return
+			}
+
+			logged := buf.String()
+
+			assert.Contains(t, logged, `"level":"WARN"`)
+			assert.Contains(t, logged, "TRUSTED_PROXIES")
+			assert.Contains(t, logged, "share one bucket")
+			assert.Contains(
+				t, logged, "throttle every other client's failed logins",
+			)
+			// The warning must not claim a lockout the login
+			// endpoint no longer permits: credentials are verified
+			// before any budget is spent.
+			assert.Contains(
+				t, logged, "a correct password still gets in",
+			)
+			// The text must stay accurate for a developer with
+			// nothing in front of the process, where an empty
+			// list costs nothing.
+			assert.Contains(
+				t, logged, "nothing proxying to this process",
+			)
+		})
+	}
+}
+
 // metricsEnv describes what one subtest below puts in the
 // environment for a single METRICS_ variable. A variable that is
 // set to the empty string and one that is not set at all are

internal/config/export_test.go

@@ -6,6 +6,21 @@ import "log/slog"
 // the external config_test package so each helper can be covered by
 // its own table-driven test without weakening the package API.
 
+// WarnSharedRateLimitBucketForTest loads a Config from the current
+// environment and emits its startup warnings to log. The real logger
+// writes to stdout, so this lets the warning's firing condition be
+// asserted against a handler the test controls.
+func WarnSharedRateLimitBucketForTest(log *slog.Logger) error {
+	c, err := loadFromEnv()
+	if err != nil {
+		return err
+	}
+
+	c.warnSharedRateLimitBucket(log)
+
+	return nil
+}
+
 // WarnEgressAllowlistForTest loads a Config from the current
 // environment and emits its egress-allowlist startup warning to
 // log, so a test can assert both that the warning fires only when

internal/delivery/ssrf.go

@@ -43,13 +43,6 @@ var (
 // permit specific blocks out of this set with
 // ALLOWED_EGRESS_CIDRS; see Guard.
 //
-// A public address belongs on the default blocklist only if it
-// hands credentials, user data or bootstrap material to whatever
-// can reach it, without the caller presenting anything. A
-// provider's other public addresses are not refused, since
-// reaching them can be legitimate and no list of them could be
-// complete.
-//
 //nolint:gochecknoglobals // package-level network list is appropriate here
 var blockedNetworks []*net.IPNet
 

internal/gormlog/gormlog.go

@@ -7,7 +7,7 @@
 // SQL — parameters and all — for every statement that returns an
 // error, including gorm.ErrRecordNotFound. Two of this service's
 // lookups miss by design on unauthenticated routes: the entrypoint
-// lookup on /h/{uuid}, whose path segment the client picks
+// lookup on /webhook/{uuid}, whose path segment the client picks
 // outright, and the user lookup behind the login form, whose username
 // the client picks outright. Under the default logger each of those
 // misses printed an unbounded, attacker-chosen string, at no level the

internal/handlers/auth.go

@@ -103,10 +103,9 @@ func (h *Handlers) renderLoginError(
 // The credential check runs BEFORE any rate-limit budget is
 // consulted, and only a failed check spends budget. That is what
 // keeps the single administrative path reachable: behind the reverse
-// proxy this deployment requires, when TRUSTED_PROXIES does not cover
+// proxy this deployment requires, with TRUSTED_PROXIES unset, every
-// it, every client shares one bucket, so a limiter spent on arrival
+// client shares one bucket, so a limiter spent on arrival lets any
-// lets any stranger deny the operator's own correct password
+// stranger deny the operator's own correct password indefinitely.
-// indefinitely.
 //
 // Verifying first means every login POST costs an Argon2id hash, so
 // the work is taken under a bounded number of verification slots.

internal/handlers/auth_test.go

@@ -25,7 +25,7 @@ const (
 
 	// sharedProxyPeer is the whole point of this file. Production is
 	// required to run behind a TLS-terminating reverse proxy, and
-	// when TRUSTED_PROXIES does not cover it every client — attacker
+	// TRUSTED_PROXIES defaults to empty, so every client — attacker
 	// and operator alike — reaches the process from the proxy's
 	// address and shares one rate-limit bucket. Both parties in
 	// these tests therefore use the same RemoteAddr.
@@ -115,11 +115,11 @@ func floodFailures(
 // done-criterion of https://git.eeqj.de/sneak/webhooker/issues/150.
 //
 // The attacker and the operator share one rate-limit bucket, because
-// behind the mandated reverse proxy, when TRUSTED_PROXIES does not
+// behind the mandated reverse proxy with TRUSTED_PROXIES unset every
-// cover it, every client keys on the proxy's address. The attacker
+// client keys on the proxy's address. The attacker floods the
-// floods the operator's own username — a single-admin product has a
+// operator's own username — a single-admin product has a predictable
-// predictable one — far past the failure limit. The operator must
+// one — far past the failure limit. The operator must still be able
-// still be able to log in with the correct password.
+// to log in with the correct password.
 //
 // This fails if credentials stop being verified ahead of the limiter.
 func TestLogin_StrangersFloodCannotLockOutTheOperator(t *testing.T) {

internal/handlers/delivery_replay.go

@@ -362,7 +362,7 @@ func (h *Handlers) finishReplay(
 	webhook database.Webhook,
 	code replayOutcomeCode,
 ) {
-	dest := "/hook/" + webhook.ID + "/events?" +
+	dest := "/source/" + webhook.ID + "/logs?" +
 		replayOutcomeParam + "=" + string(code)
 
 	// The page is read from the form rather than the query string:

internal/handlers/delivery_replay_test.go

@@ -138,7 +138,7 @@ func postReplay(
 	t.Helper()
 
 	req := postRequest(
-		"/hook/"+webhookID+"/deliveries/"+
+		"/source/"+webhookID+"/deliveries/"+
 			deliveryID+"/replay",
 		authenticatedCookies(
 			t, sess, deleteTestUserID, deleteTestUsername,
@@ -212,7 +212,7 @@ func TestHandleDeliveryReplay_AppendsDeliveryAndLeavesOriginal(
 	require.Equal(t, http.StatusSeeOther, w.Code)
 	assert.Equal(
 		t,
-		"/hook/"+wh.ID+"/events?replay=queued",
+		"/source/"+wh.ID+"/logs?replay=queued",
 		w.Header().Get("Location"),
 	)
 
@@ -362,7 +362,7 @@ func TestHandleDeliveryReplay_RefusesDeletedTarget(t *testing.T) {
 	require.Equal(t, http.StatusSeeOther, w.Code)
 	assert.Equal(
 		t,
-		"/hook/"+wh.ID+"/events?replay=target-deleted",
+		"/source/"+wh.ID+"/logs?replay=target-deleted",
 		w.Header().Get("Location"),
 	)
 
@@ -390,7 +390,7 @@ func TestHandleDeliveryReplay_RefusesDeletedTarget(t *testing.T) {
 	require.Equal(t, http.StatusSeeOther, missing.Code)
 	assert.Equal(
 		t,
-		"/hook/"+wh.ID+"/events?replay=target-missing",
+		"/source/"+wh.ID+"/logs?replay=target-missing",
 		missing.Header().Get("Location"),
 	)
 }
@@ -431,7 +431,7 @@ func TestHandleDeliveryReplay_RefusesWhileEarlierReplayInFlight(
 	require.Equal(t, http.StatusSeeOther, first.Code)
 	require.Equal(
 		t,
-		"/hook/"+wh.ID+"/events?replay=queued",
+		"/source/"+wh.ID+"/logs?replay=queued",
 		first.Header().Get("Location"),
 	)
 
@@ -439,7 +439,7 @@ func TestHandleDeliveryReplay_RefusesWhileEarlierReplayInFlight(
 	require.Equal(t, http.StatusSeeOther, second.Code)
 	assert.Equal(
 		t,
-		"/hook/"+wh.ID+"/events?replay=in-flight",
+		"/source/"+wh.ID+"/logs?replay=in-flight",
 		second.Header().Get("Location"),
 	)
 
@@ -465,7 +465,7 @@ func TestHandleDeliveryReplay_RefusesWhileEarlierReplayInFlight(
 	require.Equal(t, http.StatusSeeOther, pending.Code)
 	assert.Equal(
 		t,
-		"/hook/"+wh.ID+"/events?replay=not-terminal",
+		"/source/"+wh.ID+"/logs?replay=not-terminal",
 		pending.Header().Get("Location"),
 	)
 }
@@ -501,7 +501,7 @@ func TestHandleSourceLogs_RendersReplayControlAndBanner(t *testing.T) {
 
 	assert.Contains(
 		t, body,
-		`action="/hook/`+wh.ID+`/deliveries/`+
+		`action="/source/`+wh.ID+`/deliveries/`+
 			original.ID+`/replay"`,
 	)
 	assert.Contains(t, body, `method="POST"`)

internal/handlers/event_body_test.go

@@ -64,8 +64,8 @@ func fetchEventBody(
 	req := httptest.NewRequestWithContext(
 		context.Background(),
 		http.MethodGet,
-		"/hook/"+url.PathEscape(sourceID)+
+		"/source/"+url.PathEscape(sourceID)+
-			"/events/"+url.PathEscape(eventID)+"/body",
+			"/logs/"+url.PathEscape(eventID)+"/body",
 		nil,
 	)
 
@@ -490,7 +490,7 @@ func TestHandleSourceLogs_TruncationMarkerLinksToDownload(
 	page := renderSourceLogsPage(t, h, sess, big.ID)
 	assert.Contains(
 		t, page,
-		"/hook/"+big.ID+"/events/"+bigEvt.ID+"/body",
+		"/source/"+big.ID+"/logs/"+bigEvt.ID+"/body",
 	)
 
 	small := seedWebhook(t, db)
@@ -501,6 +501,6 @@ func TestHandleSourceLogs_TruncationMarkerLinksToDownload(
 	page = renderSourceLogsPage(t, h, sess, small.ID)
 	assert.NotContains(
 		t, page,
-		"/hook/"+small.ID+"/events/"+smallEvt.ID+"/body",
+		"/source/"+small.ID+"/logs/"+smallEvt.ID+"/body",
 	)
 }

internal/handlers/event_resubmit.go

@@ -257,7 +257,7 @@ func (h *Handlers) finishResubmit(
 	webhook database.Webhook,
 	code resubmitOutcomeCode,
 ) {
-	dest := "/hook/" + webhook.ID + "/events?" +
+	dest := "/source/" + webhook.ID + "/logs?" +
 		resubmitOutcomeParam + "=" + string(code)
 
 	// The page is read from the form rather than the query string:

internal/handlers/event_resubmit_test.go

@@ -65,7 +65,7 @@ func postResubmit(
 	t.Helper()
 
 	req := postRequest(
-		"/hook/"+webhookID+"/events/"+eventID+"/resubmit",
+		"/source/"+webhookID+"/events/"+eventID+"/resubmit",
 		authenticatedCookies(
 			t, sess, deleteTestUserID, deleteTestUsername,
 		),
@@ -154,7 +154,7 @@ func TestHandleEventResubmit_DeliversToTargetCreatedAfterTheEvent(
 	require.Equal(t, http.StatusSeeOther, w.Code)
 	assert.Equal(
 		t,
-		"/hook/"+wh.ID+"/events?resubmit=queued",
+		"/source/"+wh.ID+"/logs?resubmit=queued",
 		w.Header().Get("Location"),
 	)
 
@@ -282,7 +282,7 @@ func TestHandleEventResubmit_IsRepeatable(t *testing.T) {
 		require.Equal(t, http.StatusSeeOther, w.Code)
 		assert.Equal(
 			t,
-			"/hook/"+wh.ID+"/events?resubmit=queued",
+			"/source/"+wh.ID+"/logs?resubmit=queued",
 			w.Header().Get("Location"),
 			"a resubmit must not be refused while an earlier "+
 				"one is in flight",
@@ -436,7 +436,7 @@ func TestHandleEventResubmit_SkipsInactiveTarget(t *testing.T) {
 	require.Equal(t, http.StatusSeeOther, w.Code)
 	assert.Equal(
 		t,
-		"/hook/"+wh.ID+"/events?resubmit=queued",
+		"/source/"+wh.ID+"/logs?resubmit=queued",
 		w.Header().Get("Location"),
 		"an inactive target is skipped, not an error",
 	)
@@ -482,7 +482,7 @@ func TestHandleEventResubmit_NoActiveTargetsStillStoresEvent(
 	require.Equal(t, http.StatusSeeOther, w.Code)
 	assert.Equal(
 		t,
-		"/hook/"+wh.ID+"/events?resubmit=no-targets",
+		"/source/"+wh.ID+"/logs?resubmit=no-targets",
 		w.Header().Get("Location"),
 	)
 
@@ -598,7 +598,7 @@ func TestHandleSourceLogs_ShowsResubmitProvenance(t *testing.T) {
 	)
 	assert.Contains(
 		t, body,
-		"/hook/"+wh.ID+"/events/"+original.ID+"/resubmit",
+		"/source/"+wh.ID+"/events/"+original.ID+"/resubmit",
 		"the log must offer the resubmit action per event",
 	)
 }

internal/handlers/gormlogbound_test.go

@@ -306,7 +306,7 @@ func postWebhook(
 	t.Helper()
 
 	req := httptest.NewRequestWithContext(
-		context.Background(), http.MethodPost, "/h/x",
+		context.Background(), http.MethodPost, "/webhook/x",
 		strings.NewReader("{}"),
 	)
 

internal/handlers/handlers_test.go

@@ -176,7 +176,7 @@ func TestHandleIndex_Authenticated(t *testing.T) {
 
 	assert.Equal(t, http.StatusSeeOther, w2.Code)
 	assert.Equal(
-		t, "/hooks", w2.Header().Get("Location"),
+		t, "/sources", w2.Header().Get("Location"),
 	)
 }
 

internal/handlers/index.go

@@ -5,13 +5,13 @@ import (
 )
 
 // HandleIndex returns a handler for the root path that redirects
-// based on authentication state: authenticated users go to /hooks
+// based on authentication state: authenticated users go to /sources
 // (the dashboard), unauthenticated users go to the login page.
 func (s *Handlers) HandleIndex() http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		sess, err := s.session.Get(r)
 		if err == nil && s.session.IsAuthenticated(sess) {
-			http.Redirect(w, r, "/hooks", http.StatusSeeOther)
+			http.Redirect(w, r, "/sources", http.StatusSeeOther)
 
 			return
 		}

internal/handlers/logbound_test.go

@@ -4,7 +4,7 @@ package handlers_test
 // this package reach a value an UNAUTHENTICATED client picks outright
 // and of a length it picks outright:
 //
-//   - the unknown-entrypoint DEBUG line on /h/{uuid}, whose
+//   - the unknown-entrypoint DEBUG line on /webhook/{uuid}, whose
 //     path segment matched no stored entrypoint and so is bounded by
 //     nothing;
 //   - the failed-login DEBUG lines, whose username is a form field.
@@ -190,12 +190,12 @@ func assertNoClientText(t *testing.T, buf *bytes.Buffer) {
 // route pattern.
 func receiverRouter(h *handlers.Handlers) *chi.Mux {
 	router := chi.NewRouter()
-	router.Post("/h/{uuid}", h.HandleWebhook())
+	router.Post("/webhook/{uuid}", h.HandleWebhook())
 
 	return router
 }
 
-// postReceiver sends one POST at /h/<segment>.
+// postReceiver sends one POST at /webhook/<segment>.
 //
 // RawPath is cleared after parsing so chi routes on the decoded path
 // and the handler sees the raw bytes rather than their percent-escaped
@@ -210,7 +210,7 @@ func postReceiver(
 	req := httptest.NewRequestWithContext(
 		context.Background(),
 		http.MethodPost,
-		"/h/"+url.PathEscape(segment),
+		"/webhook/"+url.PathEscape(segment),
 		strings.NewReader(""),
 	)
 	req.URL.RawPath = ""
@@ -507,7 +507,7 @@ func TestVerificationCapacity_LogLineDoesNotTrackPathSize(
 					http.StatusServiceUnavailable,
 					postLoginAtPath(
 						t, h,
-						"/hook/"+url.PathEscape(
+						"/source/"+url.PathEscape(
 							oversizedFill(fill),
 						)+"/login",
 					),

internal/handlers/recent_events_test.go

@@ -313,7 +313,7 @@ func TestHandleWebhook_RecordsBodySize(t *testing.T) {
 	body := strings.Repeat("é", 1024)
 
 	req := httptest.NewRequestWithContext(
-		context.Background(), http.MethodPost, "/h/x",
+		context.Background(), http.MethodPost, "/webhook/x",
 		strings.NewReader(body),
 	)
 

internal/handlers/source_delete_test.go

@@ -220,7 +220,7 @@ func TestHandleSourceDelete_EvictsArchiveWriter(t *testing.T) {
 	)
 
 	req := postRequest(
-		"/hook/"+wh.ID+"/delete",
+		"/source/"+wh.ID+"/delete",
 		cookies,
 		map[string]string{paramSourceID: wh.ID},
 	)
@@ -267,7 +267,7 @@ func TestHandleSourceDelete_KeepsArchiveFile(t *testing.T) {
 	)
 
 	req := postRequest(
-		"/hook/"+wh.ID+"/delete",
+		"/source/"+wh.ID+"/delete",
 		cookies,
 		map[string]string{paramSourceID: wh.ID},
 	)
@@ -323,7 +323,7 @@ func TestHandleSourceDelete_FailedDeleteKeepsEverything(
 	)
 
 	req := postRequest(
-		"/hook/"+wh.ID+"/delete",
+		"/source/"+wh.ID+"/delete",
 		cookies,
 		map[string]string{paramSourceID: wh.ID},
 	)
@@ -337,7 +337,7 @@ func TestHandleSourceDelete_FailedDeleteKeepsEverything(
 	)
 	assert.Empty(
 		t, w.Header().Get("Location"),
-		"a failed deletion must not redirect to /hooks",
+		"a failed deletion must not redirect to /sources",
 	)
 
 	assert.Equal(
@@ -402,7 +402,7 @@ func TestHandleSourceDelete_RemovesConfigAndEventDatabase(
 	)
 
 	req := postRequest(
-		"/hook/"+wh.ID+"/delete",
+		"/source/"+wh.ID+"/delete",
 		cookies,
 		map[string]string{paramSourceID: wh.ID},
 	)
@@ -411,7 +411,7 @@ func TestHandleSourceDelete_RemovesConfigAndEventDatabase(
 	h.HandleSourceDelete().ServeHTTP(w, req)
 
 	require.Equal(t, http.StatusSeeOther, w.Code)
-	assert.Equal(t, "/hooks", w.Header().Get("Location"))
+	assert.Equal(t, "/sources", w.Header().Get("Location"))
 
 	assert.Equal(
 		t, int64(0),
@@ -465,7 +465,7 @@ func TestHandleTargetDelete_EvictsWhenLastDatabaseTargetGone(
 	)
 
 	req := postRequest(
-		"/hook/"+wh.ID+"/targets/"+tgt.ID+"/delete",
+		"/source/"+wh.ID+"/targets/"+tgt.ID+"/delete",
 		cookies,
 		map[string]string{
 			paramSourceID: wh.ID,
@@ -515,7 +515,7 @@ func TestHandleTargetDelete_KeepsWriterWhenDatabaseTargetRemains(
 	)
 
 	req := postRequest(
-		"/hook/"+wh.ID+"/targets/"+doomed.ID+"/delete",
+		"/source/"+wh.ID+"/targets/"+doomed.ID+"/delete",
 		cookies,
 		map[string]string{
 			paramSourceID: wh.ID,
@@ -563,7 +563,7 @@ func TestHandleTargetDelete_KeepsWriterWhenOtherTypeDeleted(
 	)
 
 	req := postRequest(
-		"/hook/"+wh.ID+"/targets/"+other.ID+"/delete",
+		"/source/"+wh.ID+"/targets/"+other.ID+"/delete",
 		cookies,
 		map[string]string{
 			paramSourceID: wh.ID,

internal/handlers/source_detail_baseurl_test.go

@@ -81,7 +81,7 @@ func (f *baseURLFixture) entrypointURL(
 	req := httptest.NewRequestWithContext(
 		context.Background(),
 		http.MethodGet,
-		"/hook/"+f.webhook,
+		"/source/"+f.webhook,
 		nil,
 	)
 	req.Host = host
@@ -213,7 +213,7 @@ func TestSourceDetailBaseURL_ForwardedProtoSpellings(t *testing.T) {
 
 			assert.Equal(
 				t,
-				tc.scheme+"://"+host+"/h/"+fixture.path,
+				tc.scheme+"://"+host+"/webhook/"+fixture.path,
 				fixture.entrypointURL(
 					t, host, forwardedProto(tc.header),
 				),
@@ -244,7 +244,7 @@ func TestSourceDetailBaseURL_DirectTLSBeatsPlaintextHeader(
 
 	assert.Equal(
 		t,
-		"https://"+host+"/h/"+fixture.path,
+		"https://"+host+"/webhook/"+fixture.path,
 		got,
 		"a connection this process terminated with TLS "+
 			"outranks a header claiming plaintext",
@@ -272,7 +272,7 @@ func TestSourceDetailBaseURL_KeepsHostAuthority(t *testing.T) {
 
 			assert.Equal(
 				t,
-				"https://"+host+"/h/"+fixture.path,
+				"https://"+host+"/webhook/"+fixture.path,
 				fixture.entrypointURL(
 					t, host, forwardedProto("HTTPS"),
 				),

internal/handlers/source_detail_test.go

@@ -82,7 +82,7 @@ func serveSourceDetailPage(
 	req := httptest.NewRequestWithContext(
 		context.Background(),
 		http.MethodGet,
-		"/hook/"+webhookID,
+		"/source/"+webhookID,
 		nil,
 	)
 

internal/handlers/source_logs_deleted_target_test.go

@@ -28,7 +28,7 @@ func deleteTargetThroughHandler(
 	t.Helper()
 
 	req := postRequest(
-		"/hook/"+webhookID+"/targets/"+targetID+"/delete",
+		"/source/"+webhookID+"/targets/"+targetID+"/delete",
 		authenticatedCookies(
 			t, sess, deleteTestUserID, deleteTestUsername,
 		),

internal/handlers/source_logs_test.go

@@ -84,7 +84,7 @@ func renderSourceLogsPageWithQuery(
 	req := httptest.NewRequestWithContext(
 		context.Background(),
 		http.MethodGet,
-		"/hook/"+webhookID+"/events"+query,
+		"/source/"+webhookID+"/logs"+query,
 		nil,
 	)
 

internal/handlers/source_management.go

@@ -330,7 +330,7 @@ func (h *Handlers) createWebhookWithEntrypoint(
 	)
 
 	http.Redirect(
-		w, r, "/hook/"+webhook.ID, http.StatusSeeOther,
+		w, r, "/source/"+webhook.ID, http.StatusSeeOther,
 	)
 }
 
@@ -588,7 +588,7 @@ func (h *Handlers) applyWebhookEdit(
 	}
 
 	http.Redirect(
-		w, r, "/hook/"+webhook.ID, http.StatusSeeOther,
+		w, r, "/source/"+webhook.ID, http.StatusSeeOther,
 	)
 }
 
@@ -671,7 +671,7 @@ func (h *Handlers) deleteWebhookResources(
 		return
 	}
 
-	http.Redirect(w, r, "/hooks", http.StatusSeeOther)
+	http.Redirect(w, r, "/sources", http.StatusSeeOther)
 }
 
 // commitWebhookDeletion soft-deletes a webhook's entrypoints,
@@ -1264,7 +1264,7 @@ func (h *Handlers) HandleEntrypointCreate() http.HandlerFunc {
 		}
 
 		http.Redirect(
-			w, r, "/hook/"+webhook.ID, http.StatusSeeOther,
+			w, r, "/source/"+webhook.ID, http.StatusSeeOther,
 		)
 	}
 }
@@ -1320,7 +1320,7 @@ func (h *Handlers) processTargetCreate(
 	//
 	// Every field here is read with PostFormValue, not FormValue.
 	// FormValue falls back to the query string, which would let
-	// `POST /hook/{id}/targets?url=https://hooks.slack.com/...`
+	// `POST /source/{id}/targets?url=https://hooks.slack.com/...`
 	// configure a target from a value the request line carries — and
 	// the request line, unlike the body, is what logs, proxies,
 	// Referer headers and error trackers record.
@@ -1377,7 +1377,7 @@ func (h *Handlers) processTargetCreate(
 	}
 
 	http.Redirect(
-		w, r, "/hook/"+webhook.ID, http.StatusSeeOther,
+		w, r, "/source/"+webhook.ID, http.StatusSeeOther,
 	)
 }
 
@@ -1435,7 +1435,7 @@ type targetFormInput struct {
 //
 // Every field is read with PostFormValue, not FormValue. FormValue
 // falls back to the query string, which would let
-// `POST /hook/{id}/targets?url=https://hooks.slack.com/...`
+// `POST /source/{id}/targets?url=https://hooks.slack.com/...`
 // configure a target from a value the request line carries — and the
 // request line, unlike the body, is what logs, proxies, Referer
 // headers and error trackers record. The headers field is under the
@@ -1714,7 +1714,7 @@ func (h *Handlers) deleteChildResource(
 
 		http.Redirect(
 			w, r,
-			"/hook/"+webhook.ID,
+			"/source/"+webhook.ID,
 			http.StatusSeeOther,
 		)
 	}
@@ -1811,7 +1811,7 @@ func (h *Handlers) toggleChildResource(
 
 		http.Redirect(
 			w, r,
-			"/hook/"+webhook.ID,
+			"/source/"+webhook.ID,
 			http.StatusSeeOther,
 		)
 	}

internal/handlers/source_management_test.go

@@ -105,7 +105,7 @@ func submitCreate(
 		form.Set("retention_days", *retention)
 	}
 
-	req := formRequest("/hooks/new", cookies, form, nil)
+	req := formRequest("/sources/new", cookies, form, nil)
 	w := httptest.NewRecorder()
 
 	h.HandleSourceCreateSubmit().ServeHTTP(w, req)
@@ -265,7 +265,7 @@ func TestHandleSourceCreate_PrefillsDefaultFromConstant(t *testing.T) {
 
 	w := httptest.NewRecorder()
 	env.handlers.HandleSourceCreate().ServeHTTP(
-		w, getRequest(t, "/hooks/new", env.cookies, nil),
+		w, getRequest(t, "/sources/new", env.cookies, nil),
 	)
 
 	require.Equal(t, http.StatusOK, w.Code)
@@ -402,7 +402,7 @@ func TestHandleSourceCreateSubmit_RejectedFormKeepsUserInput(
 	form.Set("description", description)
 	form.Set("retention_days", "nonsense")
 
-	req := formRequest("/hooks/new", env.cookies, form, nil)
+	req := formRequest("/sources/new", env.cookies, form, nil)
 	w := httptest.NewRecorder()
 
 	env.handlers.HandleSourceCreateSubmit().ServeHTTP(w, req)
@@ -430,7 +430,7 @@ func submitEdit(
 	form.Set("retention_days", retention)
 
 	req := formRequest(
-		"/hook/"+wh.ID+"/edit",
+		"/source/"+wh.ID+"/edit",
 		env.cookies,
 		form,
 		map[string]string{sourceIDParam: wh.ID},
@@ -512,7 +512,7 @@ func TestSourceEditForm_ForeverWebhookRoundTrips(t *testing.T) {
 	)
 
 	req := getRequest(
-		t, "/hook/"+wh.ID+"/edit", env.cookies,
+		t, "/source/"+wh.ID+"/edit", env.cookies,
 		map[string]string{sourceIDParam: wh.ID},
 	)
 	w := httptest.NewRecorder()
@@ -567,7 +567,7 @@ func TestSourceListAndDetail_ShowForeverNotTheSentinelNumber(
 
 	listW := httptest.NewRecorder()
 	env.handlers.HandleSourceList().ServeHTTP(
-		listW, getRequest(t, "/hooks", env.cookies, nil),
+		listW, getRequest(t, "/sources", env.cookies, nil),
 	)
 
 	require.Equal(t, http.StatusOK, listW.Code)
@@ -578,7 +578,7 @@ func TestSourceListAndDetail_ShowForeverNotTheSentinelNumber(
 	env.handlers.HandleSourceDetail().ServeHTTP(
 		detailW,
 		getRequest(
-			t, "/hook/"+wh.ID, env.cookies,
+			t, "/source/"+wh.ID, env.cookies,
 			map[string]string{sourceIDParam: wh.ID},
 		),
 	)

internal/handlers/target_create_query_test.go

@@ -76,11 +76,11 @@ func postTargetCreate(
 	router := chi.NewRouter()
 	router.Use(mw.Logging())
 	router.Post(
-		"/hook/{sourceID}/targets",
+		"/source/{sourceID}/targets",
 		env.handlers.HandleTargetCreate(),
 	)
 
-	target := "/hook/" + webhookID + "/targets"
+	target := "/source/" + webhookID + "/targets"
 	if query != "" {
 		target += "?" + query
 	}
@@ -114,7 +114,7 @@ func postTargetCreate(
 // regression test for the ingress leak. r.FormValue falls back to the
 // query string when a field is absent from the POST body, so
 //
-//	POST /hook/{id}/targets?url=https://hooks.slack.com/services/...
+//	POST /source/{id}/targets?url=https://hooks.slack.com/services/...
 //
 // with an empty url field used to create a working target from a value
 // carried on the request line — where logs, proxies, Referer headers

internal/handlers/target_edit.go

@@ -47,7 +47,7 @@ type targetEditView struct {
 //
 // This page is the one place the full destination URL and header
 // values are shown. It is reachable only through the
-// /hook/{sourceID} route group, which supplies RequireAuth and
+// /source/{sourceID} route group, which supplies RequireAuth and
 // NoCache, and only for a target of a webhook the session's user
 // owns; masking (delivery.TargetView) is unchanged everywhere else.
 func (h *Handlers) HandleTargetEdit() http.HandlerFunc {
@@ -163,7 +163,7 @@ func (h *Handlers) applyTargetEdit(
 	}
 
 	http.Redirect(
-		w, r, "/hook/"+webhook.ID, http.StatusSeeOther,
+		w, r, "/source/"+webhook.ID, http.StatusSeeOther,
 	)
 }
 

internal/handlers/target_edit_test.go

@@ -42,15 +42,15 @@ const (
 func targetRouter(env *sourceTestEnv) *chi.Mux {
 	router := chi.NewRouter()
 	router.Post(
-		"/hook/{sourceID}/targets",
+		"/source/{sourceID}/targets",
 		env.handlers.HandleTargetCreate(),
 	)
 	router.Get(
-		"/hook/{sourceID}/targets/{targetID}/edit",
+		"/source/{sourceID}/targets/{targetID}/edit",
 		env.handlers.HandleTargetEdit(),
 	)
 	router.Post(
-		"/hook/{sourceID}/targets/{targetID}/edit",
+		"/source/{sourceID}/targets/{targetID}/edit",
 		env.handlers.HandleTargetEditSubmit(),
 	)
 
@@ -117,7 +117,7 @@ func seedHTTPTarget(
 
 	w := serveTarget(
 		env, http.MethodPost,
-		"/hook/"+webhook.ID+"/targets", form,
+		"/source/"+webhook.ID+"/targets", form,
 	)
 	require.Equal(t, http.StatusSeeOther, w.Code, w.Body.String())
 
@@ -188,7 +188,7 @@ func submitTargetEdit(
 ) *httptest.ResponseRecorder {
 	return serveTarget(
 		env, http.MethodPost,
-		"/hook/"+webhookID+"/targets/"+targetID+"/edit",
+		"/source/"+webhookID+"/targets/"+targetID+"/edit",
 		form,
 	)
 }
@@ -401,7 +401,7 @@ func TestHandleTargetEdit_PrefillsTheStoredValuesUnmasked(
 
 	w := serveTarget(
 		env, http.MethodGet,
-		"/hook/"+webhook.ID+"/targets/"+target.ID+"/edit",
+		"/source/"+webhook.ID+"/targets/"+target.ID+"/edit",
 		nil,
 	)
 	require.Equal(t, http.StatusOK, w.Code)
@@ -508,7 +508,7 @@ func assertEditIgnoresQueryString(
 
 	w := serveTarget(
 		env, http.MethodPost,
-		"/hook/"+webhook.ID+"/targets/"+target.ID+
+		"/source/"+webhook.ID+"/targets/"+target.ID+
 			"/edit?url="+url.QueryEscape(editReplacedURL)+
 			"&headers="+url.QueryEscape(editAuthHeader),
 		form,
@@ -592,7 +592,7 @@ func assertTargetOfAnotherWebhook404s(
 
 	get := serveTarget(
 		env, http.MethodGet,
-		"/hook/"+mine.ID+"/targets/"+target.ID+"/edit", nil,
+		"/source/"+mine.ID+"/targets/"+target.ID+"/edit", nil,
 	)
 	assert.Equal(t, http.StatusNotFound, get.Code)
 
@@ -630,7 +630,7 @@ func assertWebhookOfAnotherUser404s(
 
 	w := serveTarget(
 		env, http.MethodGet,
-		"/hook/"+other.ID+"/targets/"+target.ID+"/edit", nil,
+		"/source/"+other.ID+"/targets/"+target.ID+"/edit", nil,
 	)
 
 	assert.Equal(t, http.StatusNotFound, w.Code)

internal/handlers/target_retries_test.go

@@ -102,7 +102,7 @@ func createWithRetries(
 
 	w := serveTarget(
 		env, http.MethodPost,
-		"/hook/"+webhook.ID+"/targets",
+		"/source/"+webhook.ID+"/targets",
 		createRetriesForm(retries),
 	)
 

internal/handlers/ui_copy_test.go

@@ -54,7 +54,8 @@ func renderPage(
 }
 
 // TestNavbarUsesWebhookTerminology pins the user-visible navigation
-// label to "Webhooks" and its link to the webhook list at /hooks.
+// label to "Webhooks". The /sources route is deliberately unchanged, so
+// the assertion targets the link text rather than the href.
 func TestNavbarUsesWebhookTerminology(t *testing.T) {
 	t.Parallel()
 
@@ -94,11 +95,15 @@ func TestNavbarUsesWebhookTerminology(t *testing.T) {
 		t, body, ">Sources<",
 		"no user-visible element may still be labelled Sources",
 	)
-	assert.Contains(t, body, `href="/hooks"`)
+	assert.Contains(
+		t, body, `href="/sources"`,
+		"the /sources route itself must not change",
+	)
 }
 
 // TestEditPageUsesWebhookTerminology pins the edit page's heading and
-// its back link to the webhook page at /hook/{id}.
+// its back link. The link's href still points at /source/{id}, which is
+// intentional: only user-visible copy changes.
 func TestEditPageUsesWebhookTerminology(t *testing.T) {
 	t.Parallel()
 
@@ -125,57 +130,7 @@ func TestEditPageUsesWebhookTerminology(t *testing.T) {
 
 	assert.Contains(t, body, "Edit Webhook")
 	assert.NotContains(t, body, ">Sources<")
-	assert.Contains(t, body, `href="/hook/wh-1"`)
+	assert.Contains(t, body, `href="/source/wh-1"`)
-}
-
-// TestEventLogPageIsCalledFullEventLog pins the one name the event log
-// page at /hook/{id}/events goes by: both links to it on the webhook
-// page, and its own heading, read "Full Event Log".
-func TestEventLogPageIsCalledFullEventLog(t *testing.T) {
-	t.Parallel()
-
-	var h *handlers.Handlers
-
-	var sess *session.Session
-
-	app := newTestApp(t, &h, &sess)
-	app.RequireStart()
-
-	t.Cleanup(app.RequireStop)
-
-	// A pointer, as in the handlers: source_detail.html calls
-	// Webhook.RetentionLabel, a pointer method. Both pages only range
-	// over their lists, and a list left out renders as empty, so the
-	// lists are left out.
-	webhook := &database.Webhook{Name: "wh", RetentionDays: 14}
-	webhook.ID = testWebhookID
-
-	detailBody := renderPage(
-		t, h, sess, "source_detail.html", map[string]any{
-			dataKeyWebhook: webhook,
-		},
-	)
-
-	assert.Contains(
-		t, detailBody,
-		`<a href="/hook/wh-1/events" class="btn-secondary">Full Event Log</a>`,
-		"the button at the top of the webhook page",
-	)
-	assert.Contains(
-		t, detailBody,
-		`<a href="/hook/wh-1/events" class="btn-text text-sm">Full Event Log</a>`,
-		"the link under recent events",
-	)
-
-	logBody := renderPage(t, h, sess, "source_logs.html", map[string]any{
-		dataKeyWebhook: webhook,
-		"TotalEvents":  int64(0),
-	})
-
-	assert.Contains(
-		t, logBody,
-		`<h1 class="text-2xl font-medium text-gray-900">Full Event Log</h1>`,
-	)
 }
 
 // TestCreateFormRetentionCopyMatchesBehaviour pins the create form's
@@ -328,7 +283,7 @@ func TestEntrypointCopyButtonIsProgressiveEnhancement(t *testing.T) {
 		t, body,
 		`<code id="entrypoint-url-ep-1"`,
 	)
-	assert.Contains(t, body, "https://hooks.example.com/h/abc123")
+	assert.Contains(t, body, "https://hooks.example.com/webhook/abc123")
 	assert.Contains(
 		t, body,
 		`hidden data-copy-target="entrypoint-url-ep-1"`,

internal/handlers/webhook.go

@@ -131,7 +131,7 @@ func (h *Handlers) lookupEntrypoint(
 		"path = ?", entrypointUUID,
 	).First(&entrypoint)
 	if result.Error != nil {
-		// The receiver is unauthenticated and /h/{uuid}
+		// The receiver is unauthenticated and /webhook/{uuid}
 		// matches any single segment, so this value is entirely
 		// client-chosen on exactly the branch where the lookup
 		// failed. DEBUG is off by default; the cap is what keeps

internal/logfield/logfield_test.go

@@ -201,7 +201,7 @@ func TestTruncate_LeavesShortValuesAlone(t *testing.T) {
 	t.Parallel()
 
 	for _, s := range []string{
-		"", "GET", "/hook/abc/edit", "Mozilla/5.0 (X11)",
+		"", "GET", "/source/abc/edit", "Mozilla/5.0 (X11)",
 	} {
 		assert.Equal(t, s, logfield.Truncate(s, budget))
 	}

internal/middleware/accesslog_test.go

@@ -119,7 +119,7 @@ func accessLogRouter(m *middleware.Middleware) *chi.Mux {
 	)
 
 	router.HandleFunc(
-		"/h/{uuid}",
+		"/webhook/{uuid}",
 		func(w http.ResponseWriter, r *http.Request) {
 			// Stands in for the real handler: an unknown entrypoint
 			// UUID 404s, a known one succeeds.
@@ -271,11 +271,11 @@ func TestAccessLog_InventedReceiverPathsLogRoutePattern(t *testing.T) {
 	assertFloodIsBounded(
 		t,
 		func(i int) string {
-			return "/h/" + attackerMarker +
+			return "/webhook/" + attackerMarker +
 				strings.Repeat("x", i) + "?q=" + attackerMarker
 		},
 		http.StatusNotFound,
-		"/h/{uuid}",
+		"/webhook/{uuid}",
 	)
 }
 
@@ -346,10 +346,10 @@ type sizeCase struct {
 func lineSizeCases() map[string]sizeCase {
 	cases := map[string]sizeCase{
 		"oversized path segment": {
-			target: "/h/" + attackerMarker +
+			target: "/webhook/" + attackerMarker +
 				strings.Repeat("x", oversizedSegmentBytes),
 			wantStatus: http.StatusNotFound,
-			wantURL:    "/h/{uuid}",
+			wantURL:    "/webhook/{uuid}",
 			bound:      maxLineBytes,
 		},
 		// /.well-known/healthcheck answers 200 to anyone and has no
@@ -605,14 +605,14 @@ func TestAccessLog_SuccessKeepsConcretePathAndRedactsQuery(
 	router := accessLogRouter(m)
 
 	assert.Equal(
-		t, http.StatusOK, get(t, router, "/h/known?src=ci"),
+		t, http.StatusOK, get(t, router, "/webhook/known?src=ci"),
 	)
 
 	// The path resolved against a stored entrypoint, so it stays. The
 	// query never does: see TestAccessLog_UnauthenticatedSuccess...
 	entries := accessLogEntries(t, buf)
 	require.Len(t, entries, 1)
-	assert.Equal(t, "/h/known?(redacted)", entries[0]["url"])
+	assert.Equal(t, "/webhook/known?(redacted)", entries[0]["url"])
 	assert.NotContains(t, buf.String(), "src=ci")
 }
 
@@ -640,7 +640,7 @@ func TestAccessLog_RetainsEveryOtherField(t *testing.T) {
 	assert.Equal(
 		t,
 		http.StatusNotFound,
-		get(t, router, "/h/"+attackerMarker),
+		get(t, router, "/webhook/"+attackerMarker),
 	)
 
 	entries := accessLogEntries(t, buf)

internal/middleware/csrf.go

@@ -41,7 +41,7 @@ func (m *Middleware) CSRF() func(http.Handler) http.Handler {
 		// CSRF is registered ahead of RequireAuth on every route
 		// group that uses it, so this WARN is reachable by an
 		// unauthenticated client: a POST with no token to
-		// /hook/<any length of any text>/edit lands here. The
+		// /source/<any length of any text>/edit lands here. The
 		// method and path are capped against the same budgets as
 		// the access log. remote_addr is set by net/http from the
 		// accepted connection rather than by the client, and

internal/middleware/logbound_test.go

@@ -383,7 +383,7 @@ func TestLogLines_ClientChosenPathDoesNotSizeTheLine(t *testing.T) {
 						t, newHandler,
 					)
 
-					path := "/hook/" +
+					path := "/source/" +
 						oversizedPathSegment(fill) + "/edit"
 
 					assert.Equal(
@@ -434,7 +434,7 @@ func TestLoginThrottle_LogLineDoesNotTrackPathSize(t *testing.T) {
 				req := httptest.NewRequestWithContext(
 					context.Background(),
 					http.MethodPost,
-					"/hook/"+
+					"/source/"+
 						oversizedPathSegment(fill)+"/login",
 					nil,
 				)
@@ -499,7 +499,7 @@ func TestMaxBodySize_FloodOfOversizePathsDoesNotGrowTheLog(
 							http.StatusRequestEntityTooLarge,
 							postOversize(
 								h,
-								"/hook/"+segment(i)+"/edit",
+								"/source/"+segment(i)+"/edit",
 							),
 						)
 					}

internal/middleware/loginguard.go

@@ -108,10 +108,10 @@ type failureWindow struct {
 //
 // A limiter that spends budget on arrival cannot protect a
 // single-admin product: behind the reverse proxy the deployment
-// requires, when TRUSTED_PROXIES does not cover it, every client
+// requires, with TRUSTED_PROXIES unset, every client keys on the
-// keys on the proxy, so a stranger trickling five POSTs a minute
+// proxy, so a stranger trickling five POSTs a minute keeps the one
-// keeps the one bucket full and the operator's own correct password
+// bucket full and the operator's own correct password is answered 429
-// is answered 429 forever. There is no second administrative path.
+// forever. There is no second administrative path.
 //
 // So budget is spent only by a FAILED verification. A correct
 // password is never throttled, whatever the counters say, which is

internal/middleware/metrics.go

@@ -40,7 +40,7 @@ const unmatchedMethod = unmatchedRoute
 //
 // The pattern is what bounds the label's domain to the routes the
 // service registers. The path does not bound it at all — every byte
-// after /h/ is client-chosen, so labelling by path lets any
+// after /webhook/ is client-chosen, so labelling by path lets any
 // unauthenticated client mint permanent series at will, and publishes
 // the entrypoint UUID (the receiver's only credential) in the scrape
 // while doing it.

internal/middleware/metrics_method_test.go

@@ -50,7 +50,7 @@ func realMethods() []string {
 // dimension varying, so any series growth a probe produces is the
 // method label's and nothing else's.
 func methodProbePath() string {
-	return "/h/" + uuid.NewString()
+	return "/webhook/" + uuid.NewString()
 }
 
 // inventedMethods returns n distinct RFC 9110 method tokens that no

internal/middleware/metrics_test.go

@@ -28,7 +28,7 @@ const (
 
 	// receiverRoutePattern is the one handler label every receiver
 	// request must produce, however the client varies the path.
-	receiverRoutePattern = "/h/{uuid}"
+	receiverRoutePattern = "/webhook/{uuid}"
 
 	// okRoute is a static route used to pin that the response-writer
 	// interceptor still reports status and size after the handler id
@@ -143,13 +143,13 @@ func drivePaths(
 	return drive(t, h, probes)
 }
 
-// receiverPaths returns n distinct /h/ paths, each naming a
+// receiverPaths returns n distinct /webhook/ paths, each naming a
 // fresh UUID exactly as an unauthenticated flood would.
 func receiverPaths(n int) []string {
 	paths := make([]string, 0, n)
 
 	for range n {
-		paths = append(paths, "/h/"+uuid.NewString())
+		paths = append(paths, "/webhook/"+uuid.NewString())
 	}
 
 	return paths
@@ -220,7 +220,7 @@ func keys(set map[string]struct{}) []string {
 
 // TestMetrics_DistinctReceiverPathsMintOneLabelSet is the direct
 // assertion the issue asks for: N requests to N distinct
-// /h/<uuid> paths must produce exactly ONE handler label, the
+// /webhook/<uuid> paths must produce exactly ONE handler label, the
 // route pattern. Before the fix this produced N of them.
 func TestMetrics_DistinctReceiverPathsMintOneLabelSet(t *testing.T) {
 	t.Parallel()
@@ -250,7 +250,7 @@ func TestMetrics_DistinctReceiverPathsMintOneLabelSet(t *testing.T) {
 	// The scrape must not republish the UUIDs it was driven with.
 	// They are the receiver's only credential.
 	for _, p := range paths {
-		id := strings.TrimPrefix(p, "/h/")
+		id := strings.TrimPrefix(p, "/webhook/")
 		for label := range labels {
 			assert.NotContains(
 				t, label, id,
@@ -354,7 +354,7 @@ func TestMetrics_UnmatchedPathsCollapseToTheSentinel(t *testing.T) {
 		if i%2 == 0 {
 			paths = append(paths, "/"+id)
 		} else {
-			paths = append(paths, "/h/"+id+"/"+id)
+			paths = append(paths, "/webhook/"+id+"/"+id)
 		}
 	}
 

internal/middleware/middleware.go

@@ -257,7 +257,7 @@ func concreteLogURL(r *http.Request) string {
 //
 // 3xx and 4xx responses get the chi route pattern instead. Those are
 // the outcomes an unauthenticated client drives for free: 404 or 429
-// on any invented /h/ path, 303 to the login page on any
+// on any invented /webhook/ path, 303 to the login page on any
 // invented /user/ path. Logging the concrete URL there lets a flood
 // write attacker-chosen text, of attacker-chosen length, into the
 // operator's log at one line per request. The pattern comes from the
@@ -560,7 +560,7 @@ func (s *Middleware) MaxBodySize(
 				// internal/server/routes.go), so an
 				// unauthenticated client reaches it with a path
 				// of its own choosing and its own length —
-				// POST /hook/<8 KB>/edit with an oversize
+				// POST /source/<8 KB>/edit with an oversize
 				// declared Content-Length costs nothing to
 				// send. At WARN, on by default, that is a
 				// write into the operator's log sized by the

internal/middleware/middleware_test.go

@@ -640,7 +640,7 @@ func TestNoCache_SetsHeaders(t *testing.T) {
 
 	req := httptest.NewRequestWithContext(
 		context.Background(),
-		http.MethodGet, "/hooks", nil,
+		http.MethodGet, "/sources", nil,
 	)
 	w := httptest.NewRecorder()
 

internal/middleware/ratelimit.go

@@ -63,7 +63,7 @@ const (
 
 	// receiverAggregateMultiplier scales the configured
 	// per-entrypoint receiver limit into the aggregate limit one
-	// client IP may spend across the whole /h/* route. Ten
+	// client IP may spend across the whole /webhook/* route. Ten
 	// entrypoints' worth lets a single sender address drive several
 	// entrypoints at their full rate, while still capping what one
 	// address costs the unauthenticated receiver.
@@ -123,8 +123,9 @@ func bucketKey(addr netip.Addr) string {
 	return prefix.String()
 }
 
-// isTrustedProxy reports whether addr belongs to a network in
+// isTrustedProxy reports whether addr belongs to a network the
-// TRUSTED_PROXIES, which by default is the RFC 1918 private ranges.
+// operator listed in TRUSTED_PROXIES. The list is empty by default,
+// so by default nothing is trusted.
 func (m *Middleware) isTrustedProxy(addr netip.Addr) bool {
 	for _, prefix := range m.params.Config.TrustedProxies {
 		if prefix.Contains(addr) {
@@ -389,7 +390,7 @@ func (m *Middleware) postRateLimit(
 // It is Config.ReceiverRateLimit requests per minute.
 //
 // That limit alone bounds nothing in aggregate. The route pattern
-// /h/{uuid} matches any single segment, so a client that
+// /webhook/{uuid} matches any single segment, so a client that
 // invents a fresh path per request mints a fresh bucket per request
 // and never refills one — and every such request still reaches the
 // handler's entrypoint lookup before it 404s. The outer limit is

internal/middleware/ratelimit_test.go

@@ -275,7 +275,7 @@ func TestReceiverRateLimit_LimitsPerIPAndPath(t *testing.T) {
 	// pass.
 	for i := range limit {
 		w := receiverPost(
-			handler, "9.9.9.9:1234", "/h/uuid-a",
+			handler, "9.9.9.9:1234", "/webhook/uuid-a",
 		)
 		assert.Equal(
 			t, http.StatusOK, w.Code,
@@ -286,7 +286,7 @@ func TestReceiverRateLimit_LimitsPerIPAndPath(t *testing.T) {
 	// The next request over the limit is rejected with a 429
 	// carrying a Retry-After header.
 	w := receiverPost(
-		handler, "9.9.9.9:1234", "/h/uuid-a",
+		handler, "9.9.9.9:1234", "/webhook/uuid-a",
 	)
 	assert.Equal(t, http.StatusTooManyRequests, w.Code)
 	assert.NotEmpty(
@@ -296,7 +296,7 @@ func TestReceiverRateLimit_LimitsPerIPAndPath(t *testing.T) {
 
 	// The same IP is not limited on a different entrypoint.
 	w = receiverPost(
-		handler, "9.9.9.9:1234", "/h/uuid-b",
+		handler, "9.9.9.9:1234", "/webhook/uuid-b",
 	)
 	assert.Equal(
 		t, http.StatusOK, w.Code,
@@ -305,7 +305,7 @@ func TestReceiverRateLimit_LimitsPerIPAndPath(t *testing.T) {
 
 	// A different IP is not limited on the same entrypoint.
 	w = receiverPost(
-		handler, "8.8.8.8:1234", "/h/uuid-a",
+		handler, "8.8.8.8:1234", "/webhook/uuid-a",
 	)
 	assert.Equal(
 		t, http.StatusOK, w.Code,
@@ -322,7 +322,7 @@ func TestReceiverRateLimit_CountsEveryMethod(t *testing.T) {
 	const (
 		limit = 2
 		ip    = "7.7.7.7:1234"
-		path  = "/h/uuid-c"
+		path  = "/webhook/uuid-c"
 	)
 
 	handler := receiverLimitedHandler(t, limit)
@@ -384,8 +384,8 @@ const (
 	// trustedProxyCIDR is the proxy network the forwarded-path
 	// tests configure, and trustedPeer an address inside it. A
 	// production deployment is required to run behind a reverse
-	// proxy that TRUSTED_PROXIES covers, either by the default or by
+	// proxy with TRUSTED_PROXIES set, so this is the shape the
-	// a set value, so this is the shape the bucketing has to hold in.
+	// bucketing has to hold in.
 	trustedProxyCIDR = "10.0.0.0/8"
 	trustedPeer      = "10.0.0.1:44444"
 )
@@ -426,8 +426,8 @@ func assertSharedBucket(
 }
 
 // TestRateLimitKey_SpoofedForwardedFromUntrustedPeer is the test
-// this gating exists for: from a peer that is not a trusted
+// this gating exists for: with no trusted proxies configured (the
-// proxy, a client that rotates a forwarded header on every
+// default), a client that rotates a forwarded header on every
 // request must stay in one bucket. If forwarded headers were
 // trusted unconditionally, each spoofed value would mint a fresh
 // bucket and the limit would stop no one.
@@ -715,7 +715,7 @@ func TestReceiverRateLimit_LimitsAggregateAcrossInventedPaths(
 	// none of them shares a per-entrypoint bucket with another.
 	for i := range aggregate {
 		w := receiverPost(
-			handler, ip, fmt.Sprintf("/h/invented-%d", i),
+			handler, ip, fmt.Sprintf("/webhook/invented-%d", i),
 		)
 		assert.Equal(
 			t, http.StatusOK, w.Code,
@@ -724,17 +724,17 @@ func TestReceiverRateLimit_LimitsAggregateAcrossInventedPaths(
 	}
 
 	w := receiverPost(
-		handler, ip, fmt.Sprintf("/h/invented-%d", aggregate),
+		handler, ip, fmt.Sprintf("/webhook/invented-%d", aggregate),
 	)
 	assert.Equal(
 		t, http.StatusTooManyRequests, w.Code,
 		"a client must not be able to raise its aggregate rate "+
-			"against /h/* by varying the path",
+			"against /webhook/* by varying the path",
 	)
 
 	// The aggregate limit is still per client IP: exhausting one
 	// address must not throttle another.
-	w = receiverPost(handler, "6.6.6.7:1234", "/h/invented-0")
+	w = receiverPost(handler, "6.6.6.7:1234", "/webhook/invented-0")
 	assert.Equal(
 		t, http.StatusOK, w.Code,
 		"a different client IP must not be affected",
@@ -771,7 +771,7 @@ func TestReceiverRateLimit_RejectedRequestsCountTowardAggregate(
 	// limit requests are served; the rest are rejected by the
 	// per-entrypoint limiter but still count against the aggregate.
 	for i := range aggregate {
-		w := receiverPost(handler, ip, "/h/exhausted")
+		w := receiverPost(handler, ip, "/webhook/exhausted")
 
 		want := http.StatusTooManyRequests
 		if i < limit {
@@ -784,7 +784,7 @@ func TestReceiverRateLimit_RejectedRequestsCountTowardAggregate(
 		)
 	}
 
-	w := receiverPost(handler, ip, "/h/never-used")
+	w := receiverPost(handler, ip, "/webhook/never-used")
 	assert.Equal(
 		t, http.StatusTooManyRequests, w.Code,
 		"requests rejected per entrypoint must still count "+
@@ -823,7 +823,7 @@ func TestReceiverRateLimit_IgnoresForwardedFromUntrustedPeer(
 	const (
 		limit = 3
 		peer  = "203.0.113.10:44444"
-		path  = "/h/uuid-d"
+		path  = "/webhook/uuid-d"
 	)
 
 	handler := receiverLimitedHandler(t, limit)
@@ -1097,9 +1097,8 @@ func TestPostRateLimit_IPv4IndependentPerAddress(t *testing.T) {
 // that arrives from trustedPeer — a configured trusted proxy — and
 // names forwarded as its client in X-Forwarded-For. That is the
 // production path: a deployment is required to run behind a reverse
-// proxy that TRUSTED_PROXIES covers, either by the default or by a
+// proxy with TRUSTED_PROXIES set, so the forwarded address, not the
-// set value, so the forwarded address, not the peer, is what the
+// peer, is what the limiters bucket on there.
-// limiters bucket on there.
 func forwardedKeyFor(
 	t *testing.T, m *middleware.Middleware, forwarded string,
 ) string {
@@ -1179,9 +1178,9 @@ func TestRateLimitKey_ForwardedIPv6BucketsByPrefix(t *testing.T) {
 //
 // Every existing test of this fallback uses an IPv4 proxy, where
 // bucketKey is the identity function, so replacing the call with
-// peer.String() leaves the whole suite green. Only addresses inside
+// peer.String() leaves the whole suite green. Only operator-listed
-// TRUSTED_PROXIES reach this line and the fallback is fail-closed, so
+// addresses reach this line and the fallback is fail-closed, so this
-// this pins behaviour rather than fixing a defect.
+// pins behaviour rather than fixing a defect.
 func TestRateLimitKey_TrustedPeerUnusableForwardedMasksPeer(
 	t *testing.T,
 ) {

internal/server/routes.go

@@ -154,12 +154,11 @@ func (s *Server) setupPageRoutes() {
 		r.Use(s.mw.NoCache())
 
 		// The login POST carries no pre-emptive rate limiter. Behind
-		// the reverse proxy production requires, when TRUSTED_PROXIES
+		// the reverse proxy production requires, with TRUSTED_PROXIES
-		// does not cover it, every client shares one bucket, so a
+		// unset, every client shares one bucket, so a limiter spent
-		// limiter spent on arrival lets any stranger deny the operator
+		// on arrival lets any stranger deny the operator the only
-		// the only administrative path. The handler verifies
+		// administrative path. The handler verifies credentials first
-		// credentials first and charges only failures; see
+		// and charges only failures; see Handlers.authenticateUser.
-		// Handlers.authenticateUser.
 		r.Get("/login", s.h.HandleLoginPage())
 		r.Post("/login", s.h.HandleLoginSubmit())
 
@@ -183,7 +182,7 @@ func (s *Server) setupUserRoutes() {
 }
 
 func (s *Server) setupSourceRoutes() {
-	s.router.Route("/hooks", func(r chi.Router) {
+	s.router.Route("/sources", func(r chi.Router) {
 		// MaxBodySize precedes CSRF and RequireAuth deliberately;
 		// see maxFormBodySize for why, and for what it costs.
 		r.Use(s.mw.MaxBodySize(maxFormBodySize))
@@ -195,7 +194,7 @@ func (s *Server) setupSourceRoutes() {
 		r.Post("/new", s.h.HandleSourceCreateSubmit())
 	})
 
-	s.router.Route("/hook/{sourceID}", func(r chi.Router) {
+	s.router.Route("/source/{sourceID}", func(r chi.Router) {
 		// MaxBodySize precedes CSRF and RequireAuth deliberately;
 		// see maxFormBodySize for why, and for what it costs.
 		r.Use(s.mw.MaxBodySize(maxFormBodySize))
@@ -206,14 +205,14 @@ func (s *Server) setupSourceRoutes() {
 		r.Get("/edit", s.h.HandleSourceEdit())
 		r.Post("/edit", s.h.HandleSourceEditSubmit())
 		r.Post("/delete", s.h.HandleSourceDelete())
-		r.Get("/events", s.h.HandleSourceLogs())
+		r.Get("/logs", s.h.HandleSourceLogs())
 		// The log page renders each body only up to its cap, so
 		// this is the only route that serves a whole one. It
 		// belongs to this group for its RequireAuth and
 		// NoCache; see HandleEventBodyDownload for the headers
 		// that keep the bytes it returns inert.
 		r.Get(
-			"/events/{eventID}/body",
+			"/logs/{eventID}/body",
 			s.h.HandleEventBodyDownload(),
 		)
 		// Replay is the one page action that queues outbound work:
@@ -280,7 +279,7 @@ func (s *Server) setupSourceRoutes() {
 
 func (s *Server) setupWebhookRoutes() {
 	s.router.With(s.mw.ReceiverRateLimit()).HandleFunc(
-		"/h/{uuid}",
+		"/webhook/{uuid}",
 		s.h.HandleWebhook(),
 	)
 }

internal/server/routes_test.go

@@ -240,26 +240,6 @@ func (e *testEnv) csrfFrom(
 	return token, combined
 }
 
-// urlFrom renders the page at path and returns the link or form
-// action that pattern's one group captures, so a test requests the
-// URL the template emitted rather than one it wrote itself.
-func (e *testEnv) urlFrom(
-	t *testing.T,
-	path, pattern string,
-	cookies []*http.Cookie,
-) string {
-	t.Helper()
-
-	w := e.get(path, cookies)
-	require.Equal(t, http.StatusOK, w.Code)
-
-	match := regexp.MustCompile(pattern).
-		FindStringSubmatch(w.Body.String())
-	require.Len(t, match, 2, "%s should render %s", path, pattern)
-
-	return html.UnescapeString(match[1])
-}
-
 // authCookies forges an authenticated session for the given user.
 func (e *testEnv) authCookies(
 	t *testing.T,
@@ -694,7 +674,7 @@ func TestPagesLogin_CookiesFromAnEarlierDatabase(t *testing.T) {
 
 	require.NotNil(t, fresh, "login must set a session cookie")
 	assert.Equal(
-		t, "/hooks",
+		t, "/sources",
 		env.get("/", []*http.Cookie{fresh}).Header().Get("Location"),
 		"the new session cookie must authenticate",
 	)
@@ -761,264 +741,7 @@ func TestPasswordChange_UnderLimit_Succeeds(t *testing.T) {
 	)
 }
 
-// --- /hooks group ---
+// --- /source/{sourceID} group ---
-
-// TestHooks_ListAndNewWebhookForm gets the webhook list and the
-// new-webhook form through the production router, then submits the
-// form to the action and with the token the page rendered. A
-// mistyped route or form action fails here; the handler tests
-// cannot catch either, because they never route a request.
-func TestHooks_ListAndNewWebhookForm(t *testing.T) {
-	t.Parallel()
-
-	env := newTestEnv(t)
-
-	userID, _ := env.seedUser(t, "lister", "somepassword")
-	cookies := env.authCookies(t, userID, "lister")
-	existing := env.seedWebhook(t, userID)
-
-	list := env.get("/hooks", cookies)
-	require.Equal(t, http.StatusOK, list.Code)
-	assert.Contains(
-		t, list.Body.String(), `href="/hook/`+existing.ID+`"`,
-		"the list should link the user's webhook",
-	)
-
-	token, cookies := env.csrfFrom(t, "/hooks/new", cookies)
-
-	form := url.Values{}
-	form.Set("csrf_token", token)
-	form.Set("name", "created")
-
-	w := env.post(
-		env.urlFrom(t, "/hooks/new", `action="(/hooks[^"]*)"`, cookies),
-		form, cookies,
-	)
-	require.Equal(t, http.StatusSeeOther, w.Code)
-
-	var created database.Webhook
-
-	require.NoError(t,
-		env.db.DB().Where("name = ?", "created").First(&created).Error,
-	)
-	assert.Equal(
-		t, "/hook/"+created.ID, w.Header().Get("Location"),
-		"creating a webhook should redirect to its page",
-	)
-}
-
-// --- /hook/{sourceID} group ---
-
-// TestHook_EditFormAndDelete follows the webhook page's Edit link to
-// the edit form and submits it, then deletes the webhook with the
-// form on its page, every URL and token taken from the rendered
-// pages.
-func TestHook_EditFormAndDelete(t *testing.T) {
-	t.Parallel()
-
-	env := newTestEnv(t)
-
-	userID, _ := env.seedUser(t, "editor", "somepassword")
-	cookies := env.authCookies(t, userID, "editor")
-	wh := env.seedWebhook(t, userID)
-	page := "/hook/" + wh.ID
-
-	editPage := env.urlFrom(t, page, `href="(/hook/[^/"]+/edit)"`, cookies)
-	token, cookies := env.csrfFrom(t, editPage, cookies)
-
-	form := url.Values{}
-	form.Set("csrf_token", token)
-	form.Set("name", "renamed")
-
-	w := env.post(
-		env.urlFrom(t, editPage, `action="(/hook/[^/"]+/edit)"`, cookies),
-		form, cookies,
-	)
-	require.Equal(t, http.StatusSeeOther, w.Code)
-	assert.Equal(t, page, w.Header().Get("Location"))
-
-	var edited database.Webhook
-
-	require.NoError(t, env.db.DB().First(&edited, "id = ?", wh.ID).Error)
-	assert.Equal(t, "renamed", edited.Name)
-
-	form = url.Values{}
-	form.Set("csrf_token", token)
-
-	w = env.post(
-		env.urlFrom(t, page, `action="(/hook/[^/"]+/delete)"`, cookies),
-		form, cookies,
-	)
-	require.Equal(t, http.StatusSeeOther, w.Code)
-	assert.Equal(t, "/hooks", w.Header().Get("Location"))
-	assert.Equal(
-		t, http.StatusNotFound, env.get(page, cookies).Code,
-		"a deleted webhook's page should be gone",
-	)
-}
-
-// TestHook_EntrypointActions adds, deactivates and deletes an
-// entrypoint with the forms on the webhook page, each submitted to
-// the action and with the token the page rendered.
-func TestHook_EntrypointActions(t *testing.T) {
-	t.Parallel()
-
-	env := newTestEnv(t)
-
-	userID, _ := env.seedUser(t, "epuser", "somepassword")
-	cookies := env.authCookies(t, userID, "epuser")
-	wh := env.seedWebhook(t, userID)
-	page := "/hook/" + wh.ID
-
-	token, cookies := env.csrfFrom(t, page, cookies)
-
-	form := url.Values{}
-	form.Set("csrf_token", token)
-
-	// submit posts the webhook page's form whose action pattern
-	// captures, and requires the redirect back to that page.
-	submit := func(pattern string) {
-		t.Helper()
-
-		w := env.post(env.urlFrom(t, page, pattern, cookies), form, cookies)
-		require.Equal(t, http.StatusSeeOther, w.Code)
-		require.Equal(t, page, w.Header().Get("Location"))
-	}
-
-	submit(`action="(/hook/[^/"]+/entrypoints)"`)
-
-	var added database.Entrypoint
-
-	require.NoError(t,
-		env.db.DB().First(&added, "webhook_id = ?", wh.ID).Error,
-	)
-	require.True(t, added.Active)
-
-	submit(`action="(/hook/[^/"]+/entrypoints/[^/"]+/toggle)"`)
-
-	var toggled database.Entrypoint
-
-	require.NoError(t,
-		env.db.DB().First(&toggled, "id = ?", added.ID).Error,
-	)
-	assert.False(t, toggled.Active, "the toggle should deactivate it")
-
-	submit(`action="(/hook/[^/"]+/entrypoints/[^/"]+/delete)"`)
-
-	var left int64
-
-	require.NoError(t, env.db.DB().Model(&database.Entrypoint{}).
-		Where("webhook_id = ?", wh.ID).Count(&left).Error)
-	assert.Zero(t, left, "the delete should remove the entrypoint")
-}
-
-// TestHook_TargetActions adds a target with the form on the webhook
-// page, follows its Edit link to the target edit form and submits
-// it, then deactivates and deletes it, every URL and token taken from
-// the rendered pages.
-func TestHook_TargetActions(t *testing.T) {
-	t.Parallel()
-
-	env := newTestEnv(t)
-
-	userID, _ := env.seedUser(t, "tgtuser", "somepassword")
-	cookies := env.authCookies(t, userID, "tgtuser")
-	wh := env.seedWebhook(t, userID)
-	page := "/hook/" + wh.ID
-
-	token, cookies := env.csrfFrom(t, page, cookies)
-
-	// submit posts form, with the token, to the action pattern
-	// captures on the page at from, and requires the redirect back to
-	// the webhook page.
-	submit := func(from, pattern string, form url.Values) {
-		t.Helper()
-
-		form.Set("csrf_token", token)
-
-		w := env.post(env.urlFrom(t, from, pattern, cookies), form, cookies)
-		require.Equal(t, http.StatusSeeOther, w.Code)
-		require.Equal(t, page, w.Header().Get("Location"))
-	}
-
-	submit(page, `action="(/hook/[^/"]+/targets)"`, url.Values{
-		"name": {"added"},
-		"type": {string(database.TargetTypeLog)},
-	})
-
-	editPage := env.urlFrom(
-		t, page, `href="(/hook/[^/"]+/targets/[^/"]+/edit)"`, cookies,
-	)
-	submit(editPage, `action="(/hook/[^/"]+/targets/[^/"]+/edit)"`,
-		url.Values{"name": {"renamed"}})
-
-	var edited database.Target
-
-	require.NoError(t,
-		env.db.DB().First(&edited, "webhook_id = ?", wh.ID).Error,
-	)
-	assert.Equal(t, "renamed", edited.Name)
-	require.True(t, edited.Active)
-
-	submit(page, `action="(/hook/[^/"]+/targets/[^/"]+/toggle)"`,
-		url.Values{})
-
-	var toggled database.Target
-
-	require.NoError(t,
-		env.db.DB().First(&toggled, "id = ?", edited.ID).Error,
-	)
-	assert.False(t, toggled.Active, "the toggle should deactivate it")
-
-	submit(page, `action="(/hook/[^/"]+/targets/[^/"]+/delete)"`,
-		url.Values{})
-
-	var left int64
-
-	require.NoError(t, env.db.DB().Model(&database.Target{}).
-		Where("webhook_id = ?", wh.ID).Count(&left).Error)
-	assert.Zero(t, left, "the delete should remove the target")
-}
-
-// TestHook_ResubmitFromEventLog resubmits a stored event with the
-// form on the event log page, submitted to the action and with the
-// token the page rendered.
-func TestHook_ResubmitFromEventLog(t *testing.T) {
-	t.Parallel()
-
-	env := newTestEnv(t)
-
-	userID, _ := env.seedUser(t, "resubmitter", "somepassword")
-	cookies := env.authCookies(t, userID, "resubmitter")
-	wh := env.seedWebhook(t, userID)
-	env.seedEvent(t, wh.ID, `{"resubmit":"me"}`)
-
-	logsPath := "/hook/" + wh.ID + "/events"
-
-	token, cookies := env.csrfFrom(t, logsPath, cookies)
-
-	form := url.Values{}
-	form.Set("csrf_token", token)
-
-	w := env.post(
-		env.urlFrom(t, logsPath, `action="(/hook/[^"]+/resubmit)"`, cookies),
-		form, cookies,
-	)
-	require.Equal(t, http.StatusSeeOther, w.Code)
-	assert.Equal(
-		t, logsPath+"?resubmit=no-targets", w.Header().Get("Location"),
-	)
-
-	webhookDB, err := env.dbMgr.GetDB(wh.ID)
-	require.NoError(t, err)
-
-	var events int64
-
-	require.NoError(t,
-		webhookDB.Model(&database.Event{}).Count(&events).Error,
-	)
-	assert.Equal(t, int64(2), events, "the resubmit stores a new event")
-}
 
 // TestSourceLogs_TruncationLinkDownloadsTheBody walks the whole
 // feature the way a user does: render the event log page through
@@ -1046,11 +769,11 @@ func TestSourceLogs_TruncationLinkDownloadsTheBody(t *testing.T) {
 	wh := env.seedWebhook(t, userID)
 	env.seedEvent(t, wh.ID, stored)
 
-	page := env.get("/hook/"+wh.ID+"/events", cookies)
+	page := env.get("/source/"+wh.ID+"/logs", cookies)
 	require.Equal(t, http.StatusOK, page.Code)
 
 	link := regexp.MustCompile(
-		`href="(/hook/[^"]+/body)"`,
+		`href="(/source/[^"]+/body)"`,
 	).FindStringSubmatch(page.Body.String())
 	require.Len(
 		t, link, 2,
@@ -1096,7 +819,7 @@ func TestSourceLogsBody_OtherUser404s(t *testing.T) {
 	const payload = "OWNERS-PAYLOAD-77c1"
 
 	evt := env.seedEvent(t, wh.ID, payload)
-	path := "/hook/" + wh.ID + "/events/" + evt.ID + "/body"
+	path := "/source/" + wh.ID + "/logs/" + evt.ID + "/body"
 
 	intruderID, _ := env.seedUser(t, "intruder", "somepassword")
 	intruder := env.authCookies(t, intruderID, "intruder")
@@ -1130,7 +853,7 @@ func TestDeliveryReplay_PostOnlyAndCSRFProtected(t *testing.T) {
 	evt := env.seedEvent(t, wh.ID, `{"replay":"me"}`)
 	dlv := env.seedFailedDelivery(t, wh.ID, evt.ID, tgt.ID)
 
-	path := "/hook/" + wh.ID + "/deliveries/" + dlv.ID +
+	path := "/source/" + wh.ID + "/deliveries/" + dlv.ID +
 		"/replay"
 
 	assert.Equal(
@@ -1156,7 +879,7 @@ func TestDeliveryReplay_PostOnlyAndCSRFProtected(t *testing.T) {
 	// The token and the action URL both come out of the rendered
 	// page, so a typo in either the route pattern or the template
 	// fails here.
-	logsPath := "/hook/" + wh.ID + "/events"
+	logsPath := "/source/" + wh.ID + "/logs"
 
 	token, cookies := env.csrfFrom(t, logsPath, cookies)
 
@@ -1164,7 +887,7 @@ func TestDeliveryReplay_PostOnlyAndCSRFProtected(t *testing.T) {
 	require.Equal(t, http.StatusOK, page.Code)
 
 	action := regexp.MustCompile(
-		`action="(/hook/[^"]+/replay)"`,
+		`action="(/source/[^"]+/replay)"`,
 	).FindStringSubmatch(page.Body.String())
 	require.Len(
 		t, action, 2,
@@ -1189,59 +912,6 @@ func TestDeliveryReplay_PostOnlyAndCSRFProtected(t *testing.T) {
 	)
 }
 
-// --- /h/{uuid} receiver ---
-
-// TestReceiver_EntrypointURLIsRateLimited takes the entrypoint URL
-// the webhook page shows and posts to it through the production
-// router until the receiver rate limit refuses it. The URL has to
-// reach the receiver, and the limit has to apply to it.
-func TestReceiver_EntrypointURLIsRateLimited(t *testing.T) {
-	t.Parallel()
-
-	const limit = 2
-
-	env := newTestEnvWithConfig(t, &config.Config{
-		DataDir:           t.TempDir(),
-		Environment:       config.EnvironmentDev,
-		ReceiverRateLimit: limit,
-	})
-
-	userID, _ := env.seedUser(t, "receiver", "somepassword")
-	cookies := env.authCookies(t, userID, "receiver")
-
-	wh := env.seedWebhook(t, userID)
-	require.NoError(t, env.db.DB().Omit(clause.Associations).Create(
-		&database.Entrypoint{
-			WebhookID: wh.ID,
-			Path:      "6f1e2a9c-4b7d-4e3a-9c2f-1d8b5a7e3c60",
-			Active:    true,
-		},
-	).Error)
-
-	page := env.get("/hook/"+wh.ID, cookies)
-	require.Equal(t, http.StatusOK, page.Code)
-
-	shown := regexp.MustCompile(`(/h/[^<]+)</code>`).
-		FindStringSubmatch(page.Body.String())
-	require.Len(
-		t, shown, 2, "the webhook page should show the entrypoint URL",
-	)
-
-	for i := range limit {
-		assert.Equal(
-			t, http.StatusOK,
-			env.post(shown[1], url.Values{}, nil).Code,
-			"request %d should reach the receiver", i,
-		)
-	}
-
-	assert.Equal(
-		t, http.StatusTooManyRequests,
-		env.post(shown[1], url.Values{}, nil).Code,
-		"the receiver rate limit must apply to the entrypoint URL",
-	)
-}
-
 // metricsConfig is a Config differing from the routing default only
 // in the two /metrics credentials.
 func metricsConfig(

internal/server/sentry.go

@@ -55,7 +55,7 @@ func sentryClientOptions(dsn, release string) sentry.ClientOptions {
 //
 // URL is the third such field. NewRequest builds it as
 // scheme://host/path (interfaces.go:183), and on the receiver route
-// that path is /h/<uuid> in full — a write capability, not an
+// that path is /webhook/<uuid> in full — a write capability, not an
 // identifier. It is rebuilt here from the chi route pattern, on every
 // route, keeping the scheme and the host.
 //

internal/server/sentry_test.go

@@ -153,7 +153,7 @@ func (c sentryCase) router() http.Handler {
 		sentryhttp.New(sentryhttp.Options{Repanic: true}).Handle,
 	)
 	router.HandleFunc("/pages/login", handler)
-	router.HandleFunc("/h/{uuid}", handler)
+	router.HandleFunc("/webhook/{uuid}", handler)
 
 	return router
 }
@@ -191,7 +191,7 @@ func sentryLoginRequest(client *sentry.Client) *http.Request {
 // concrete path carries the entrypoint capability.
 func sentryReceiverRequest(client *sentry.Client) *http.Request {
 	return sentryRequest(
-		client, "/h/"+sentryReceiverUUID, "payload=hello",
+		client, "/webhook/"+sentryReceiverUUID, "payload=hello",
 	)
 }
 
@@ -316,7 +316,7 @@ func TestSentryScrub_ReplacesTheCapabilityPathWithTheRoutePattern(
 		t, marshalEvent(t, event), sentryReceiverUUID,
 	)
 	assert.Equal(
-		t, "http://example.com/h/{uuid}", event.Request.URL,
+		t, "http://example.com/webhook/{uuid}", event.Request.URL,
 	)
 }
 
@@ -401,7 +401,7 @@ func TestSentryScrub_TransactionDispatchIsUnscrubbedWithoutTheHook(
 func TestSentryScrub_FallsBackWithoutARoutePattern(t *testing.T) {
 	t.Parallel()
 
-	concrete := "https://example.com/h/" + sentryReceiverUUID
+	concrete := "https://example.com/webhook/" + sentryReceiverUUID
 
 	// A request with no chi routing context on it at all, which is
 	// what an event captured outside the router would carry.
@@ -426,7 +426,7 @@ func TestSentryScrub_FallsBackWithoutARoutePattern(t *testing.T) {
 
 			event := sentry.NewEvent()
 			event.Request = &sentry.Request{URL: concrete}
-			event.Transaction = "POST /h/" +
+			event.Transaction = "POST /webhook/" +
 				sentryReceiverUUID
 
 			scrubbed := server.ScrubSentryRequestForTest(
@@ -459,9 +459,9 @@ func TestSentryScrub_WithholdsUnparseableValues(t *testing.T) {
 
 	event := sentry.NewEvent()
 	event.Request = &sentry.Request{
-		URL: "/h/" + sentryReceiverUUID,
+		URL: "/webhook/" + sentryReceiverUUID,
 	}
-	event.Transaction = "/h/" + sentryReceiverUUID
+	event.Transaction = "/webhook/" + sentryReceiverUUID
 
 	scrubbed := server.ScrubSentryRequestForTest(event, nil)
 	require.NotNil(t, scrubbed)

internal/versionscript/version_script_test.go

@@ -115,8 +115,8 @@ func TestVersion_EnclosingRepositoryIsNotUsed(t *testing.T) {
 	require.Equal(t, unknown, runScript(t, inner, nil))
 }
 
-// The Docker build has no git metadata, so the version arrives as an
+// An explicit VERSION, such as the Dockerfile's build arg, wins over
-// environment override. It wins over anything derivable.
+// anything derivable.
 func TestVersion_EnvironmentOverrideWins(t *testing.T) {
 	t.Parallel()
 
@@ -128,8 +128,8 @@ func TestVersion_EnvironmentOverrideWins(t *testing.T) {
 }
 
 // An empty VERSION is treated as unset rather than stamping an empty
-// string: the Dockerfile's build arg has a non-empty default, but a
+// string: a caller exporting VERSION= must not produce a binary
-// caller exporting VERSION= must not produce a binary reporting "".
+// reporting "".
 func TestVersion_EmptyOverrideFallsBackToGit(t *testing.T) {
 	t.Parallel()
 
@@ -168,8 +168,8 @@ func TestMakefile_BuildComposesVersionAndExtraFlags(t *testing.T) {
 }
 
 // A caller can define VERSION as the empty string -- `make build
-// VERSION=`, or a `--build-arg VERSION=` reaching the Dockerfile's `make
+// VERSION=`, or the Dockerfile's `make build VERSION="$VERSION"` when no
-// build VERSION="$VERSION"`. script/version's own guard does not cover
+// VERSION build arg was given. script/version's own guard does not cover
 // that: the value never passes through the script. Stamping "" would
 // leave the binary reporting no version and the footer on "dev", which
 // is the defect this package exists for.
@@ -231,7 +231,7 @@ func TestDockerfile_BuildsThroughTheMakeTarget(t *testing.T) {
 
 	require.NotContains(t, dockerfile, "go build",
 		"a raw go build bypasses the Makefile's -X flag")
-	require.Contains(t, dockerfile, "ARG VERSION=")
+	require.Contains(t, dockerfile, "ARG VERSION")
 	require.Contains(t, dockerfile,
 		`make build VERSION="$VERSION" GO_LDFLAGS='-extldflags "-static"'`)
 }

script/docker

@@ -2,9 +2,9 @@
 # script/docker: build the Docker image tagged with the project name.
 # The tag comes from script/projectname.
 #
-# .dockerignore excludes .git/, so the builder stage cannot derive the
+# The version script/version resolves here goes in as the VERSION build
-# version itself. It is resolved here, where the checkout is, and passed
+# arg, which takes precedence over what the build would derive from the
-# in as a build arg; without it the image would stamp itself "unknown".
+# .git in its context.
 set -eu
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"

script/version

@@ -7,18 +7,16 @@
 #
 # Order of precedence:
 #
-#   1. $VERSION, if set and non-empty. This is how the value reaches a
+#   1. $VERSION, if set and non-empty: an explicit value, such as the
-#      build that cannot derive it: .dockerignore excludes .git/, so the
+#      Dockerfile's VERSION build arg.
-#      builder stage has no git metadata and the Dockerfile takes the
-#      value as a build arg instead.
 #   2. `git describe --tags --always --dirty` against this checkout. At
 #      a clean tagged commit that is exactly the tag; otherwise it
 #      carries the short SHA, the commit distance when a tag is
 #      reachable, and a -dirty suffix for uncommitted changes.
 #   3. "unknown", for a tree with no git metadata and no $VERSION -- a
-#      source tarball, or `docker build .` with no --build-arg. That
+#      source tarball, or a `docker build` with no .git in its context
-#      case must not fail the build and must not name a tag the tree may
+#      and no VERSION build arg. That case must not fail the build and
-#      not be at, so it names nothing.
+#      must not name a tag the tree may not be at, so it names nothing.
 #
 # The git step insists the enclosing repository is this checkout, not
 # merely some repository above it: an unpacked tarball sitting inside an

templates/navbar.html

@@ -16,7 +16,7 @@
         <!-- Desktop navigation -->
         <div class="hidden md:flex items-center gap-4">
             {{if .User}}
-            <a href="/hooks" class="btn-text">Webhooks</a>
+            <a href="/sources" class="btn-text">Webhooks</a>
             <a href="/user/{{.User.Username}}" class="btn-text">
                 <svg class="w-5 h-5 mr-1" fill="currentColor" viewBox="0 0 16 16">
                     <path d="M11 6a3 3 0 1 1-6 0 3 3 0 0 1 6 0z"/>
@@ -38,7 +38,7 @@
     <div x-show="open" x-cloak x-transition class="md:hidden mt-4 pt-4 border-t border-gray-200">
         <div class="flex flex-col gap-2">
             {{if .User}}
-            <a href="/hooks" class="btn-text w-full text-left">Webhooks</a>
+            <a href="/sources" class="btn-text w-full text-left">Webhooks</a>
             <a href="/user/{{.User.Username}}" class="btn-text w-full text-left">Profile</a>
             <form method="POST" action="/pages/logout">
                 <input type="hidden" name="csrf_token" value="{{.CSRFToken}}">

templates/source_detail.html

@@ -5,7 +5,7 @@
 {{define "content"}}
 <div class="max-w-6xl mx-auto px-6 py-8" x-data="{ showAddEntrypoint: false, showAddTarget: false }">
     <div class="mb-6">
-        <a href="/hooks" class="text-sm text-primary-600 hover:text-primary-700">&larr; Back to webhooks</a>
+        <a href="/sources" class="text-sm text-primary-600 hover:text-primary-700">&larr; Back to webhooks</a>
         <div class="flex justify-between items-center mt-2">
             <div>
                 <h1 class="text-2xl font-medium text-gray-900">{{.Webhook.Name}}</h1>
@@ -14,9 +14,9 @@
                 {{end}}
             </div>
             <div class="flex gap-2">
-                <a href="/hook/{{.Webhook.ID}}/events" class="btn-secondary">Full Event Log</a>
+                <a href="/source/{{.Webhook.ID}}/logs" class="btn-secondary">Event Log</a>
-                <a href="/hook/{{.Webhook.ID}}/edit" class="btn-secondary">Edit</a>
+                <a href="/source/{{.Webhook.ID}}/edit" class="btn-secondary">Edit</a>
-                <form method="POST" action="/hook/{{.Webhook.ID}}/delete" onsubmit="return confirm('Delete this webhook and all its data?')">
+                <form method="POST" action="/source/{{.Webhook.ID}}/delete" onsubmit="return confirm('Delete this webhook and all its data?')">
                     <input type="hidden" name="csrf_token" value="{{.CSRFToken}}">
                     <button type="submit" class="btn-danger">Delete</button>
                 </form>
@@ -39,7 +39,7 @@
 
             <!-- Add entrypoint form -->
             <div x-show="showAddEntrypoint" x-cloak class="p-4 bg-gray-50 border-b border-gray-200">
-                <form method="POST" action="/hook/{{.Webhook.ID}}/entrypoints" class="flex gap-2">
+                <form method="POST" action="/source/{{.Webhook.ID}}/entrypoints" class="flex gap-2">
                     <input type="hidden" name="csrf_token" value="{{.CSRFToken}}">
                     <input type="text" name="description" placeholder="Description (optional)" class="input text-sm flex-1">
                     <button type="submit" class="btn-primary text-sm">Add</button>
@@ -57,20 +57,20 @@
                             {{else}}
                             <span class="badge-error">Inactive</span>
                             {{end}}
-                            <form method="POST" action="/hook/{{$.Webhook.ID}}/entrypoints/{{.ID}}/toggle" class="inline">
+                            <form method="POST" action="/source/{{$.Webhook.ID}}/entrypoints/{{.ID}}/toggle" class="inline">
                                 <input type="hidden" name="csrf_token" value="{{$.CSRFToken}}">
                                 <button type="submit" class="text-xs text-gray-500 hover:text-primary-600" title="{{if .Active}}Deactivate{{else}}Activate{{end}}">
                                     {{if .Active}}Deactivate{{else}}Activate{{end}}
                                 </button>
                             </form>
-                            <form method="POST" action="/hook/{{$.Webhook.ID}}/entrypoints/{{.ID}}/delete" onsubmit="return confirm('Delete this entrypoint?')" class="inline">
+                            <form method="POST" action="/source/{{$.Webhook.ID}}/entrypoints/{{.ID}}/delete" onsubmit="return confirm('Delete this entrypoint?')" class="inline">
                                 <input type="hidden" name="csrf_token" value="{{$.CSRFToken}}">
                                 <button type="submit" class="text-xs text-red-500 hover:text-red-700" title="Delete">Delete</button>
                             </form>
                         </div>
                     </div>
                     <div class="flex items-start gap-2 mt-1">
-                        <code id="entrypoint-url-{{.ID}}" class="text-xs text-gray-500 break-all block flex-1">{{$.BaseURL}}/h/{{.Path}}</code>
+                        <code id="entrypoint-url-{{.ID}}" class="text-xs text-gray-500 break-all block flex-1">{{$.BaseURL}}/webhook/{{.Path}}</code>
                         <!-- Hidden until app.js reveals it; without the
                              script the URL above stays selectable. -->
                         <button type="button" hidden data-copy-target="entrypoint-url-{{.ID}}" class="text-xs text-gray-500 hover:text-primary-600">Copy</button>
@@ -98,7 +98,7 @@
 
             <!-- Add target form -->
             <div x-show="showAddTarget" x-cloak class="p-4 bg-gray-50 border-b border-gray-200">
-                <form method="POST" action="/hook/{{.Webhook.ID}}/targets" x-data="{ targetType: 'http' }" class="space-y-3">
+                <form method="POST" action="/source/{{.Webhook.ID}}/targets" x-data="{ targetType: 'http' }" class="space-y-3">
                     <input type="hidden" name="csrf_token" value="{{.CSRFToken}}">
                     <div class="flex gap-2">
                         <input type="text" name="name" placeholder="Target name" required class="input text-sm flex-1">
@@ -151,14 +151,14 @@
                             {{else}}
                             <span class="badge-error">Inactive</span>
                             {{end}}
-                            <a href="/hook/{{$.Webhook.ID}}/targets/{{.ID}}/edit" class="text-xs text-gray-500 hover:text-primary-600" title="Edit">Edit</a>
+                            <a href="/source/{{$.Webhook.ID}}/targets/{{.ID}}/edit" class="text-xs text-gray-500 hover:text-primary-600" title="Edit">Edit</a>
-                            <form method="POST" action="/hook/{{$.Webhook.ID}}/targets/{{.ID}}/toggle" class="inline">
+                            <form method="POST" action="/source/{{$.Webhook.ID}}/targets/{{.ID}}/toggle" class="inline">
                                 <input type="hidden" name="csrf_token" value="{{$.CSRFToken}}">
                                 <button type="submit" class="text-xs text-gray-500 hover:text-primary-600" title="{{if .Active}}Deactivate{{else}}Activate{{end}}">
                                     {{if .Active}}Deactivate{{else}}Activate{{end}}
                                 </button>
                             </form>
-                            <form method="POST" action="/hook/{{$.Webhook.ID}}/targets/{{.ID}}/delete" onsubmit="return confirm('Delete this target?')" class="inline">
+                            <form method="POST" action="/source/{{$.Webhook.ID}}/targets/{{.ID}}/delete" onsubmit="return confirm('Delete this target?')" class="inline">
                                 <input type="hidden" name="csrf_token" value="{{$.CSRFToken}}">
                                 <button type="submit" class="text-xs text-red-500 hover:text-red-700" title="Delete">Delete</button>
                             </form>
@@ -182,7 +182,7 @@
     <div class="card mt-6">
         <div class="p-4 border-b border-gray-200 flex justify-between items-center">
             <h2 class="text-lg font-medium text-gray-900">50 Most Recent Events</h2>
-            <a href="/hook/{{.Webhook.ID}}/events" class="btn-text text-sm">Full Event Log</a>
+            <a href="/source/{{.Webhook.ID}}/logs" class="btn-text text-sm">View All</a>
         </div>
         <div class="divide-y divide-gray-100">
             {{range .Events}}

templates/source_edit.html

@@ -5,7 +5,7 @@
 {{define "content"}}
 <div class="max-w-2xl mx-auto px-6 py-8">
     <div class="mb-6">
-        <a href="/hook/{{.Webhook.ID}}" class="text-sm text-primary-600 hover:text-primary-700">&larr; Back to {{.Webhook.Name}}</a>
+        <a href="/source/{{.Webhook.ID}}" class="text-sm text-primary-600 hover:text-primary-700">&larr; Back to {{.Webhook.Name}}</a>
         <h1 class="text-2xl font-medium text-gray-900 mt-2">Edit Webhook</h1>
     </div>
 
@@ -14,7 +14,7 @@
         <div class="alert-error">{{.Error}}</div>
         {{end}}
 
-        <form method="POST" action="/hook/{{.Webhook.ID}}/edit" class="space-y-6">
+        <form method="POST" action="/source/{{.Webhook.ID}}/edit" class="space-y-6">
             <input type="hidden" name="csrf_token" value="{{.CSRFToken}}">
             <div class="form-group">
                 <label for="name" class="label">Name</label>
@@ -34,7 +34,7 @@
 
             <div class="flex gap-3">
                 <button type="submit" class="btn-primary">Save Changes</button>
-                <a href="/hook/{{.Webhook.ID}}" class="btn-secondary">Cancel</a>
+                <a href="/source/{{.Webhook.ID}}" class="btn-secondary">Cancel</a>
             </div>
         </form>
     </div>

templates/source_logs.html

@@ -1,13 +1,13 @@
 {{template "base" .}}
 
-{{define "title"}}Full Event Log - {{.Webhook.Name}} - Webhooker{{end}}
+{{define "title"}}Event Log - {{.Webhook.Name}} - Webhooker{{end}}
 
 {{define "content"}}
 <div class="max-w-6xl mx-auto px-6 py-8">
     <div class="mb-6">
-        <a href="/hook/{{.Webhook.ID}}" class="text-sm text-primary-600 hover:text-primary-700">&larr; Back to {{.Webhook.Name}}</a>
+        <a href="/source/{{.Webhook.ID}}" class="text-sm text-primary-600 hover:text-primary-700">&larr; Back to {{.Webhook.Name}}</a>
         <div class="flex justify-between items-center mt-2">
-            <h1 class="text-2xl font-medium text-gray-900">Full Event Log</h1>
+            <h1 class="text-2xl font-medium text-gray-900">Event Log</h1>
             <span class="text-sm text-gray-500">{{.TotalEvents}} total event{{if ne .TotalEvents 1}}s{{end}}</span>
         </div>
     </div>
@@ -55,7 +55,7 @@
                             {{if .ResubmittedFrom}}Resubmitted from event <span class="font-mono">{{.ResubmittedFromID}}</span>.{{end}}
                             {{if .ResubmitCount}}Resubmitted as {{.ResubmitCount}} new event{{if ne .ResubmitCount 1}}s{{end}}.{{end}}
                         </div>
-                        <form method="POST" action="/hook/{{$.Webhook.ID}}/events/{{.ID}}/resubmit" class="inline">
+                        <form method="POST" action="/source/{{$.Webhook.ID}}/events/{{.ID}}/resubmit" class="inline">
                             <input type="hidden" name="csrf_token" value="{{$.CSRFToken}}">
                             <input type="hidden" name="page" value="{{$.Page}}">
                             <button type="submit" class="text-xs text-primary-600 hover:text-primary-700" title="Submit this event again as a new event, to every currently active target">Resubmit</button>
@@ -63,7 +63,7 @@
                     </div>
                     <pre class="text-xs text-gray-700 overflow-x-auto whitespace-pre-wrap break-all">{{.Body}}</pre>
                     {{if .BodyTruncated}}
-                    <p class="mt-2 text-xs text-gray-500">Body truncated for display: showing {{.BodyShownBytes}} of {{.BodyBytes}} bytes. The stored body is unchanged &mdash; <a href="/hook/{{$.Webhook.ID}}/events/{{.ID}}/body" class="text-primary-600 hover:text-primary-700 underline">download the full body</a>.</p>
+                    <p class="mt-2 text-xs text-gray-500">Body truncated for display: showing {{.BodyShownBytes}} of {{.BodyBytes}} bytes. The stored body is unchanged &mdash; <a href="/source/{{$.Webhook.ID}}/logs/{{.ID}}/body" class="text-primary-600 hover:text-primary-700 underline">download the full body</a>.</p>
                     {{end}}
 
                     {{if .Deliveries}}
@@ -79,7 +79,7 @@
                                     </div>
                                     <div class="flex items-center gap-3">
                                         {{if .Status.Terminal}}
-                                        <form method="POST" action="/hook/{{$.Webhook.ID}}/deliveries/{{.ID}}/replay" class="inline" @click.stop>
+                                        <form method="POST" action="/source/{{$.Webhook.ID}}/deliveries/{{.ID}}/replay" class="inline" @click.stop>
                                             <input type="hidden" name="csrf_token" value="{{$.CSRFToken}}">
                                             <input type="hidden" name="page" value="{{$.Page}}">
                                             <button type="submit" class="text-xs text-primary-600 hover:text-primary-700" title="Send this event to the target again">Replay</button>
@@ -139,11 +139,11 @@
     {{if or .HasPrev .HasNext}}
     <div class="flex justify-center gap-2 mt-6">
         {{if .HasPrev}}
-        <a href="/hook/{{.Webhook.ID}}/events?page={{.PrevPage}}" class="btn-secondary text-sm">&larr; Previous</a>
+        <a href="/source/{{.Webhook.ID}}/logs?page={{.PrevPage}}" class="btn-secondary text-sm">&larr; Previous</a>
         {{end}}
         <span class="inline-flex items-center px-4 py-2 text-sm text-gray-500">Page {{.Page}} of {{.TotalPages}}</span>
         {{if .HasNext}}
-        <a href="/hook/{{.Webhook.ID}}/events?page={{.NextPage}}" class="btn-secondary text-sm">Next &rarr;</a>
+        <a href="/source/{{.Webhook.ID}}/logs?page={{.NextPage}}" class="btn-secondary text-sm">Next &rarr;</a>
         {{end}}
     </div>
     {{end}}

templates/sources_list.html

@@ -6,7 +6,7 @@
 <div class="max-w-6xl mx-auto px-6 py-8">
     <div class="flex justify-between items-center mb-6">
         <h1 class="text-2xl font-medium text-gray-900">Webhooks</h1>
-        <a href="/hooks/new" class="btn-primary">
+        <a href="/sources/new" class="btn-primary">
             <svg class="w-5 h-5 mr-1" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                 <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 4v16m8-8H4"/>
             </svg>
@@ -17,7 +17,7 @@
     {{if .Webhooks}}
     <div class="grid gap-4">
         {{range .Webhooks}}
-        <a href="/hook/{{.ID}}" class="card-elevated p-6 block">
+        <a href="/source/{{.ID}}" class="card-elevated p-6 block">
             <div class="flex justify-between items-start">
                 <div>
                     <h2 class="text-lg font-medium text-gray-900">{{.Name}}</h2>
@@ -42,7 +42,7 @@
         </svg>
         <h2 class="text-lg font-medium text-gray-900 mb-2">No webhooks yet</h2>
         <p class="text-gray-500 mb-6">Create your first webhook to start receiving and forwarding events.</p>
-        <a href="/hooks/new" class="btn-primary">Create Webhook</a>
+        <a href="/sources/new" class="btn-primary">Create Webhook</a>
     </div>
     {{end}}
 </div>

templates/sources_new.html

@@ -5,7 +5,7 @@
 {{define "content"}}
 <div class="max-w-2xl mx-auto px-6 py-8">
     <div class="mb-6">
-        <a href="/hooks" class="text-sm text-primary-600 hover:text-primary-700">&larr; Back to webhooks</a>
+        <a href="/sources" class="text-sm text-primary-600 hover:text-primary-700">&larr; Back to webhooks</a>
         <h1 class="text-2xl font-medium text-gray-900 mt-2">Create Webhook</h1>
     </div>
 
@@ -14,7 +14,7 @@
         <div class="alert-error">{{.Error}}</div>
         {{end}}
 
-        <form method="POST" action="/hooks/new" class="space-y-6">
+        <form method="POST" action="/sources/new" class="space-y-6">
             <input type="hidden" name="csrf_token" value="{{.CSRFToken}}">
             <div class="form-group">
                 <label for="name" class="label">Name</label>
@@ -34,7 +34,7 @@
 
             <div class="flex gap-3">
                 <button type="submit" class="btn-primary">Create Webhook</button>
-                <a href="/hooks" class="btn-secondary">Cancel</a>
+                <a href="/sources" class="btn-secondary">Cancel</a>
             </div>
         </form>
     </div>

templates/target_edit.html

@@ -5,7 +5,7 @@
 {{define "content"}}
 <div class="max-w-2xl mx-auto px-6 py-8">
     <div class="mb-6">
-        <a href="/hook/{{.Webhook.ID}}" class="text-sm text-primary-600 hover:text-primary-700">&larr; Back to {{.Webhook.Name}}</a>
+        <a href="/source/{{.Webhook.ID}}" class="text-sm text-primary-600 hover:text-primary-700">&larr; Back to {{.Webhook.Name}}</a>
         <h1 class="text-2xl font-medium text-gray-900 mt-2">Edit Target</h1>
         <p class="text-sm text-gray-500 mt-1">Type: {{.Target.Type}}. A target's type cannot be changed; create a new target to deliver a different way.</p>
     </div>
@@ -21,7 +21,7 @@
         </div>
         {{end}}
 
-        <form method="POST" action="/hook/{{.Webhook.ID}}/targets/{{.Target.ID}}/edit" class="space-y-6">
+        <form method="POST" action="/source/{{.Webhook.ID}}/targets/{{.Target.ID}}/edit" class="space-y-6">
             <input type="hidden" name="csrf_token" value="{{.CSRFToken}}">
 
             <div class="form-group">
@@ -75,7 +75,7 @@
 
             <div class="flex gap-3">
                 <button type="submit" class="btn-primary">Save Changes</button>
-                <a href="/hook/{{.Webhook.ID}}" class="btn-secondary">Cancel</a>
+                <a href="/source/{{.Webhook.ID}}" class="btn-secondary">Cancel</a>
             </div>
         </form>
     </div>