mailbox-kit 0.1.0

data/lib/mailbox_kit/mailboxes/inbound_retention.rb

@@ -0,0 +1,16 @@
+module MailboxKit
+    module Mailboxes
+      # ActionMailbox normally deletes processed mail after its retention window.
+      # A mailbox membership owns the raw source until explicit application purge.
+      module InboundRetention
+        def incinerate
+          return super unless Mailboxes.enabled?
+          # Attachment and purge use the same Rails row lock. A cleanup job
+          # must not delete raw mail between the membership check and insert.
+          with_lock do
+            super unless Message.where(inbound_email_id: id).exists?
+          end
+        end
+      end
+    end
+  end

data/lib/mailbox_kit/mailboxes/models.rb

@@ -0,0 +1,152 @@
+require "active_record"
+require "mailbox_kit/active_record/base"
+
+module MailboxKit
+  module Mailboxes
+    # Domains are an administrator-maintained receiving directory. An active
+    # record is an assertion by the application, not DNS ownership verification.
+    class ReceivingDomain < Mailboxes.directory_base
+      self.table_name = "cloudflare_email_receiving_domains"
+      STATES = %w[pending active suspended].freeze
+      attr_readonly :domain, :tenant_key, :account_id
+      before_validation(on: :create) { self.domain = domain.to_s.strip.downcase }
+      validates :tenant_key, presence: true
+      validates :domain, presence: true, uniqueness: true,
+        length: { maximum: 253 },
+        format: { with: /\A[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)+\z/ }
+      validates :state, inclusion: { in: STATES }
+      validate do
+        errors.add(:domain, "has an oversized label") if domain.to_s.split(".").any? { |label| label.length > 63 }
+      end
+      scope :active, -> { where(state: "active") }
+    end
+
+    module TenantIdentity
+      extend ActiveSupport::Concern
+      included do
+        attr_readonly :tenant_key
+        validates :tenant_key, presence: true
+        before_validation :assign_tenant_identity
+        validate :validate_tenant_identity
+        before_destroy :assert_tenant_identity!
+      end
+
+      private
+
+      def assign_tenant_identity
+        self.tenant_key ||= Tenancy.current_key
+      end
+
+      def validate_tenant_identity
+        return unless Tenancy.enabled? || Tenancy.current_key
+        Tenancy.require_context!
+        errors.add(:tenant_key, "does not match the current tenant") unless tenant_key == Tenancy.current_key
+      end
+
+      def assert_tenant_identity!
+        return unless Tenancy.enabled? || Tenancy.current_key
+        Tenancy.require_context!
+        raise ArgumentError, "record belongs to another tenant" unless tenant_key == Tenancy.current_key
+      end
+
+      def validate_parent_tenant(parent, attribute)
+        errors.add(attribute, "belongs to another tenant") if parent && parent.tenant_key != tenant_key
+      end
+    end
+
+    class Mailbox < MailboxKit::ActiveRecord::Base
+      include TenantIdentity
+      self.table_name = "cloudflare_email_mailboxes"
+      has_many :addresses, class_name: "MailboxKit::Mailboxes::Address", dependent: :restrict_with_exception
+      has_many :messages, class_name: "MailboxKit::Mailboxes::Message", dependent: :restrict_with_exception
+      validates :name, presence: true, length: { maximum: 255 }
+      validates :state, inclusion: { in: %w[active suspended] }
+      scope :active, -> { where(state: "active") }
+    end
+
+    class Address < MailboxKit::ActiveRecord::Base
+      include TenantIdentity
+      self.table_name = "cloudflare_email_addresses"
+      belongs_to :mailbox, class_name: "MailboxKit::Mailboxes::Mailbox"
+      attr_readonly :mailbox_id, :receiving_domain_id, :local_part, :domain, :address
+      before_validation :normalize_address, on: :create
+      validates :mailbox, :receiving_domain_id, presence: true
+      validates :local_part, length: { in: 1..64 },
+        format: { with: /\A[a-z0-9!\#$%&'*+\/=\?^_`{|}~-]+(?:\.[a-z0-9!\#$%&'*+\/=\?^_`{|}~-]+)*\z/ }
+      validates :address, uniqueness: true, length: { maximum: 254 }
+      validates :state, inclusion: { in: %w[pending active suspended] }
+      validate :validate_directory
+      validate :validate_catch_all
+      validate { validate_parent_tenant(mailbox, :mailbox) }
+      scope :active, -> { where(state: "active") }
+
+      def receiving_domain
+        ReceivingDomain.find_by(id: receiving_domain_id)
+      end
+
+      private
+
+      def normalize_address
+        self.local_part = local_part.to_s.strip.downcase
+        self.domain = domain.to_s.strip.downcase
+        self.address = "#{local_part}@#{domain}"
+      end
+
+      def validate_directory
+        registered = receiving_domain
+        unless registered && registered.domain == domain && registered.tenant_key == tenant_key
+          errors.add(:receiving_domain_id, "must match this tenant and domain")
+          return
+        end
+        if new_record? && registered.state != "active"
+          errors.add(:receiving_domain_id, "must be active before creating addresses")
+        end
+      end
+
+      def validate_catch_all
+        # Existing exact-address installations need not migrate until they
+        # opt into catch-all receiving.
+        return unless has_attribute?(:catch_all) && self[:catch_all]
+        errors.add(:catch_all_evidence, "is required") if self[:catch_all_evidence].to_s.strip.empty?
+        if will_save_change_to_catch_all? && state != "active"
+          errors.add(:catch_all, "requires an active address")
+        end
+        return unless state == "active"
+        errors.add(:catch_all, "requires an active mailbox") unless mailbox&.state == "active"
+        errors.add(:catch_all, "requires an active receiving domain") unless receiving_domain&.state == "active"
+        if self.class.where(receiving_domain_id: receiving_domain_id, catch_all: true, state: "active").where.not(id: id).exists?
+          errors.add(:catch_all, "already exists for this receiving domain")
+        end
+      end
+    end
+
+    class Message < MailboxKit::ActiveRecord::Base
+      include TenantIdentity
+      self.table_name = "cloudflare_email_mailbox_messages"
+      belongs_to :mailbox, class_name: "MailboxKit::Mailboxes::Mailbox"
+      attr_readonly :mailbox_id, :inbound_email_id, :recipient
+      validates :mailbox, :inbound_email_id, :recipient, presence: true
+      # The unique database index also supports create_or_find_by! retries.
+      validate { validate_parent_tenant(mailbox, :mailbox) }
+      scope :unread, -> { where(read_at: nil) }
+      scope :inbox, -> { where(archived_at: nil) }
+
+      def mark_read!
+        update!(read_at: Time.current)
+      end
+
+      def mark_unread!
+        update!(read_at: nil)
+      end
+
+      def archive!
+        update!(archived_at: Time.current)
+      end
+
+      def unarchive!
+        update!(archived_at: nil)
+      end
+    end
+
+  end
+end

data/lib/mailbox_kit/mailboxes/service.rb

@@ -0,0 +1,312 @@
+require "mailbox_kit/address_syntax"
+
+module MailboxKit
+  module Mailboxes
+    # A routing snapshot, not a model or an authorization token. Use it inside
+    # the yielded tenant context; later jobs must resolve/check policy again.
+    Destination = Struct.new(:tenant_key, :mailbox_id, :address_id,
+      :receiving_domain_id, :recipient, :owner_ref, :catch_all, keyword_init: true) do
+      def initialize(**attributes)
+        super(**{ catch_all: false }.merge(attributes).transform_values { |value| value.is_a?(String) ? value.dup.freeze : value })
+        freeze
+      end
+    end
+
+    class << self
+      # Call after host authorization. The directory is a control-plane API,
+      # not a public endpoint accepting arbitrary customer domain claims.
+      def register_domain(domain:, tenant_key:, account_id: nil)
+        Tenancy.normalize_key(tenant_key)
+        ReceivingDomain.create!(domain: domain, tenant_key: tenant_key, account_id: account_id)
+      end
+
+      def activate_domain!(id, evidence:, sending_enabled: false)
+        raise ArgumentError, "verification evidence is required" if evidence.to_s.strip.empty?
+        domain = ReceivingDomain.find(id)
+        domain.update!(state: "active", provisioning_evidence: evidence,
+          verified_at: Time.now.utc, sending_enabled: sending_enabled)
+        domain
+      end
+
+      def for_tenant(key)
+        raise ArgumentError, "a block is required" unless block_given?
+        Tenancy.with(key) { yield Session.new(key) }
+      end
+
+      # Only call after authenticating ingress and its envelope. Resolve before
+      # ActionMailbox or ActiveStorage accesses a tenant connection.
+      def receive(recipient:, source: nil, &block)
+        raise ArgumentError, "provide source or a persistence block, not both" if source && block
+        raise ArgumentError, "source or persistence block required" unless source || block
+        in_recipient_tenant(recipient) do |session, address, directory|
+          session.receive(address, directory) do |destination|
+            if block
+              # Legacy custom persistence blocks must return the existing Rails
+              # record on duplicates when membership attachment is desired.
+              block.lambda? && block.arity.zero? ? block.call : block.call(destination)
+            else
+              require "mailbox_kit/inbound_email"
+              InboundEmail.persist(source: source).record
+            end
+          end
+        end
+      end
+
+      # Lookup only: the host owns persistence and the block's return value.
+      # Verify ingress before calling this API. No ActionMailbox is required.
+      def with_recipient(recipient:)
+        raise ArgumentError, "a block is required" unless block_given?
+        in_recipient_tenant(recipient) do |session, address, directory|
+          session.with_recipient(address, directory) { |destination| yield destination }
+        end
+      end
+
+      def canonical_address(value)
+        unless AddressSyntax.valid_address?(value)
+          raise ValidationError, "mailbox address must be an ASCII dot-atom address"
+        end
+        value.downcase
+      end
+
+      private
+
+      def in_recipient_tenant(recipient)
+        address = canonical_address(recipient)
+        directory = ReceivingDomain.find_by(domain: address.split("@", 2).last, state: "active")
+        raise Unavailable, "receiving domain unavailable" unless directory
+        for_tenant(directory.tenant_key) do |session|
+          yield session, address, directory
+        end
+      end
+    end
+
+    class Session
+      attr_reader :tenant_key
+
+      def initialize(tenant_key)
+        @tenant_key = tenant_key
+      end
+
+      def mailboxes
+        context!
+        Mailbox.where(tenant_key: tenant_key)
+      end
+
+      def create(name:, address:, owner_ref: nil)
+        context!
+        Mailbox.transaction do
+          mailbox = Mailbox.create!(tenant_key: tenant_key, name: name, owner_ref: owner_ref)
+          add_address(mailbox.id, address: address)
+          mailbox
+        end
+      end
+
+      def add_address(mailbox_id, address:)
+        mailbox = active_mailbox!(mailbox_id)
+        canonical = Mailboxes.canonical_address(address)
+        local, domain = canonical.split("@", 2)
+        directory = ReceivingDomain.find_by!(domain: domain, tenant_key: tenant_key, state: "active")
+        Address.create!(tenant_key: tenant_key, mailbox_id: mailbox.id,
+          receiving_domain_id: directory.id, local_part: local, domain: domain,
+          address: canonical, state: "pending")
+      end
+
+      def activate_address!(address_id, evidence:)
+        context!
+        raise ArgumentError, "route verification evidence is required" if evidence.to_s.strip.empty?
+        address = Address.where(tenant_key: tenant_key).find(address_id)
+        active_mailbox!(address.mailbox_id)
+        active_domain!(address)
+        address.update!(state: "active", provisioning_evidence: evidence)
+        address
+      end
+
+      # This records the host's verified provider routing decision; it does
+      # not provision provider DNS/rules or authorize arbitrary From values.
+      def enable_catch_all(address_id, evidence:)
+        context!
+        catch_all_schema!
+        raise ArgumentError, "catch-all route verification evidence is required" if evidence.to_s.strip.empty?
+        Address.transaction do
+          address = Address.where(tenant_key: tenant_key, state: "active").find(address_id)
+          active_mailbox!(address.mailbox_id)
+          active_domain!(address)
+          address.update!(catch_all: true, catch_all_evidence: evidence)
+          address
+        end
+      end
+
+      def disable_catch_all(address_id)
+        context!
+        catch_all_schema!
+        # Disabling is permitted even after suspension; retain the previous
+        # verification evidence for operator inspection.
+        Address.where(tenant_key: tenant_key).find(address_id).tap { |address| address.update!(catch_all: false) }
+      end
+
+      def suspend(mailbox_id)
+        mailboxes.find(mailbox_id).tap { |mailbox| mailbox.update!(state: "suspended") }
+      end
+
+      def resume(mailbox_id)
+        mailboxes.find(mailbox_id).tap { |mailbox| mailbox.update!(state: "active") }
+      end
+
+      def messages(mailbox_id)
+        mailbox = mailboxes.find(mailbox_id)
+        Message.where(tenant_key: tenant_key, mailbox_id: mailbox.id)
+      end
+
+      def addresses(mailbox_id)
+        mailbox = mailboxes.find(mailbox_id)
+        Address.where(tenant_key: tenant_key, mailbox_id: mailbox.id)
+      end
+
+      def suspend_address(mailbox_id, address_id)
+        addresses(mailbox_id).find(address_id).tap { |address| address.update!(state: "suspended") }
+      end
+
+      def inbound_email(mailbox_id, message_id)
+        message = messages(mailbox_id).find(message_id)
+        ensure_storage_connection!
+        ::ActionMailbox::InboundEmail.find(message.inbound_email_id)
+      end
+
+      # For an existing Rails ingress or ApplicationMailbox handler. The caller
+      # has already selected this trusted tenant and authorized the inbound ID.
+      # Never accept an unscoped ID from a customer or switch tenants around a
+      # model object loaded from another database.
+      def attach(recipient:, inbound_email_id:)
+        context!
+        ensure_storage_connection!
+        address = Mailboxes.canonical_address(recipient)
+        directory = ReceivingDomain.find_by!(domain: address.split("@", 2).last,
+          tenant_key: tenant_key, state: "active")
+        destination = resolve_destination(address, directory)
+        attach_destination(destination, inbound_email_id)
+      end
+
+      # Explicit permanent removal. Archive is the reversible default.
+      # Other mailbox memberships retain their shared raw source.
+      def purge_message(mailbox_id, message_id)
+        context!
+        ensure_storage_connection!
+        Message.transaction do
+          message = messages(mailbox_id).find(message_id)
+          inbound_id = message.inbound_email_id
+          inbound = ::ActionMailbox::InboundEmail.find_by(id: inbound_id)
+          if inbound
+            inbound.with_lock do
+              message.destroy!
+              inbound.destroy! unless Message.where(inbound_email_id: inbound_id).exists?
+            end
+          else
+            message.destroy!
+          end
+        end
+      end
+
+      def mark_read(mailbox_id, message_id, read: true)
+        messages(mailbox_id).find(message_id).update!(read_at: read ? Time.now.utc : nil)
+      end
+
+      def archive(mailbox_id, message_id, archived: true)
+        messages(mailbox_id).find(message_id).update!(archived_at: archived ? Time.now.utc : nil)
+      end
+
+      def receive(address, directory)
+        context!
+        ensure_storage_connection! if defined?(::ActionMailbox::InboundEmail)
+        Mailbox.transaction do
+          destination = resolve_destination(address, directory)
+          inbound = yield destination
+          if inbound
+            if defined?(::ActionMailbox::InboundEmail)
+              attach_destination(destination, inbound.id)
+            else
+              # Compatibility for host-owned storage. New integrations should
+              # use with_recipient for custom stores, or attach for Rails mail.
+              record_membership(destination, inbound.id)
+            end
+          end
+          inbound
+        end
+      end
+
+      def with_recipient(address, directory)
+        context!
+        yield resolve_destination(address, directory)
+      end
+
+      private
+
+      def attach_destination(destination, inbound_email_id)
+        inbound = ::ActionMailbox::InboundEmail.find(inbound_email_id)
+        inbound.with_lock do
+          if Message.where(inbound_email_id: inbound.id).where.not(tenant_key: tenant_key).exists?
+            raise ConfigurationError, "inbound email already belongs to another tenant"
+          end
+          record_membership(destination, inbound.id)
+        end
+      end
+
+      def record_membership(destination, inbound_email_id)
+        Message.create_or_find_by!(tenant_key: tenant_key, mailbox_id: destination.mailbox_id,
+          inbound_email_id: inbound_email_id) { |row| row.recipient = destination.recipient }
+      end
+
+      def resolve_destination(address, directory)
+        destination = Address.where(tenant_key: tenant_key, address: address,
+          receiving_domain_id: directory.id).first
+        fallback = destination.nil?
+        if fallback && catch_all_schema_available?
+          destination = Address.where(tenant_key: tenant_key, receiving_domain_id: directory.id,
+            catch_all: true, state: "active").first
+        end
+        # An exact pending/suspended address intentionally reserves its name.
+        # It must never fall through to another mailbox's catch-all.
+        raise Unavailable, "mailbox address unavailable" unless destination&.state == "active"
+        mailbox = active_mailbox!(destination.mailbox_id)
+        active_domain!(destination)
+        Destination.new(tenant_key: tenant_key, mailbox_id: mailbox.id,
+          address_id: destination.id, receiving_domain_id: directory.id,
+          recipient: address, owner_ref: mailbox.owner_ref, catch_all: fallback)
+      rescue ::ActiveRecord::RecordNotFound
+        raise Unavailable, "mailbox address unavailable"
+      end
+
+      def context!
+        raise ConfigurationError, "mailbox session used outside its tenant context" unless Tenancy.require_context! == tenant_key
+      end
+
+      def catch_all_schema_available?
+        Address.connection.column_exists?(Address.table_name, :catch_all) &&
+          Address.connection.column_exists?(Address.table_name, :catch_all_evidence)
+      end
+
+      def catch_all_schema!
+        unless catch_all_schema_available?
+          raise ConfigurationError, "run mailbox_kit:install migrations for this tenant first"
+        end
+      end
+
+      def ensure_storage_connection!
+        unless defined?(::ActionMailbox::InboundEmail) && ::ActionMailbox::InboundEmail.connection_pool == Mailbox.connection_pool &&
+            ::ActiveStorage::Blob.connection_pool == Mailbox.connection_pool
+          raise ConfigurationError, "ActionMailbox, ActiveStorage and mailbox records must share the tenant connection"
+        end
+      end
+
+      def active_mailbox!(id)
+        context!
+        mailboxes.where(state: "active").find(id)
+      end
+
+      def active_domain!(address)
+        ReceivingDomain.find_by!(id: address.receiving_domain_id, domain: address.domain,
+          tenant_key: tenant_key, state: "active")
+      end
+
+    end
+  end
+end

data/lib/mailbox_kit/mailboxes.rb

@@ -0,0 +1,9 @@
+# Explicit Active Record opt-in. Configure tenancy before requiring this file.
+require "mailbox-kit"
+require "mailbox_kit/tenancy"
+require "mailbox_kit/mailboxes/configuration"
+require "mailbox_kit/mailboxes/models"
+require "mailbox_kit/mailboxes/service"
+MailboxKit::Mailboxes.enable!
+
+require "mailbox_kit/railtie" if defined?(::Rails::Railtie)

data/lib/mailbox_kit/management/adapter.rb

@@ -0,0 +1,29 @@
+module MailboxKit
+  module Management
+    # A host supplies authentication, mailbox ownership and domain entitlement.
+    # Defaults deliberately grant no access. No principal comes from params.
+    class Adapter
+      attr_reader :controller
+
+      def initialize(controller = nil)
+        @controller = controller
+      end
+
+      def authenticate! = false
+      def tenant_key = nil
+      def mailboxes(session) = session.mailboxes.none
+      def allowed?(action, mailbox = nil) = false
+      def domains(session) = []
+
+      # Override these two hooks when the host keeps a linked product model or
+      # uses a deployment policy to activate/provision verified addresses.
+      def create_mailbox(session, name:, address:)
+        session.create(name: name, address: address)
+      end
+
+      def add_address(session, mailbox, address:)
+        session.add_address(mailbox.id, address: address)
+      end
+    end
+  end
+end

data/lib/mailbox_kit/management/configuration.rb

@@ -0,0 +1,15 @@
+module MailboxKit
+  module Management
+    class Configuration
+      attr_accessor :adapter, :back_path
+    end
+
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    def self.configure
+      yield configuration
+    end
+  end
+end

data/lib/mailbox_kit/management/engine.rb

@@ -0,0 +1,13 @@
+require "rails/engine"
+require "action_controller/railtie"
+
+module MailboxKit
+  module Management
+    class Engine < ::Rails::Engine
+      isolate_namespace MailboxKit::Management
+      config.root = File.expand_path("../../..", __dir__)
+
+      config.paths["config/routes.rb"] = "lib/mailbox_kit/management/routes.rb"
+    end
+  end
+end

data/lib/mailbox_kit/management/management.css

@@ -0,0 +1,68 @@
+:root { color-scheme: light; --ink: #172c35; --muted: #536871; --line: #dce4e6; --accent: #12655c; --surface: #fff; }
+* { box-sizing: border-box; }
+body { margin: 0; background: #f5f7f7; color: var(--ink); font: 16px/1.55 system-ui, sans-serif; }
+a { color: var(--accent); text-underline-offset: 3px; }
+a:hover { text-decoration-thickness: 2px; }
+:focus-visible { outline: 3px solid #b66a17; outline-offset: 4px; }
+.shell { width: min(1160px, 100% - 48px); margin: 0 auto; }
+.site-header { background: var(--surface); border-bottom: 1px solid var(--line); }
+.header-content { display: flex; justify-content: space-between; align-items: center; gap: 16px; min-height: 76px; }
+.brand { color: var(--ink); font-weight: 750; font-size: 18px; text-decoration: none; }
+.header-caption, .muted, .field-help { color: var(--muted); }
+main.shell { padding-top: 32px; padding-bottom: 64px; }
+h1, h2, h3, p { margin: 0; }
+h1 { font-size: clamp(26px, 4vw, 36px); line-height: 1.2; letter-spacing: -.035em; overflow-wrap: anywhere; }
+h2 { font-size: 17px; line-height: 1.4; }
+h3 { font-size: 17px; }
+.small, .field-help { font-size: 13px; }
+.eyebrow { color: var(--accent); font-size: 12px; font-weight: 750; text-transform: uppercase; letter-spacing: .1em; margin-bottom: 8px; }
+.page-heading { display: flex; justify-content: space-between; align-items: center; gap: 24px; margin-bottom: 28px; }
+.page-heading .muted { margin-top: 12px; max-width: 640px; }
+.workspace-grid { display: grid; grid-template-columns: minmax(0, 1.65fr) minmax(280px, 1fr); gap: 24px; align-items: start; }
+.panel { background: var(--surface); border: 1px solid var(--line); border-radius: 12px; overflow: hidden; min-width: 0; }
+.panel-heading { padding: 20px 24px; border-bottom: 1px solid var(--line); }
+.panel-body { padding: 24px; }
+.stack { display: flex; flex-direction: column; gap: 20px; }
+.field { display: flex; flex-direction: column; gap: 8px; }
+label { font-weight: 650; font-size: 14px; }
+input[type="text"], input[type="email"] { width: 100%; border: 1px solid #a6b7be; border-radius: 7px; padding: 11px 12px; background: #fff; color: var(--ink); font: inherit; }
+.button { display: inline-flex; align-items: center; justify-content: center; min-height: 42px; padding: 9px 15px; border: 1px solid var(--accent); border-radius: 7px; background: var(--accent); color: #fff; font: inherit; font-size: 14px; font-weight: 650; text-decoration: none; cursor: pointer; text-align: center; }
+.button:hover { filter: brightness(.93); }
+.button-secondary { background: #fff; color: var(--ink); border-color: #a6b7be; }
+.record-list { list-style: none; margin: 0; padding: 0; }
+.record-row { padding: 20px 24px; display: flex; align-items: center; justify-content: space-between; gap: 16px; }
+.record-row + .record-row { border-top: 1px solid var(--line); }
+.record-content { min-width: 0; }
+.record-title { font-weight: 650; overflow-wrap: anywhere; }
+.record-content p { margin-top: 4px; }
+.badge { display: inline-block; border: 1px solid var(--line); border-radius: 5px; background: #f3f6f6; color: #364f58; padding: 3px 8px; font-size: 12px; font-weight: 650; white-space: nowrap; }
+.status-list { display: flex; flex-direction: column; align-items: flex-end; gap: 6px; }
+.address-row { align-items: flex-start; flex-direction: column; gap: 8px; }
+.empty-state { padding: 48px 24px; text-align: center; }
+.empty-state p { color: var(--muted); max-width: 340px; margin: 8px auto 0; }
+.pagination { padding: 16px 24px; border-top: 1px solid var(--line); }
+.actions { display: flex; flex-wrap: wrap; align-items: center; gap: 10px; }
+.actions form { margin: 0; }
+.breadcrumbs { display: flex; flex-wrap: wrap; gap: 10px; color: var(--muted); font-size: 14px; margin-bottom: 28px; overflow-wrap: anywhere; }
+.notice { border: 1px solid #a7ccc0; border-radius: 8px; background: #edf8f2; color: #205340; padding: 14px 18px; margin-bottom: 24px; overflow-wrap: anywhere; }
+.notice-error { border-color: #e8b9b3; background: #fff2ef; color: #8d2a21; }
+.message-metadata { display: grid; grid-template-columns: 84px minmax(0, 1fr); gap: 10px 20px; margin: 0; font-size: 14px; }
+.message-metadata dt { color: var(--muted); }
+.message-metadata dd { margin: 0; overflow-wrap: anywhere; }
+.message-body { border-top: 1px solid var(--line); padding: 28px 24px; }
+.message-body pre { white-space: pre-wrap; overflow-wrap: anywhere; font: inherit; margin: 0; }
+.attachments { border-top: 1px solid var(--line); }
+.attachments p { margin-top: 8px; }
+.attachments li { overflow-wrap: anywhere; }
+.skip-link { position: absolute; left: 16px; top: -100px; background: #fff; padding: 12px; z-index: 1; }
+.skip-link:focus { top: 12px; }
+@media (max-width: 760px) {
+  .shell { width: calc(100% - 32px); }
+  .header-content { min-height: 64px; }
+  .header-caption { display: none; }
+  .workspace-grid { grid-template-columns: minmax(0, 1fr); }
+  .page-heading { align-items: flex-start; flex-direction: column; }
+  .panel-heading, .panel-body, .record-row, .message-body { padding: 20px; }
+  .record-row { align-items: flex-start; }
+  .message-metadata { grid-template-columns: 64px minmax(0, 1fr); gap: 10px; }
+}

data/lib/mailbox_kit/management/routes.rb

@@ -0,0 +1,14 @@
+MailboxKit::Management::Engine.routes.draw do
+  get "style.css", to: "styles#show", as: :style
+  root to: "mailboxes#index"
+  resources :mailboxes, only: [:index, :show, :create] do
+    member do
+      post :aliases, action: :add_address
+      post :suspend
+      post :resume
+      get "messages/:message_id", action: :message, as: :message
+      post :mark_read
+      post :archive
+    end
+  end
+end

data/lib/mailbox_kit/management.rb

@@ -0,0 +1,6 @@
+require "rails/engine"
+require "mailbox-kit"
+require "mailbox_kit/railtie"
+require "mailbox_kit/management/adapter"
+require "mailbox_kit/management/configuration"
+require "mailbox_kit/management/engine"

data/lib/mailbox_kit/railtie.rb

@@ -0,0 +1,21 @@
+require "rails/railtie"
+module MailboxKit
+  class Railtie < ::Rails::Railtie
+    # Rails runs this public hook again when the model is reloaded. Loading the
+    # kit does not itself load ActionMailbox or replace its routing lifecycle.
+    initializer "mailbox-kit.inbound_retention" do
+      ActiveSupport.on_load(:action_mailbox_inbound_email) do
+        require "mailbox_kit/mailboxes/inbound_retention"
+        prepend MailboxKit::Mailboxes::InboundRetention unless
+          ancestors.include?(MailboxKit::Mailboxes::InboundRetention)
+      end
+    end
+
+    config.to_prepare do
+      if (defined?(MailboxKit::Tenancy) && MailboxKit::Tenancy.enabled?) || MailboxKit::Mailboxes.respond_to?(:enabled?) && MailboxKit::Mailboxes.enabled?
+        require "mailbox_kit/tenant_job_context"
+        MailboxKit::TenantJobContext.install_framework_jobs!
+      end
+    end
+  end
+end