rails_webhook_outbox 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78b2ef77e9c0d4c8e0805566fd1da1e813b5e60163b3032f0584267a925803e3
-  data.tar.gz: 9a3154d6f2029879ed18aaf83548e9a950f27a27057c9a3c517363eaca21ca3e
+  metadata.gz: b4c853b16c9d48f970ebe2ccb83c7de3e1d6789d93a9e78407f788b6a5f8dd8d
+  data.tar.gz: a9a380da628a0f00c0d6d5ac08d2351edbc1e0fc3084b4d73ce6dab7e1f28c44
 SHA512:
-  metadata.gz: 4e527d2e705089dc96fbba1f913c15d03a5c1ed54b221c4e26dbd1b97d3aae10ad58dc8f910d1db090d6846438302fbef079c78cac0a58b6bca0b50c7c941b2d
-  data.tar.gz: fd935881ea40dc8e68fd3b4df3a240adf2f23b7c60e5ce938865a1f59b2f74e4e3a62123bffa6553428bb52b709d4e289adb5219bcaf75ec64b16ca38ca7c265
+  metadata.gz: 452c56fedabd11ecd4a9388af0fa7de18b4988c60585c4b567a2b28d9657ee5226ba3b492bcab0752cc29be2d843e2c329092c32391e52311e85dfd460c24f85
+  data.tar.gz: e464b60386edada571d92ad803f0c074e2b152fb4438b63d4e843b1833ff0d65686074a8fe0cc62d3817b50241d28aebc068d47605443be5cc4c6e5a5defa657

data/README.md

