cache_bro 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6287878eefcb94a718dfd1a6d1540355185e989bdc5bc21686933c5a09331f45
+  data.tar.gz: d9ab530ca70ac53107bd557da234b55337824a6523a2596e51f7fd4fc7512e9d
+SHA512:
+  metadata.gz: fac35f3a49ba16a2b2e87afe7c222356ee3904ff5dad45a89a5352913d96644ce23e486ff37c1d15f67f53d31fa4a68f349066ce9f8a2ffe1dc13d5c828b1e8f
+  data.tar.gz: 60fd4404a3f9e3e1d0494f14550cbd3961e0b71fd56d291fcc013be8873b936e72cc8248f4dcc39dea7b88405714e5018740cf3223ea532d1cc454c7f99da62c

data/MIT-LICENSE

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

data/README.md

@@ -0,0 +1,114 @@
+# CacheBro
+
+Browse, inspect and purge your Rails **Redis** cache from the browser, with every action audited.
+
+CacheBro is a section of the [BroHub](https://github.com/rubydevro/bro_hub) dashboard, next to EnvBro and SafeBro.
+It's for teams where developers already have a console: it makes the common cache chores easier to do at scale,
+and makes the ones done through the UI impossible to do unrecorded.
+
+## What it does
+
+| | |
+|---|---|
+| **Keys** | Search keys (plain text matches anywhere, `*` and `?` make a pattern). See expiry and size. |
+| **Reveal** | Show what a key holds. Its own permission, always audited. |
+| **Delete** | Delete one key. |
+| **Purge** | Delete every key matching a pattern. You see how many match first, and a sample. |
+| **Flush** | Delete everything under the store's namespace. You type the store's name to confirm. |
+| **Audit log** | Who revealed, deleted or purged what, how many, and why. Append-only. |
+
+## Install
+
+```ruby
+gem "cache_bro"
+```
+
+```
+bin/rails generate cache_bro:install
+bin/rails db:migrate
+```
+
+The installer sets up BroHub if it isn't yet, adds `config/initializers/cache_bro.rb` and copies the migration.
+CacheBro then lives at `<hub>/cache_bro`.
+
+Give your cache store a **namespace**:
+
+```ruby
+config.cache_store = :redis_cache_store, { url: ENV["REDIS_URL"], namespace: "myapp" }
+```
+
+Everything CacheBro shows or deletes is under that namespace. Without one the cache shares its Redis database
+with whatever else lives there: you'll see a warning, and Flush is disabled.
+
+## Permissions
+
+Plain lambdas, like the other Bro gems. Everything is denied until you say otherwise.
+
+```ruby
+CacheBro.configure do |config|
+  config.can_view_keys   = ->(user) { user&.developer? }  # search keys, see expiry and size
+  config.can_view_values = ->(user) { user&.senior? }     # reveal values (audited)
+  config.can_delete      = ->(user) { user&.developer? }  # delete one key
+  config.can_purge       = ->(user) { user&.lead? }       # delete by pattern
+  config.can_flush       = ->(user) { user&.admin? }      # delete the whole namespace
+  config.can_audit       = ->(user) { user&.admin? }      # read the audit log
+end
+```
+
+Higher includes lower: `flush` includes `purge` and `delete`, `purge` includes `delete`, and all of them include
+`view_keys`. `view_values` and `audit` stand alone on purpose: values can hold personal data, and the people who
+clean the cache shouldn't automatically read it.
+
+## Audit
+
+Every reveal, delete, purge and flush is recorded in `cache_bro_audit_events`: who, what (the key or the pattern,
+never the value), how many keys, which store and environment, when, and the reason if one was given. Entries can't be
+changed or deleted through the model.
+
+- Purges and flushes also keep a sample of the keys deleted.
+- A reveal is recorded **before** the value is shown. If the audit log can't be written, nothing is revealed.
+- If a purge fails part way (Redis goes away), what was deleted up to then is still recorded, marked as incomplete.
+- Require a typed reason with `config.reason_required_for = %i[ purge flush ]` (default). Add `:reveal` and `:delete`
+  if you want one for those too.
+
+Keys can contain personal data too (`user/ann@example.com/...`). Anyone with `view_keys` sees them.
+
+## Safe by construction
+
+- Redis is only walked with `SCAN`, in small steps. Never `KEYS`. A search page that doesn't cover the whole keyspace
+  gives you a "keep looking" link.
+- Every key is put back under the namespace before it touches Redis, so nothing outside it can be named.
+- Purge patterns are used as typed (`posts/*` is a prefix), refuse to match everything, and stop at
+  `config.max_purge_keys` (100,000) per run. Run it again to continue.
+- Values are shown as escaped text, truncated to `config.value_preview_length`. Reveals are `POST`s, so a link
+  prefetcher can't "view" a value.
+- Pages are `Cache-Control: no-store`.
+
+## Several stores
+
+```ruby
+config.stores = {
+  "App cache" => -> { Rails.cache },
+  "Rack::Attack" => -> { Rack::Attack.cache.store }
+}
+```
+
+Only `:redis_cache_store` on a single Redis server is supported for now. Other stores are listed with an
+explanation instead of failing.
+
+## Not a sandbox
+
+CacheBro is a convenience and an audit trail for people who already have console access. Someone with a console can
+still do all of this there, unrecorded. Pair it with [SafeBro](https://github.com/rubydevro/safe_bro) if you want the
+console recorded too.
+
+## Development
+
+```
+bin/rails test        # needs Redis on localhost (REDIS_URL, db 15 by default; only the test namespace is touched)
+bin/rubocop
+```
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/setup"
+
+require "bundler/gem_tasks"

data/app/controllers/cache_bro/application_controller.rb

@@ -0,0 +1,91 @@
+module CacheBro
+  class ApplicationController < CacheBro.config.parent_controller.constantize
+    include BroHub::ControllerBase
+    bro_hub_section :cache_bro
+
+    before_action :cache_bro_require_ssl
+    before_action :cache_bro_no_store
+    before_action :cache_bro_authenticate!
+
+    helper_method :cache_bro_user, :cache_bro_user_label, :cache_bro_store, :cache_bro_allows?
+
+    rescue_from CacheBro::NotAllowed, with: :cache_bro_forbidden
+    rescue_from CacheBro::UnknownStore, with: :cache_bro_unknown_store
+    rescue_from CacheBro::UnsupportedStore, with: :cache_bro_unsupported
+    rescue_from CacheBro::ReasonRequired, CacheBro::InvalidPattern, with: :cache_bro_rejected
+
+    private
+      # The shell shows who is signed in, by CacheBro's rules.
+      def bro_hub_user
+        cache_bro_user
+      end
+
+      def cache_bro_user
+        return @cache_bro_user if defined?(@cache_bro_user)
+
+        @cache_bro_user = CacheBro.config.current_user.call(self)
+      end
+
+      def cache_bro_user_label
+        CacheBro.config.user_label.call(cache_bro_user) if cache_bro_user
+      end
+
+      def cache_bro_allows?(permission)
+        CacheBro.config.allows?(cache_bro_user, permission)
+      end
+
+      def authorize!(permission)
+        raise CacheBro::NotAllowed, "Not allowed" unless cache_bro_allows?(permission)
+      end
+
+      # Anyone who may use some part of CacheBro gets in; each action then checks its own permission.
+      def cache_bro_authenticate!
+        raise CacheBro::NotAllowed, "Not allowed" unless cache_bro_allows?(:view_keys) || cache_bro_allows?(:audit)
+      end
+
+      # The store the page is about: ?store=Name, or the first configured one.
+      def cache_bro_store
+        @cache_bro_store ||= CacheBro.store(params[:store])
+      end
+
+      # The typed reason, or nil. Raises when the action needs one and there is none.
+      def reason_for(action)
+        reason = params[:reason].to_s.strip.presence
+        raise CacheBro::ReasonRequired, "Say why. #{action.to_s.capitalize} needs a reason." if reason.nil? && CacheBro.config.reason_required?(action)
+
+        reason
+      end
+
+      def cache_bro_require_ssl
+        head :forbidden if CacheBro.config.require_ssl && !request.ssl?
+      end
+
+      # Keys and (revealed) values are production data: keep them out of caches.
+      def cache_bro_no_store
+        response.headers["Cache-Control"] = "no-store"
+        response.headers["Pragma"] = "no-cache"
+      end
+
+      def cache_bro_forbidden
+        render "cache_bro/shared/forbidden", status: :forbidden
+      end
+
+      def cache_bro_unknown_store
+        head :not_found
+      end
+
+      def cache_bro_unsupported(error)
+        @unsupported = error.message
+        render "cache_bro/shared/unsupported", status: :unprocessable_entity
+      end
+
+      def cache_bro_rejected(error)
+        redirect_back fallback_location: root_path(store: params[:store]), alert: error.message
+      end
+
+      # A SCAN cursor is a number. Anything else starts over.
+      def cursor_param
+        params[:cursor].to_s.match?(/\A\d+\z/) ? params[:cursor].to_s : "0"
+      end
+  end
+end

data/app/controllers/cache_bro/audit_events_controller.rb

@@ -0,0 +1,38 @@
+module CacheBro
+  class AuditEventsController < ApplicationController
+    PER_PAGE = CacheBro::ApplicationHelper::PER_PAGE
+
+    before_action { authorize!(:audit) }
+    helper_method :filter_params
+
+    def index
+      @filter = filter_params
+      @events = filtered.recent.limit(PER_PAGE).offset(page * PER_PAGE)
+      @total = filtered.count
+      @page = page
+      @counts = filtered.group(:event).count
+    end
+
+    def show
+      @event = AuditEvent.find(params[:id])
+    end
+
+    private
+      def filtered
+        scope = AuditEvent.all
+        scope = scope.where(event: filter_params[:event]) if AuditEvent::EVENTS.include?(filter_params[:event])
+        scope = scope.where(user_label: filter_params[:user]) if filter_params[:user].present?
+        scope = scope.where(store: filter_params[:store]) if filter_params[:store].present?
+        scope = scope.where("target LIKE ?", "%#{AuditEvent.sanitize_sql_like(filter_params[:q])}%") if filter_params[:q].present?
+        scope
+      end
+
+      def filter_params
+        @filter_params ||= params.permit(:event, :user, :store, :q).to_h.symbolize_keys.compact_blank
+      end
+
+      def page
+        [ params[:page].to_i, 0 ].max
+      end
+  end
+end

data/app/controllers/cache_bro/flushes_controller.rb

@@ -0,0 +1,32 @@
+module CacheBro
+  class FlushesController < ApplicationController
+    before_action { authorize!(:flush) }
+
+    def new
+    end
+
+    # Typing the store's name is the confirmation.
+    def create
+      reason = reason_for(:flush)
+      unless params[:confirm].to_s == cache_bro_store.name
+        return redirect_to flush_path(store: cache_bro_store.name), alert: "Type the store name to confirm. Nothing was deleted."
+      end
+
+      result = begin
+        cache_bro_store.flush
+      rescue CacheBro::SweepFailed => error
+        record(error.matches, reason, completed: false)
+        raise
+      end
+      record(result, reason, completed: true)
+
+      redirect_to flush_path(store: cache_bro_store.name), notice: "Flushed #{cache_bro_store.name}: #{helpers.cache_bro_count(result.count, "key")} deleted."
+    end
+
+    private
+      def record(result, reason, completed:)
+        Audit.record(:store_flushed, user: cache_bro_user, store: cache_bro_store.name, count: result.count, reason: reason,
+          namespace: cache_bro_store.namespace, sample: result.sample, completed: completed)
+      end
+  end
+end

data/app/controllers/cache_bro/keys_controller.rb

@@ -0,0 +1,39 @@
+module CacheBro
+  class KeysController < ApplicationController
+    before_action { authorize!(:view_keys) }
+    before_action :load_key, only: %i[ show reveal destroy ]
+
+    def index
+      @query = params[:q].to_s.strip.presence
+      @listing = cache_bro_store.list(query: @query, cursor: cursor_param)
+    end
+
+    def show
+    end
+
+    # A POST, so a link prefetcher can't "view" a value. The audit entry is written first: if it can't be
+    # recorded, nothing is shown.
+    def reveal
+      authorize!(:view_values)
+      reason = reason_for(:reveal)
+      Audit.record(:value_viewed, user: cache_bro_user, store: cache_bro_store.name, target: @key, reason: reason)
+      @value = cache_bro_store.read(@key)
+      render :show
+    end
+
+    def destroy
+      authorize!(:delete)
+      reason = reason_for(:delete)
+      deleted = cache_bro_store.delete(@key)
+      Audit.record(:key_deleted, user: cache_bro_user, store: cache_bro_store.name, target: @key, count: deleted, reason: reason)
+      redirect_to root_path(store: cache_bro_store.name), notice: "Deleted #{@key}."
+    end
+
+    private
+      def load_key
+        @key = params[:key].to_s
+        @entry = cache_bro_store.stat(@key) unless @key.empty?
+        redirect_to root_path(store: cache_bro_store.name), alert: "That key no longer exists." unless @entry
+      end
+  end
+end

data/app/controllers/cache_bro/purges_controller.rb

@@ -0,0 +1,38 @@
+module CacheBro
+  class PurgesController < ApplicationController
+    before_action { authorize!(:purge) }
+
+    def new
+    end
+
+    # Counts what the pattern matches, without deleting, and asks to confirm.
+    def preview
+      @pattern = params[:pattern].to_s.strip
+      @reason = reason_for(:purge)
+      @matches = cache_bro_store.preview(@pattern)
+    end
+
+    def create
+      pattern = params[:pattern].to_s.strip
+      reason = reason_for(:purge)
+      result = begin
+        cache_bro_store.purge(pattern)
+      rescue CacheBro::SweepFailed => error
+        # Whatever got deleted before the failure is still recorded.
+        record(pattern, error.matches, reason, completed: false)
+        raise
+      end
+      record(pattern, result, reason, completed: true)
+
+      notice = "Deleted #{helpers.cache_bro_count(result.count, "key")} matching #{pattern}."
+      notice += " That is the limit for one purge, run it again to continue." if result.truncated
+      redirect_to purge_path(store: cache_bro_store.name), notice: notice
+    end
+
+    private
+      def record(pattern, result, reason, completed:)
+        Audit.record(:keys_purged, user: cache_bro_user, store: cache_bro_store.name, target: pattern, count: result.count,
+          reason: reason, sample: result.sample, truncated: result.truncated, completed: completed)
+      end
+  end
+end

data/app/helpers/cache_bro/application_helper.rb

@@ -0,0 +1,63 @@
+module CacheBro
+  module ApplicationHelper
+    PER_PAGE = 50
+
+    EVENT_LABELS = {
+      "value_viewed" => "Revealed", "key_deleted" => "Deleted", "keys_purged" => "Purged", "store_flushed" => "Flushed"
+    }.freeze
+    EVENT_TONES = { "value_viewed" => "amber", "key_deleted" => "red", "keys_purged" => "red", "store_flushed" => "red" }.freeze
+
+    def cache_bro_time(time)
+      return "-" unless time
+
+      content_tag(:time, time.utc.strftime("%Y-%m-%d %H:%M"), datetime: time.iso8601, title: time.utc.to_s)
+    end
+
+    def cache_bro_ttl(seconds)
+      seconds ? "in #{distance_of_time_in_words(0, seconds.round, include_seconds: true)}" : "no expiry"
+    end
+
+    def cache_bro_size(bytes)
+      bytes ? number_to_human_size(bytes) : "-"
+    end
+
+    def cache_bro_count(count, singular, plural = singular.pluralize)
+      "#{number_with_delimiter(count)} #{count == 1 ? singular : plural}"
+    end
+
+    def cache_bro_event_label(event)
+      EVENT_LABELS.fetch(event.to_s, event.to_s.humanize)
+    end
+
+    def cache_bro_event_tag(event)
+      content_tag(:span, cache_bro_event_label(event), class: "bh-tag is-#{EVENT_TONES.fetch(event.to_s, "muted")}")
+    end
+
+    # A reason box. Required when the config says so for that action.
+    def cache_bro_reason_field(action, placeholder: "Why? (ticket, incident, ...)")
+      required = CacheBro.config.reason_required?(action)
+      label_tag(:reason, class: "bh-field") do
+        safe_join([ (required ? "Reason (required)" : "Reason (optional)"),
+                    text_field_tag(:reason, nil, class: "bh-input", placeholder: placeholder, required: required, autocomplete: "off") ])
+      end
+    end
+
+    # "Next →" for SCAN cursors. There is no "back": a cursor only goes forward.
+    def cache_bro_pager(listing, query:)
+      return unless listing.more?
+
+      content_tag(:div, class: "bh-meta", style: "margin-top:14px") do
+        link_to("Keep looking →", root_path(store: cache_bro_store.name, q: query, cursor: listing.cursor))
+      end
+    end
+
+    # "← Newer / Older →" for audit pages. `page` counts from 0.
+    def cache_bro_audit_pager(total:, page:)
+      newer = link_to("← Newer", url_for(request.query_parameters.merge(page: page - 1))) if page > 0
+      older = link_to("Older →", url_for(request.query_parameters.merge(page: page + 1))) if (page + 1) * PER_PAGE < total
+      content_tag(:div, class: "bh-meta", style: "display:flex;justify-content:space-between;gap:16px;margin-top:14px") do
+        safe_join([ content_tag(:span, cache_bro_count(total, "event")), content_tag(:span, safe_join([ newer, older ].compact, " ")) ])
+      end
+    end
+  end
+end

data/app/models/cache_bro/application_record.rb

@@ -0,0 +1,6 @@
+module CacheBro
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+    self.table_name_prefix = "cache_bro_"
+  end
+end

data/app/models/cache_bro/audit_event.rb

@@ -0,0 +1,25 @@
+module CacheBro
+  # Who revealed, deleted or purged what, and when. Holds keys and patterns, never values.
+  class AuditEvent < ApplicationRecord
+    EVENTS = %w[ value_viewed key_deleted keys_purged store_flushed ].freeze
+
+    validates :event, inclusion: { in: EVENTS }
+    validates :environment, :store, presence: true
+
+    scope :recent, -> { order(created_at: :desc, id: :desc) }
+
+    # Audit entries are append-only.
+    def readonly?
+      persisted?
+    end
+
+    # Keys the action touched, for a purge or flush (a sample, see config.audit_sample_size).
+    def sample
+      Array(details["sample"])
+    end
+
+    def truncated?
+      details["truncated"] == true
+    end
+  end
+end

data/app/views/cache_bro/audit_events/index.html.erb

@@ -0,0 +1,39 @@
+<% bro_hub_crumb "Audit log" %>
+<% content_for :bro_hub_crumb_actions do %>
+  <% [ [ "All", nil ], *CacheBro::AuditEvent::EVENTS.map { |event| [ cache_bro_event_label(event), event ] } ].each do |label, event| %>
+    <%= bro_hub_crumb_link label, audit_path(@filter.merge(event: event).compact), active: @filter[:event] == event %>
+  <% end %>
+<% end %>
+
+<%= bro_hub_hero eyebrow: "Audit log", title: @total, subtitle: @total == 1 ? "event" : "events",
+      lead: "Who revealed, deleted or purged what. Entries can't be changed. Keys and patterns are recorded, never values.",
+      stats: [ [ @counts.fetch("value_viewed", 0), "reveals", :amber ], [ %w[ key_deleted keys_purged store_flushed ].sum { |event| @counts.fetch(event, 0) }, "deletions", :red ] ] %>
+
+<%= form_with url: audit_path, method: :get, class: "bh-filters" do %>
+  <%= hidden_field_tag :event, @filter[:event] if @filter[:event] %>
+  <%= text_field_tag :q, @filter[:q], placeholder: "Search keys and patterns", class: "bh-input is-strong", "aria-label": "Search keys and patterns" %>
+  <%= text_field_tag :user, @filter[:user], placeholder: "User", class: "bh-input", "aria-label": "User" %>
+  <% if CacheBro.config.store_names.size > 1 %>
+    <%= select_tag :store, options_for_select([ [ "Any store", "" ], *CacheBro.config.store_names ], @filter[:store]), class: "bh-select", "aria-label": "Store" %>
+  <% end %>
+  <%= submit_tag "Filter", name: nil, class: "bh-chip" %>
+  <%= link_to "Reset", audit_path(event: @filter[:event]), class: "bh-link-quiet" %>
+<% end %>
+
+<div class="bh-table-wrap">
+  <div class="bh-table" style="--cols: 150px 150px 100px 120px minmax(220px,1fr) 80px; --min: 900px">
+    <div class="bh-row is-head"><span>When</span><span>User</span><span>Action</span><span>Store</span><span>Key or pattern</span><span>Keys</span></div>
+    <% @events.each do |event| %>
+      <%= link_to audit_event_path(event), class: [ "bh-row", ("bh-edge-red" unless event.event == "value_viewed") ] do %>
+        <span class="bh-tone-violet"><%= cache_bro_time(event.created_at) %></span>
+        <span class="bh-cell-strong"><%= event.user_label %></span>
+        <span><%= cache_bro_event_tag(event.event) %></span>
+        <span class="bh-cell-muted"><%= event.store %></span>
+        <span class="bh-cell-text" style="overflow-wrap:anywhere"><%= truncate(event.target.to_s, length: 90) %></span>
+        <span><%= event.count %></span>
+      <% end %>
+    <% end %>
+    <% if @events.empty? %><div class="bh-empty">Nothing recorded.</div><% end %>
+    <%= cache_bro_audit_pager(total: @total, page: @page) %>
+  </div>
+</div>

data/app/views/cache_bro/audit_events/show.html.erb

@@ -0,0 +1,48 @@
+<% bro_hub_crumb "Audit log", "##{@event.id}" %>
+<% content_for :bro_hub_crumb_actions do %>
+  <%= bro_hub_crumb_link "← Audit log", audit_path %>
+<% end %>
+
+<%= bro_hub_hero eyebrow: "#{@event.store} · #{@event.environment}", title: cache_bro_event_label(@event.event),
+      subtitle: ("#{cache_bro_count(@event.count, "key")}" if @event.count),
+      lead: safe_join([ content_tag(:strong, @event.user_label), " at #{@event.created_at.utc.strftime("%Y-%m-%d %H:%M UTC")}" ]) %>
+
+<div class="bh-split">
+  <section class="bh-split-main">
+    <div class="bh-block-head"><h2 class="bh-h2"><%= @event.event == "keys_purged" ? "Pattern" : "Key" %></h2></div>
+    <% if @event.target.present? %>
+      <pre class="bh-cmd-code" style="white-space:pre-wrap;overflow-wrap:anywhere"><%= @event.target %></pre>
+    <% else %>
+      <p class="bh-hint">The whole namespace.</p>
+    <% end %>
+
+    <% if @event.sample.any? %>
+      <div class="bh-block-head" style="margin-top:24px">
+        <h2 class="bh-h2">Keys deleted</h2>
+        <span class="bh-meta">a sample of <%= @event.sample.size %><%= " (more were deleted)" if @event.count.to_i > @event.sample.size %></span>
+      </div>
+      <div class="bh-log">
+        <% @event.sample.each do |key| %>
+          <div class="bh-cmd"><pre class="bh-cmd-code" style="white-space:pre-wrap;overflow-wrap:anywhere"><%= key %></pre></div>
+        <% end %>
+      </div>
+    <% end %>
+  </section>
+
+  <div class="bh-split-aside">
+    <section class="bh-block">
+      <h2 class="bh-h2">Details</h2>
+      <dl class="bh-dl">
+        <dt>User</dt><dd><%= @event.user_label %></dd>
+        <dt>Action</dt><dd><%= cache_bro_event_tag(@event.event) %></dd>
+        <dt>When</dt><dd><%= cache_bro_time(@event.created_at) %></dd>
+        <dt>Store</dt><dd><%= @event.store %></dd>
+        <dt>Environment</dt><dd><%= @event.environment %></dd>
+        <dt>Keys</dt><dd><%= @event.count || "-" %></dd>
+        <dt>Reason</dt><dd><%= @event.reason.presence || "none given" %></dd>
+        <% if @event.details["completed"] == false %><dt>Outcome</dt><dd class="bh-tone-red">failed part way: only the keys counted here were deleted</dd><% end %>
+        <% if @event.truncated? %><dt>Limit</dt><dd class="bh-tone-amber">stopped at the per-purge limit</dd><% end %>
+      </dl>
+    </section>
+  </div>
+</div>

data/app/views/cache_bro/flushes/new.html.erb

@@ -0,0 +1,19 @@
+<% bro_hub_crumb "Flush" %>
+<%= render "cache_bro/shared/store_tabs", path: ->(name) { flush_path(store: name) } %>
+
+<%= bro_hub_hero eyebrow: cache_bro_store.name, title: "Flush", tone: :red,
+      lead: "Delete everything in this cache store's namespace. Every cached page, fragment and value is rebuilt on demand, which can load your database. Recorded in the audit log." %>
+
+<% if cache_bro_store.namespaced? %>
+  <%= form_with url: flush_path, method: :post, class: "bh-filters" do %>
+    <%= hidden_field_tag :store, cache_bro_store.name %>
+    <label class="bh-field">Type <strong><%= cache_bro_store.name %></strong> to confirm
+      <%= text_field_tag :confirm, nil, class: "bh-input", autocomplete: "off", required: true %>
+    </label>
+    <%= cache_bro_reason_field(:flush) %>
+    <%= submit_tag "Flush #{cache_bro_store.name}", name: nil, class: "bh-btn is-auto", style: "background:var(--bh-red)" %>
+  <% end %>
+  <p class="bh-hint" style="padding:0 var(--bh-pad)">Only keys under the namespace <code><%= cache_bro_store.namespace %></code> are deleted.</p>
+<% else %>
+  <div class="bh-alert bh-alert-error">This store has no namespace, so flushing it would delete keys that aren't the cache's. Set <code>namespace:</code> on the cache store to enable this. You can still purge by pattern.</div>
+<% end %>

data/app/views/cache_bro/keys/index.html.erb

@@ -0,0 +1,36 @@
+<% bro_hub_crumb "Keys" %>
+<%= render "cache_bro/shared/store_tabs", path: ->(name) { root_path(store: name) } %>
+
+<%= bro_hub_hero eyebrow: [ cache_bro_store.name, (cache_bro_store.namespace ? "namespace #{cache_bro_store.namespace}" : "no namespace") ].join(" · "),
+      title: @listing.entries.size,
+      subtitle: @listing.more? ? "keys so far" : (@listing.entries.size == 1 ? "key" : "keys"),
+      lead: "Search what is in the cache. Plain text matches anywhere in the key; use * and ? for a pattern. " \
+            "Redis is walked in small steps, so on a big cache a page may show only part of the matches: keep looking to continue." %>
+
+<% unless cache_bro_store.namespaced? %>
+  <div class="bh-alert bh-alert-error">This cache store has no namespace, so it shares its Redis database with whatever else lives there. Set <code>namespace:</code> on the cache store to keep CacheBro to the cache's own keys.</div>
+<% end %>
+
+<%= form_with url: root_path, method: :get, class: "bh-filters" do %>
+  <%= hidden_field_tag :store, cache_bro_store.name %>
+  <%= text_field_tag :q, @query, placeholder: "Search keys, e.g. posts/ or views/*/show*", class: "bh-input is-strong", "aria-label": "Search keys", autofocus: true %>
+  <%= submit_tag "Search", name: nil, class: "bh-chip" %>
+  <%= link_to "Reset", root_path(store: cache_bro_store.name), class: "bh-link-quiet" %>
+<% end %>
+
+<div class="bh-table-wrap">
+  <div class="bh-table" style="--cols: minmax(260px,1fr) 150px 100px; --min: 560px">
+    <div class="bh-row is-head"><span>Key</span><span>Expires</span><span>Size</span></div>
+    <% @listing.entries.each do |entry| %>
+      <%= link_to key_path(store: cache_bro_store.name, key: entry.key), class: "bh-row" do %>
+        <span class="bh-cell-strong" style="overflow-wrap:anywhere"><%= entry.key %></span>
+        <span class="bh-cell-muted"><%= cache_bro_ttl(entry.ttl) %></span>
+        <span class="bh-cell-muted"><%= cache_bro_size(entry.size) %></span>
+      <% end %>
+    <% end %>
+    <% if @listing.entries.empty? %>
+      <div class="bh-empty"><%= @listing.more? ? "Nothing here yet." : "No keys." %></div>
+    <% end %>
+    <%= cache_bro_pager(@listing, query: @query) %>
+  </div>
+</div>