@@ -17,13 +17,20 @@ A Rails engine for sending outgoing webhooks with HMAC signing, ActiveJob-based
 - [Subscriptions](#subscriptions)
 - [Deliveries](#deliveries)
 - [Async Delivery](#async-delivery)
+- [Instrumentation](#instrumentation)
+- [Logging](#logging)
 - [HTTP Request Format](#http-request-format)
 - [HMAC Signing](#hmac-signing)
+- [Secret Rotation](#secret-rotation)
+- [Circuit Breaker](#circuit-breaker)
+- [Dashboard](#dashboard)
+- [Rake Tasks](#rake-tasks)
 - [Usage](#usage)
 - [Manual Dispatch](#manual-dispatch)
 - [Testing](#testing)
 - [Development](#development)
   - [Dummy App](#dummy-app)
+- [Upgrading](#upgrading)
 - [Contributing](#contributing)
 - [License](#license)
 
@@ -41,13 +48,16 @@ And then execute:
 $ bundle install
 ```
 
-Run the install generator:
+Run the install generator, then migrate:
 
 ```bash
 $ rails generate rails_webhook_outbox:install
 $ rails db:migrate
 ```
 
+The generator creates `config/initializers/rails_webhook_outbox.rb`. It does not copy any migrations:
+the engine adds its own to your app's migration paths, so `rails db:migrate` creates the tables.
+
 ## Configuration
 
 ```ruby
@@ -66,6 +76,9 @@ RailsWebhookOutbox.configure do |config|
   config.request_timeout    = 5
   config.delivery_job_queue = :webhooks
   config.max_payload_size   = 65_536  # bytes; set to nil or 0 to disable
+  config.secret_rotation_grace_period = 24.hours
+  config.circuit_breaker_threshold = 10  # consecutive permanent failures before auto-disabling; nil or 0 disables
+  config.dashboard_enabled = true        # enable the mountable dashboard UI; defaults to true in development
 end
 ```
 
@@ -129,6 +142,23 @@ RailsWebhookOutbox::Delivery.delivered   # successfully delivered
 RailsWebhookOutbox::Delivery.failed      # exhausted all retries
 ```
 
+Every HTTP attempt is also recorded as a `RailsWebhookOutbox::DeliveryAttempt`, so earlier failures
+are kept after a retry succeeds (the delivery itself only stores the latest response):
+
+```ruby
+delivery.delivery_attempts.each do |attempt|
+  attempt.attempt_number  # => 1, 2, 3, ...
+  attempt.outcome         # => "failed" or "delivered"
+  attempt.response_code   # => 503
+  attempt.response_body   # => truncated to 1000 characters
+  attempt.duration_ms     # => 182
+  attempt.created_at
+end
+```
+
+Attempts are deleted with their delivery, including by `webhook_outbox:cleanup`. Upgrading from a
+version before 0.4.0 requires a migration — see [Upgrading](#upgrading).
+
 [Back to top](#table-of-contents)
 
 ## Async Delivery
@@ -162,6 +192,69 @@ RailsWebhookOutbox::DeliveryJob.perform_later(delivery)
 
 [Back to top](#table-of-contents)
 
+## Instrumentation
+
+`DeliveryJob` publishes `ActiveSupport::Notifications` events you can subscribe to for logging, metrics, or alerting:
+
+| Event | When |
+|-------|------|
+| `webhook.delivered.rails_webhook_outbox` | Delivery succeeded (2xx response) |
+| `webhook.failed.rails_webhook_outbox` | All retries exhausted — permanent failure |
+| `webhook.circuit_breaker_tripped.rails_webhook_outbox` | A permanent failure auto-disabled the subscription — see [Circuit Breaker](#circuit-breaker) |
+
+`webhook.delivered` / `webhook.failed` payloads include:
+
+| Key | Type | Description |
+|-----|------|-------------|
+| `event` | String | Webhook event name, e.g. `"order.created"` |
+| `subscription_id` | Integer | ID of the `Subscription` record |
+| `delivery_id` | Integer | ID of the `Delivery` record |
+| `duration` | Integer | HTTP round-trip time in milliseconds |
+
+`webhook.circuit_breaker_tripped` payloads include `subscription_id` and `consecutive_failures`.
+
+Subscribe in an initializer:
+
+```ruby
+ActiveSupport::Notifications.subscribe("webhook.delivered.rails_webhook_outbox") do |*args|
+  event = ActiveSupport::Notifications::Event.new(*args)
+  Rails.logger.info "[webhook] delivered #{event.payload[:event]} in #{event.payload[:duration]}ms"
+end
+
+ActiveSupport::Notifications.subscribe("webhook.failed.rails_webhook_outbox") do |*args|
+  event = ActiveSupport::Notifications::Event.new(*args)
+  Sentry.capture_message("Webhook permanently failed", extra: event.payload)
+end
+```
+
+[Back to top](#table-of-contents)
+
+## Logging
+
+`Sender` and `DeliveryJob` emit structured `Rails.logger` output for every delivery lifecycle event. All lines are prefixed `[RailsWebhookOutbox]` in key=value format, making them easy to grep and compatible with Logfmt-aware log aggregators (Datadog, Papertrail, etc.).
+
+| Source | Level | When | Keys logged |
+|--------|-------|------|-------------|
+| `Sender` | `info` | Before each HTTP call | `event`, `key` (idempotency key), `url` |
+| `DeliveryJob` | `info` | Successful delivery | `event`, `delivery_id`, `subscription_id`, `status`, `duration` |
+| `DeliveryJob` | `warn` | Retryable failure | `event`, `delivery_id`, `subscription_id`, `status`, `attempt`, `next_retry_at` |
+| `DeliveryJob` | `error` | Permanent failure (all retries exhausted) | `event`, `delivery_id`, `subscription_id`, `status`, `attempts` |
+| `DeliveryJob` | `warn` | Circuit breaker tripped | `subscription_id`, `consecutive_failures` |
+
+Example lines:
+
+```
+[RailsWebhookOutbox] attempt event=order.created key=550e8400-e29b-41d4-a716-446655440000 url=https://example.com/webhooks
+[RailsWebhookOutbox] delivered event=order.created delivery_id=1 subscription_id=1 status=200 duration=45ms
+[RailsWebhookOutbox] retry event=order.created delivery_id=1 subscription_id=1 status=503 attempt=1 next_retry_at=2026-07-01T00:00:13Z
+[RailsWebhookOutbox] failed event=order.created delivery_id=1 subscription_id=1 status=503 attempts=3
+[RailsWebhookOutbox] circuit_breaker_tripped subscription_id=1 consecutive_failures=10
+```
+
+No configuration is required — logging is always on and respects your application's log level.
+
+[Back to top](#table-of-contents)
+
 ## HTTP Request Format
 
 Each webhook delivery is an HTTP POST to the subscription URL with the following headers and body:
@@ -195,11 +288,14 @@ Every outgoing request includes an `X-Webhook-Signature` header (configurable) c
 X-Webhook-Signature: sha256=a1b2c3d4...
 ```
 
-Subscribers can verify the signature:
+Subscribers can verify the signature. The header may contain more than one comma-separated
+`algorithm=digest` pair while a subscription's secret is [rotating](#secret-rotation), so check
+each one and accept the request if any match:
 
 ```ruby
-expected = RailsWebhookOutbox::Signature.header_value(raw_body, subscription.secret)
-Rack::Utils.secure_compare(expected, request.headers["X-Webhook-Signature"])
+expected = RailsWebhookOutbox::Signature.sign(raw_body, subscription.secret, :sha256)
+signatures = request.headers["X-Webhook-Signature"].to_s.split(",")
+valid = signatures.any? { |sig| Rack::Utils.secure_compare(sig, "sha256=#{expected}") }
 ```
 
 You can also call the primitives directly:
@@ -214,6 +310,114 @@ RailsWebhookOutbox::Signature.header_value(payload, secret)
 # => "sha256=a1b2c3d4..."
 ```
 
+`header_value` also accepts an array of secrets, signing the payload with each one and joining the
+results with a comma — this is how dual-secret signing works during [secret rotation](#secret-rotation).
+
+[Back to top](#table-of-contents)
+
+## Secret Rotation
+
+Rotate a subscription's HMAC secret without dropping any webhook deliveries:
+
+```ruby
+sub.rotate_secret!
+```
+
+This generates a new secret and moves the old one to `previous_secret`, valid until
+`previous_secret_expires_at` (set from `config.secret_rotation_grace_period`, default 24 hours).
+Pass `grace_period:` to override it for a single rotation:
+
+```ruby
+sub.rotate_secret!(grace_period: 3.days)
+```
+
+Calling `rotate_secret!` again while a previous secret is still within its grace period raises
+`RailsWebhookOutbox::SecretRotationError`, since the schema only holds one previous secret — doing
+so would silently invalidate a secret subscribers may not have finished transitioning to yet. Pass
+`force: true` to rotate anyway and discard it immediately.
+
+While `previous_secret` is still active, every outgoing request is signed with **both** secrets —
+`X-Webhook-Signature` carries a comma-separated list of `algorithm=digest` pairs:
+
+```
+X-Webhook-Signature: sha256=<new-secret-digest>,sha256=<previous-secret-digest>
+```
+
+See [HMAC Signing](#hmac-signing) for how subscribers should verify a header that may contain more
+than one signature.
+
+[Back to top](#table-of-contents)
+
+## Circuit Breaker
+
+Each `Subscription` tracks `consecutive_failures` — how many deliveries in a row have permanently
+failed (all retries exhausted). A successful delivery resets it to zero.
+
+Once `consecutive_failures` reaches `config.circuit_breaker_threshold` (default 10), the
+subscription is automatically disabled (`active: false`) so a persistently failing endpoint stops
+being hammered — deliveries already in flight are skipped rather than retried further once their
+subscription is disabled — and `webhook.circuit_breaker_tripped.rails_webhook_outbox` is published:
+
+```ruby
+ActiveSupport::Notifications.subscribe("webhook.circuit_breaker_tripped.rails_webhook_outbox") do |*args|
+  event = ActiveSupport::Notifications::Event.new(*args)
+  Sentry.capture_message("Webhook subscription auto-disabled",
+    extra: event.payload.slice(:subscription_id, :consecutive_failures))
+end
+```
+
+Set `config.circuit_breaker_threshold` to `nil` or `0` to disable auto-disabling entirely. Retryable
+(non-final) failures don't count towards the threshold — only a delivery that has exhausted all
+retries counts as one consecutive failure. Re-enable a tripped subscription with
+`sub.update!(active: true)`; `consecutive_failures` resets to zero immediately on reactivation, so a
+single subsequent failure won't instantly re-trip the breaker.
+
+[Back to top](#table-of-contents)
+
+## Dashboard
+
+Mount the engine to get a browser dashboard for managing subscriptions and browsing deliveries:
+
+```ruby
+# config/routes.rb
+mount RailsWebhookOutbox::Engine => "/admin/webhooks"
+```
+
+The dashboard is gated by `config.dashboard_enabled` (default: `true` in development, `false`
+elsewhere) — set it explicitly to control access, and put the mount behind your own
+authentication/authorization in `routes.rb` (e.g. `constraints AdminConstraint.new do ... end`) since
+the engine itself has no concept of users.
+
+Pages:
+
+| Page | Purpose |
+|------|---------|
+| `/` | Overview — subscription/delivery counts, recent failures |
+| `/subscriptions` | List, create, and edit subscriptions; enable/disable with one click |
+| `/subscriptions/:id` | Detail — masked signing secret with reveal/copy, rotate-secret button |
+| `/deliveries` | Filterable delivery log (status, event, date range) with live status updates via Turbo Streams |
+| `/deliveries/:id` | Detail — attempt timeline, payload, response, and a manual retry button for failed deliveries |
+| `/events` | Registered events with subscriber counts and a recent payload example |
+
+The UI ships its own assets (CSS inlined, JS via importmap) and follows the system light/dark color
+scheme automatically — no asset pipeline configuration is required beyond what a standard Rails 7+
+app already has.
+
+[Back to top](#table-of-contents)
+
+## Rake Tasks
+
+```bash
+bin/rails webhook_outbox:retry_failed         # re-enqueue all failed deliveries for retry
+bin/rails webhook_outbox:list_subscriptions   # list subscriptions with status, events, and failure count
+bin/rails webhook_outbox:cleanup[7]           # delete delivered/failed deliveries older than N days
+```
+
+`retry_failed` resets each failed delivery to `pending` and enqueues a `DeliveryJob`; deliveries
+whose subscription has since been disabled are skipped by the job itself, not by the task.
+`cleanup[days]` requires a positive integer argument and only removes deliveries in a terminal
+state (`delivered` or `failed`) — `pending` deliveries are never deleted.
+
 [Back to top](#table-of-contents)
 
 ## Usage
@@ -384,6 +588,16 @@ RailsWebhookOutbox::Subscription.first.update!(url: "https://webhook.site/your-i
 
 [Back to top](#table-of-contents)
 
+## Upgrading
+
+Some releases need action from you, such as a database migration. Read [UPGRADING.md](UPGRADING.md)
+before updating the gem, and check the **BREAKING** entries in the [CHANGELOG](CHANGELOG.md).
+
+**0.4.0 requires a new table** (`webhook_outbox_delivery_attempts`): run `bin/rails db:migrate`
+before deploying. See [Upgrading to 0.4.0](UPGRADING.md#upgrading-to-040).
+
+[Back to top](#table-of-contents)
+
 ## Contributing
 
 Bug reports and pull requests are welcome on [GitHub](https://github.com/eclectic-coding/rails_webhook_outbox).

data/Rakefile

@@ -13,4 +13,9 @@ RuboCop::RakeTask.new(:lint)
 Bundler::Audit::Task.new
 RSpec::Core::RakeTask.new(:spec)
 
-task default: [:lint, :'bundle:audit:update', 'bundle:audit:check', :spec]
+desc "Run Brakeman static security analysis"
+task :brakeman do
+  sh "bundle exec brakeman -q --no-pager --force-scan --skip-files spec/ ."
+end
+
+task default: [:lint, :'bundle:audit:update', 'bundle:audit:check', :brakeman, :spec]

data/UPGRADING.md

@@ -0,0 +1,92 @@
+# Upgrading
+
+Notes for upgrades that need action from you, newest version first. For everything that changed in a
+release, see the [CHANGELOG](CHANGELOG.md).
+
+## Upgrading to 0.4.0
+
+**This release has a breaking change: it requires a new database table.** Run the migration _before_
+the 0.4.0 code starts processing deliveries.
+
+### What changed
+
+`DeliveryJob` now records every HTTP attempt as a `RailsWebhookOutbox::DeliveryAttempt` in the new
+`webhook_outbox_delivery_attempts` table. This is the data behind the delivery timeline in the
+dashboard. Previously only the latest response was kept on the delivery itself.
+
+### Steps
+
+1. Update the gem:
+
+   ```bash
+   bundle update rails_webhook_outbox
+   ```
+
+2. Run the migration. The engine adds its migrations to your app's migration paths, so there is
+   nothing to copy:
+
+   ```bash
+   bin/rails db:migrate
+   ```
+
+3. Confirm it ran:
+
+   ```bash
+   bin/rails db:migrate:status | grep delivery_attempts
+   # up     20261027000001  Create webhook outbox delivery attempts
+   ```
+
+In a deploy pipeline, run `db:migrate` before the new code starts serving requests or running jobs
+(the usual release-phase step on most hosts).
+
+### If you ran the install generator on an earlier version
+
+Before 0.4.0, `rails generate rails_webhook_outbox:install` also copied the engine's table migrations
+into your app's `db/migrate`. The engine adds those same migrations to your app on its own, so with
+the copies present `db:migrate` fails:
+
+```
+ActiveRecord::DuplicateMigrationNameError: Multiple migrations have the name CreateWebhookOutboxSubscriptions.
+```
+
+To fix it, delete the copies and migrate. The engine's migrations now skip tables, columns, and
+indexes that already exist, so they are safe to run against a database the copies already built:
+
+```bash
+rm db/migrate/*_create_webhook_outbox_subscriptions.rb \
+   db/migrate/*_create_webhook_outbox_deliveries.rb
+bin/rails db:migrate
+```
+
+Commit the deletions. `db:migrate:status` will keep listing the old copied versions as `NO FILE`;
+that is harmless. The run also adds anything the copies lacked, such as the unique index on
+`idempotency_key`, and creates the new `webhook_outbox_delivery_attempts` table.
+
+### If you deploy the code without migrating
+
+`DeliveryJob` sends the HTTP request first and records the attempt afterwards. Without the table,
+recording the attempt raises `ActiveRecord::StatementInvalid`, so:
+
+- the webhook **is still sent** to the subscriber, but the delivery is left `pending` with
+  `attempts: 0`, and the engine's `DeliveryError` retry does not apply to this error;
+- every job fails the same way until the migration is run.
+
+Run `db:migrate`, then re-enqueue the stuck deliveries:
+
+```ruby
+RailsWebhookOutbox::Delivery.pending.find_each { |d| RailsWebhookOutbox::DeliveryJob.perform_later(d) }
+```
+
+The subscriber will receive those webhooks a second time. It can deduplicate them with the
+`X-Webhook-Delivery` header, which is stable across attempts. (`webhook_outbox:retry_failed` does not
+help here: it only re-enqueues `failed` deliveries.)
+
+### Existing data
+
+Deliveries created before the upgrade have no attempt history; it starts with the first attempt made
+after the migration. Nothing is backfilled.
+
+### Downgrading
+
+Downgrading the gem back to 0.3.0 is safe without rolling the migration back: 0.3.0 never reads the
+table, and the foreign key cascades on delete, so `webhook_outbox:cleanup` keeps working.

data/app/assets/stylesheets/rails_webhook_outbox/_01_base.css

@@ -0,0 +1,53 @@
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+
+:root {
+  --bg:            #f8f9fa;
+  --surface:       #ffffff;
+  --border:        #dee2e6;
+  --text:          #212529;
+  --muted:         #6c757d;
+  --accent:        #4f46e5;
+  --accent-text:   #ffffff;
+  --danger:        #dc3545;
+  --success-bg:    #d1e7dd;
+  --success-text:  #0f5132;
+  --warning-bg:    #fff3cd;
+  --warning-text:  #664d03;
+  --danger-bg:     #f8d7da;
+  --danger-text:   #842029;
+  --radius:        6px;
+  --shadow:        0 1px 3px rgba(0,0,0,.08);
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --bg:            #16181d;
+    --surface:       #1f2229;
+    --border:        #333844;
+    --text:          #e9ecef;
+    --muted:         #9aa1ac;
+    --accent:        #7c7ff2;
+    --accent-text:   #ffffff;
+    --danger:        #e25563;
+    --success-bg:    #10321f;
+    --success-text:  #7fe0a4;
+    --warning-bg:    #3a2f0b;
+    --warning-text:  #f0c96b;
+    --danger-bg:     #3a1216;
+    --danger-text:   #f0949c;
+    --shadow:        0 1px 3px rgba(0,0,0,.4);
+  }
+}
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+  font-size: 14px;
+  line-height: 1.5;
+  color: var(--text);
+  background: var(--bg);
+}
+
+a { color: var(--accent); }
+
+.rwo-monospace { font-family: ui-monospace, "SFMono-Regular", Menlo, monospace; font-size: 12px; }
+.rwo-muted     { color: var(--muted); font-size: 12px; }

data/app/assets/stylesheets/rails_webhook_outbox/_02_layout.css

@@ -0,0 +1,88 @@
+.rwo-nav {
+  display: flex;
+  gap: 1.5rem;
+  padding: 1rem 2rem;
+  background: var(--surface);
+  border-bottom: 1px solid var(--border);
+}
+
+.rwo-nav-link {
+  color: var(--text);
+  text-decoration: none;
+  font-weight: 600;
+}
+
+.rwo-nav-link:hover { color: var(--accent); }
+
+.rwo-main { padding: 2rem; max-width: 1100px; margin: 0 auto; }
+
+.rwo-header { margin-bottom: 1.5rem; }
+
+.rwo-header-row {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 1rem;
+  margin-bottom: 1rem;
+}
+
+.rwo-section-title { margin: 1.5rem 0 0.75rem; font-size: 16px; }
+
+.rwo-back { display: inline-block; margin-bottom: 1rem; font-size: 13px; }
+
+.rwo-empty { color: var(--muted); padding: 1rem 0; }
+
+.rwo-stats-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(140px, 1fr));
+  gap: 1rem;
+  margin-bottom: 2rem;
+}
+
+.rwo-stat {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  box-shadow: var(--shadow);
+  padding: 1rem;
+}
+
+.rwo-stat-label { color: var(--muted); font-size: 12px; text-transform: uppercase; letter-spacing: .04em; }
+.rwo-stat-value { font-size: 28px; font-weight: 700; }
+
+.rwo-detail {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  box-shadow: var(--shadow);
+  padding: 1rem;
+  margin-bottom: 1rem;
+}
+
+.rwo-detail-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
+  gap: 1rem;
+}
+
+.rwo-detail-label { color: var(--muted); font-size: 12px; text-transform: uppercase; letter-spacing: .04em; }
+.rwo-detail-value { font-size: 15px; }
+
+.rwo-code-block {
+  background: var(--bg);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  padding: 1rem;
+  overflow-x: auto;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
+.rwo-event {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  box-shadow: var(--shadow);
+  padding: 1rem;
+  margin-bottom: 1rem;
+}

data/app/assets/stylesheets/rails_webhook_outbox/_03_table.css

@@ -0,0 +1,26 @@
+.rwo-table {
+  width: 100%;
+  border-collapse: collapse;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  overflow: hidden;
+}
+
+.rwo-table th, .rwo-table td {
+  text-align: left;
+  padding: 0.6rem 0.75rem;
+  border-bottom: 1px solid var(--border);
+}
+
+.rwo-table th { font-size: 12px; text-transform: uppercase; letter-spacing: .04em; color: var(--muted); }
+
+.rwo-table tbody tr:last-child td { border-bottom: none; }
+
+.rwo-path { font-weight: 600; }
+
+.rwo-pagination {
+  display: flex;
+  justify-content: space-between;
+  margin-top: 1rem;
+}

data/app/assets/stylesheets/rails_webhook_outbox/_04_badges.css

@@ -0,0 +1,19 @@
+.rwo-badge {
+  display: inline-block;
+  padding: 0.2rem 0.6rem;
+  border-radius: 999px;
+  font-size: 12px;
+  font-weight: 600;
+}
+
+.rwo-badge--delivered { background: var(--success-bg); color: var(--success-text); }
+.rwo-badge--pending    { background: var(--warning-bg); color: var(--warning-text); }
+.rwo-badge--failed     { background: var(--danger-bg);  color: var(--danger-text); }
+
+.rwo-alert {
+  background: var(--danger-bg);
+  color: var(--danger-text);
+  border-radius: var(--radius);
+  padding: 0.75rem 1rem;
+  margin-bottom: 1rem;
+}

data/app/assets/stylesheets/rails_webhook_outbox/_05_forms.css

@@ -0,0 +1,42 @@
+.rwo-form { max-width: 480px; }
+
+.rwo-field { margin-bottom: 1rem; }
+
+.rwo-field label { display: block; font-size: 12px; text-transform: uppercase; letter-spacing: .04em; color: var(--muted); margin-bottom: 0.3rem; }
+
+.rwo-input, .rwo-select {
+  width: 100%;
+  padding: 0.5rem 0.6rem;
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  background: var(--surface);
+  color: var(--text);
+  font-size: 14px;
+}
+
+.rwo-checkbox-group { display: flex; flex-direction: column; gap: 0.4rem; }
+.rwo-checkbox-label { display: flex; align-items: center; gap: 0.4rem; font-weight: 400; text-transform: none; letter-spacing: normal; }
+
+.rwo-btn, .rwo-btn-small, .rwo-btn-danger, .rwo-btn-reset {
+  display: inline-block;
+  border: none;
+  border-radius: var(--radius);
+  cursor: pointer;
+  font-size: 14px;
+  font-weight: 600;
+  text-decoration: none;
+}
+
+.rwo-btn { background: var(--accent); color: var(--accent-text); padding: 0.55rem 1rem; }
+.rwo-btn-small { background: var(--surface); color: var(--text); border: 1px solid var(--border); padding: 0.35rem 0.7rem; font-size: 12px; }
+.rwo-btn-danger { background: var(--danger); color: #fff; padding: 0.55rem 1rem; }
+.rwo-btn-reset { background: transparent; color: var(--muted); padding: 0.55rem 0.75rem; }
+
+.rwo-secret {
+  display: flex;
+  align-items: center;
+  gap: 0.6rem;
+  margin-bottom: 0.5rem;
+}
+
+.rwo-secret-display { font-size: 14px; }

data/app/assets/stylesheets/rails_webhook_outbox/_06_filters.css

@@ -0,0 +1,13 @@
+.rwo-filters {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: end;
+  gap: 1rem;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  padding: 1rem;
+  margin-bottom: 1.5rem;
+}
+
+.rwo-filters .rwo-field { margin-bottom: 0; min-width: 140px; }

data/app/assets/stylesheets/rails_webhook_outbox/_07_timeline.css

@@ -0,0 +1,31 @@
+.rwo-timeline {
+  list-style: none;
+  margin-left: 6px;
+  border-left: 2px solid var(--border);
+}
+
+.rwo-timeline-item {
+  position: relative;
+  padding: 0 0 1rem 1.25rem;
+}
+
+.rwo-timeline-item::before {
+  content: "";
+  position: absolute;
+  left: -7px;
+  top: 4px;
+  width: 12px;
+  height: 12px;
+  border-radius: 50%;
+  border: 2px solid var(--bg);
+  background: var(--muted);
+}
+
+.rwo-timeline-item--delivered::before { background: var(--success-text); }
+.rwo-timeline-item--failed::before    { background: var(--danger); }
+.rwo-timeline-item--scheduled::before { background: var(--warning-text); }
+
+.rwo-timeline-title { font-weight: 600; }
+
+.rwo-timeline-response { margin-top: 0.25rem; }
+.rwo-timeline-response summary { cursor: pointer; }