nuntius 1.5.2 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e838696ffee97488fa8ba197789b8c863a662dab896cb47c836b651d61135e50
-  data.tar.gz: 695b8775db5700301419a9d25ab58f6752f16f1ac10451d31a4e2cb4a251a927
+  metadata.gz: 7180b584a94828e410a42d835438c6cf31515fc9b4dde511b094ba2b4b03490d
+  data.tar.gz: f1b864e4d6ccf58829584985c5eb2cac1135803780f542f8d604410b27ee0e69
 SHA512:
-  metadata.gz: 5264de4adda58f8297b41d20bd2c3302f2022e2702e75f048f13dafed286ec7bb6c828ea59f6cf5f1d4b8106e2141d349194a67c71cd791b83f7dc65cb6a9508
-  data.tar.gz: 5b3076c6c0a95a17f6f6f8b4be55a822bc3d66ed4bbd308b02970c2f8103589f637468d883832b94f695ad6f626f916b4512fe8507aea492e039a7f736a08b63
+  metadata.gz: 437e01c204f38b399332504ec8fa9179d7627973a87a25fa18739336d445b5212b7d53c02542f64445cd4b2a563280b46dcb0361f4e04fc10738da40510eaf81
+  data.tar.gz: 5b4ad9324541e2110b012c84e71c08760331220ed999763f566ad6ede6e63c38078018ea1af8d2bdf2bdd9e6353d24321d7324553188210a29d58584cd90247b

data/README.md

@@ -223,7 +223,7 @@ The main key of the hash passed will also be the liquid variable.
 
 ### Mail
 
-Outbound mail is handled through SMTP. We've only exposed the HTML of mail, we can create text-versions based on sanitized HTML. HTML allows for [Foundation for Emails](https://get.foundation/emails/docs/index.html). You will have to include the CSS in the layouts.
+Outbound mail is handled through SMTP (the `:smtp` provider on the `:mail` transport). LMTP delivery to a mailbox is available through a separate `:lmtp` transport (see below). We've only exposed the HTML of mail, we can create text-versions based on sanitized HTML. HTML allows for [Foundation for Emails](https://get.foundation/emails/docs/index.html). You will have to include the CSS in the layouts.
 
 In the layout you can add `<a href="{{message_url}}">Link to mail</a>` to provide a link to the online version of the message.
 
@@ -244,6 +244,28 @@ The subscription will automatically be confirmed.
 
 Next in AWS SES, configure the SNS topic to receive feedback notifications for Bounce, Complaint and Delivery and include original headers.
 
+### LMTP
+
+LMTP (RFC 2033) delivers a message directly to a mailbox. It is its own transport, so it never interferes with `:mail`/SMTP delivery. Enable the transport and provider, and give the relevant templates `transport: "lmtp"`:
+
+```ruby
+config.transport :lmtp
+config.provider :lmtp, transport: :lmtp, settings: {
+  from_header: "Example <example@example.com>",
+  allow_list: ["example.com"]
+}
+```
+
+With LMTP both the recipient email address and the target LMTP server are provided by the template, inline-encoded in the `to` field as:
+
+```
+<email>@<host>:<port>
+```
+
+For example a template `to` of `{{user.email}}@mx.internal:24` renders to `user@example.com@mx.internal:24`. The provider uses the email (`user@example.com`) for the `To:` header and the envelope `RCPT TO`, and connects to the LMTP server at `mx.internal:24`. A plain address (without an inline `@host:port`) falls back to the optional `host`/`port` settings.
+
+LMTP templates use the same fields as mail templates (subject, html, layout, tracking). Delivery is synchronous: the server confirms delivery in its reply, so the message is marked `delivered` straight away and no refresh is needed.
+
 ### Slack
 
 Slack uses the [postMessage](https://api.slack.com/methods/chat.postMessage) method to send messages. It will also upload any attachment the message has prior to sending the message itself.

data/app/assets/stylesheets/nuntius/application.css

@@ -1,14 +1,12 @@
 
-span.traffic-signal {
-    &-red {
-        @apply text-red-600;
-    }
+span.traffic-signal-red {
+    @apply text-red-600;
+}
 
-    &-green {
-        @apply text-green-600;
-    }
+span.traffic-signal-green {
+    @apply text-green-600;
+}
 
-    &-orange {
-        @apply text-orange-400;
-    }
+span.traffic-signal-orange {
+    @apply text-orange-400;
 }

data/app/assets/tailwind/nuntius/engine.css

@@ -0,0 +1,6 @@
+/* Entry point for tailwindcss-rails v4 (Tailwind CSS v4).
+   The host app includes it with: @import "../builds/tailwind/nuntius";
+   Imported into the components layer so utility classes still override component styles, as they did in v3 */
+@import "../../stylesheets/nuntius/application.css" layer(components);
+
+@source "../../..";

data/app/jobs/nuntius/timebased_events_job.rb

@@ -3,7 +3,7 @@
 module Nuntius
   class TimebasedEventsJob < ApplicationJob
     def perform
-      Nuntius::Template.where.not(interval: nil).each do |template|
+      Nuntius::Template.where(enabled: true).where.not(interval: nil).each do |template|
         messenger_class = Nuntius::BaseMessenger.messenger_for_class(template.klass)
 
         messenger_class.timebased_scope_for(template).each do |object|

data/app/messengers/nuntius/base_messenger.rb

@@ -9,14 +9,16 @@ module Nuntius
 
     define_callbacks :action, terminator: ->(_target, result_lambda) { result_lambda.call == false }
 
-    attr_reader :attachments, :event, :object, :params
-    attr_accessor :templates
+    attr_reader :attachments, :headers, :event, :object, :params
+    attr_accessor :templates, :smtp_envelope_from
 
     def initialize(object, event, params = {})
       @object = object
       @event = event
       @params = params
       @attachments = params.fetch(:attachments, [])
+      @headers = params.fetch(:headers, {})
+      @smtp_envelope_from = params[:smtp_envelope_from]
     end
 
     # Calls the event method on the messenger
@@ -39,6 +41,7 @@ module Nuntius
         @attachments.each do |attachment|
           msg.add_attachment(attachment)
         end
+        apply_mail_overrides(msg)
 
         transport = Nuntius::BaseTransport.class_from_name(template.transport).new
         transport.deliver(msg)
@@ -54,6 +57,12 @@ module Nuntius
       @attachments << attachment
     end
 
+    # Sets an extra header on the resulting message (currently applied by the
+    # mail transport). Useful for things like "Auto-Submitted" or "Precedence".
+    def header(key, value)
+      @headers[key.to_s] = value
+    end
+
     class << self
       #
       # Returns the variable name used in the liquid context
@@ -172,6 +181,19 @@ module Nuntius
 
     private
 
+    # Persists any messenger-provided mail overrides (extra headers and/or a
+    # custom SMTP envelope sender) onto the message so they survive the
+    # transport delivery job and can be applied by the provider.
+    def apply_mail_overrides(message)
+      return if @headers.blank? && @smtp_envelope_from.nil?
+
+      mail = {}
+      mail["headers"] = @headers if @headers.present?
+      mail["envelope_from"] = @smtp_envelope_from unless @smtp_envelope_from.nil?
+
+      message.metadata = (message.metadata || {}).merge("mail" => mail)
+    end
+
     # Returns the relevant templates for the object / event combination
     def select_templates
       return @templates if @templates
@@ -188,7 +210,7 @@ module Nuntius
 
     def liquid_context
       assigns = @params || {}
-      instance_variables.reject { |i| %w[@params @object @locale @templates @template_scope].include? i.to_s }.each do |i|
+      instance_variables.reject { |i| %w[@params @object @locale @templates @template_scope @headers @smtp_envelope_from].include? i.to_s }.each do |i|
         assigns[i.to_s[1..]] = instance_variable_get(i)
       end
 

data/app/models/nuntius/message.rb

@@ -79,6 +79,14 @@ module Nuntius
       clicked_at.present?
     end
 
+    def opened?
+      opened_at.present?
+    end
+
+    def clicked?
+      clicked_at.present?
+    end
+
     # Removes only pending child messages
     def cleanup!
       Nuntius::Message.where(state: "pending").where(parent_message: self).destroy_all

data/app/providers/nuntius/abstract_mail_provider.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "mail"
+
+module Nuntius
+  # Shared delivery flow for mail providers (SMTP, LMTP). Concrete providers
+  # supply the recipient, the delivery method and the success semantics through
+  # the hooks below.
+  class AbstractMailProvider < BaseProvider
+    transport :mail
+
+    # RFC 5321 null reverse-path, used for auto-generated/bounce notifications.
+    NULL_REVERSE_PATH = "<>"
+
+    def deliver
+      return no_recipient if recipient.blank?
+      return block unless MailAllowList.new(settings[:allow_list]).allowed?(recipient)
+      return block if Nuntius::Message.where(state: %w[complaint bounced], to: recipient).count >= 1
+
+      mail = if message.from.present?
+        Mail.new(sender: from_header, from: message.from)
+      else
+        Mail.new(from: from_header)
+      end
+
+      mail.header["X-Nuntius-Message-Id"] = message.id
+
+      if message.campaign.present? && message.subscriber.present?
+        mail.header["List-Unsubscribe"] = "<" + message.subscriber.unsubscribe_link(message.campaign, message) + ">"
+        mail.header["List-Unsubscribe-Post"] = "List-Unsubscribe=One-Click"
+      end
+
+      null_sender = apply_mail_overrides(mail)
+
+      configure_delivery_method(mail, null_sender)
+
+      mail.to = recipient
+      mail.subject = message.subject
+      mail.part content_type: "multipart/alternative" do |p|
+        p.text_part = Mail::Part.new(
+          body: message.text,
+          content_type: "text/plain",
+          charset: "UTF-8"
+        )
+        if message.html.present?
+          # Apply email tracking (tracking pixel and link wrapping)
+          Nuntius::EmailTrackingService.perform(message: message)
+
+          message.html = message.html.gsub("{{message_url}}") { message_url(message) }
+
+          p.html_part = Mail::Part.new(
+            body: message.html,
+            content_type: "text/html",
+            charset: "UTF-8"
+          )
+        end
+      end
+
+      message.attachments.each do |attachment|
+        mail.attachments[attachment.filename.to_s] = {mime_type: attachment.content_type, content: attachment.download}
+      end
+
+      prepare_envelope(mail)
+
+      begin
+        response = mail.deliver!
+      rescue Net::SMTPFatalError
+        message.rejected
+        return message
+      rescue Net::SMTPServerBusy, Net::ReadTimeout
+        message.undelivered
+        return message
+      end
+
+      message.provider_id = mail.message_id
+      message.undelivered
+      message.send(success_state) if Rails.env.test? || delivered_successfully?(response)
+      message.last_sent_at = Time.zone.now if message.sent? || message.delivered?
+
+      message
+    end
+
+    def block
+      message.blocked
+      message
+    end
+
+    def no_recipient
+      message.no_recipient
+      message
+    end
+
+    private
+
+    # The resolved recipient email address. Used for the blank check, allow
+    # list, bounce dedup query and the +To:+ header. Subclasses may override
+    # (e.g. LMTP parses it out of the inline +to+).
+    def recipient
+      message.to
+    end
+
+    # Hook to set a custom SMTP/LMTP envelope. Default lets Mail derive it.
+    def prepare_envelope(mail)
+    end
+
+    # Concrete providers must configure how +mail+ is delivered.
+    def configure_delivery_method(mail, null_sender)
+      raise NotImplementedError, "#{self.class} must implement #configure_delivery_method"
+    end
+
+    # Whether a non-test delivery response counts as success.
+    def delivered_successfully?(response)
+      response.success?
+    end
+
+    # State to transition to on a successful delivery.
+    def success_state
+      :sent
+    end
+
+    # Applies any messenger-provided overrides stored on the message: extra
+    # headers and/or a custom SMTP envelope sender. Returns true when a null
+    # reverse-path (+MAIL FROM:<>+) was requested, so the caller can pick the
+    # delivery method that can actually emit it.
+    def apply_mail_overrides(mail)
+      overrides = message.metadata&.dig("mail")
+      return false if overrides.blank?
+
+      (overrides["headers"] || {}).each do |key, value|
+        mail.header[key] = value
+      end
+
+      return false unless overrides.key?("envelope_from")
+
+      envelope_from = overrides["envelope_from"]
+      if null_reverse_path?(envelope_from)
+        mail.smtp_envelope_from = NULL_REVERSE_PATH
+        true
+      else
+        mail.smtp_envelope_from = envelope_from
+        false
+      end
+    end
+
+    def null_reverse_path?(value)
+      value.blank? || value == NULL_REVERSE_PATH
+    end
+
+    def message_url(message)
+      Nuntius::Engine.routes.url_helpers.message_url(message.id, host: Nuntius.config.host(message))
+    end
+  end
+end

data/app/providers/nuntius/lmtp_delivery_method.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "socket"
+require "openssl"
+require "net/smtp"
+
+module Nuntius
+  # A minimal LMTP (RFC 2033) delivery method, usable as a Mail delivery
+  # method (+initialize(settings)+ + +deliver!(mail)+).
+  #
+  # Net::SMTP / Mail::SMTP greet with +EHLO+/+HELO+, but LMTP requires +LHLO+
+  # and returns one reply per recipient after the message body, so we speak the
+  # protocol directly over a socket. Failures raise the same Net::SMTP errors
+  # SMTP delivery would, so callers can treat both transports identically.
+  class LmtpDeliveryMethod
+    Response = Struct.new(:code, :message) do
+      def success?
+        code.to_s.start_with?("2")
+      end
+    end
+
+    DEFAULTS = {
+      address: "localhost",
+      port: 24,
+      ssl: false,
+      domain: "localhost"
+    }.freeze
+
+    attr_reader :settings
+
+    def initialize(settings = {})
+      @settings = DEFAULTS.merge(settings.compact)
+    end
+
+    def deliver!(mail)
+      envelope_from = mail.smtp_envelope_from
+      destinations = Array(mail.smtp_envelope_to)
+      raise ArgumentError, "LMTP delivery requires at least one recipient" if destinations.empty?
+
+      data = mail.encoded
+      socket = open_socket
+      begin
+        read_reply(socket, expected: "2") # 220 greeting
+        send_command(socket, "LHLO #{settings[:domain]}", expected: "2")
+        send_command(socket, "MAIL FROM:<#{envelope_from}>", expected: "2")
+        destinations.each do |to|
+          send_command(socket, "RCPT TO:<#{to}>", expected: "2")
+        end
+
+        send_command(socket, "DATA", expected: "3") # 354
+        socket.write(dot_stuff(data))
+        socket.write("\r\n") unless data.end_with?("\r\n")
+        socket.write(".\r\n")
+
+        # LMTP returns one reply per recipient after the body.
+        response = nil
+        destinations.each do
+          response = read_reply(socket, expected: "2")
+        end
+
+        send_command(socket, "QUIT", expected: nil)
+        response
+      ensure
+        socket.close unless socket.closed?
+      end
+    end
+
+    private
+
+    def open_socket
+      tcp = TCPSocket.open(settings[:address], settings[:port])
+      return tcp unless settings[:ssl]
+
+      ssl = OpenSSL::SSL::SSLSocket.new(tcp)
+      ssl.sync_close = true
+      ssl.connect
+      ssl
+    end
+
+    def send_command(socket, command, expected:)
+      socket.write("#{command}\r\n")
+      read_reply(socket, expected: expected)
+    end
+
+    def read_reply(socket, expected:)
+      lines = []
+      code = nil
+      loop do
+        line = socket.gets
+        raise Net::SMTPFatalError, "LMTP connection closed unexpectedly" if line.nil?
+
+        line = line.chomp
+        lines << line
+        code = line[0, 3]
+        # Multiline replies use "250-..." for every line but the last ("250 ...").
+        break unless line[3] == "-"
+      end
+
+      response = Response.new(code, lines.join("\n"))
+      return response if expected.nil? || code.to_s.start_with?(expected)
+
+      raise_for(code, response.message)
+    end
+
+    def raise_for(code, message)
+      case code.to_s[0]
+      when "4"
+        raise Net::SMTPServerBusy, message
+      when "5"
+        raise Net::SMTPFatalError, message
+      else
+        raise Net::SMTPUnknownError, message
+      end
+    end
+
+    # RFC 5321 transparency: lines starting with a dot get an extra dot.
+    def dot_stuff(data)
+      data.gsub(/^\./, "..")
+    end
+  end
+end

data/app/providers/nuntius/lmtp_lmtp_provider.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "mail"
+
+module Nuntius
+  # Delivers mail to a mailbox over LMTP.
+  #
+  # The recipient and the per-message LMTP server are inline-encoded in the
+  # message +to+ as <tt><email>@<host>:<port></tt> (for example
+  # <tt>user@example.com@mx.internal:24</tt>). The +email+ is used for the
+  # +To:+ header and the envelope +RCPT TO+; the +host:port+ is the LMTP
+  # server we connect to. A plain address (without +@host:port+) falls back to
+  # the configured +host+/+port+ settings.
+  #
+  # Delivery is synchronous: the server's per-recipient reply is the final
+  # confirmation, so messages are marked +delivered+ directly and no refresh
+  # job is required.
+  class LmtpLmtpProvider < AbstractMailProvider
+    transport :lmtp
+
+    LMTP_TARGET = /\A(?<email>.+)@(?<host>[^@\s:]+):(?<port>\d+)\z/
+
+    setting_reader :from_header, required: true, description: "From header (example: Nuntius Messenger <nuntius@entdec.com>)"
+    setting_reader :host, required: false, default: nil, description: "Fallback LMTP host, used when not encoded in the recipient (example: 127.0.0.1)"
+    setting_reader :port, required: false, default: nil, description: "Fallback LMTP port, used when not encoded in the recipient (example: 24)"
+    setting_reader :allow_list, required: false, default: [], description: "Allow list (example: [example.com, tim@apple.com])"
+    setting_reader :ssl, required: false, default: false, description: "Whether to use SSL or not"
+
+    private
+
+    def recipient
+      lmtp_target[:email]
+    end
+
+    def prepare_envelope(mail)
+      mail.smtp_envelope_to = recipient
+    end
+
+    def configure_delivery_method(mail, _null_sender)
+      if Rails.env.test?
+        mail.delivery_method :test
+      else
+        mail.delivery_method Nuntius::LmtpDeliveryMethod, lmtp_settings
+      end
+    end
+
+    # LMTP delivery is synchronous and confirmed by the server, so we can mark
+    # the message delivered straight away (no refresh job needed).
+    def success_state
+      :delivered
+    end
+
+    def lmtp_settings
+      {
+        address: lmtp_target[:host],
+        port: lmtp_target[:port],
+        ssl: ssl
+      }
+    end
+
+    def lmtp_target
+      @lmtp_target ||= begin
+        match = message.to.to_s.strip.match(LMTP_TARGET)
+        if match
+          {email: match[:email], host: match[:host], port: match[:port].to_i}
+        else
+          {email: message.to, host: host, port: port}
+        end
+      end
+    end
+  end
+end

data/app/providers/nuntius/null_sender_smtp.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "mail"
+
+module Nuntius
+  # A Mail::SMTP delivery method that sends with a null reverse-path
+  # (+MAIL FROM:<>+).
+  #
+  # The stock Mail::SmtpEnvelope refuses to emit an empty reverse-path
+  # (it raises on a blank From), and Net::SMTP wraps the address in angle
+  # brackets, so setting +smtp_envelope_from+ to +"<>"+ would produce the
+  # invalid +MAIL FROM:<<>>+. This delivery method bypasses Mail::SmtpEnvelope
+  # and hands an empty reverse-path straight to Net::SMTP, yielding the
+  # RFC 5321 null sender used by auto-generated/bounce notifications.
+  class NullSenderSmtp < ::Mail::SMTP
+    def deliver!(mail)
+      response = start_smtp_session do |smtp|
+        smtp.sendmail(mail.encoded, "", mail.smtp_envelope_to)
+      end
+
+      settings[:return_response] ? response : self
+    end
+  end
+end

data/app/providers/nuntius/smtp_mail_provider.rb

@@ -3,7 +3,7 @@
 require "mail"
 
 module Nuntius
-  class SmtpMailProvider < BaseProvider
+  class SmtpMailProvider < AbstractMailProvider
     transport :mail
 
     setting_reader :from_header, required: true, description: "From header (example: Nuntius Messenger <nuntius@entdec.com>)"
@@ -14,94 +14,27 @@ module Nuntius
     setting_reader :allow_list, required: false, default: [], description: "Allow list (example: [example.com, tim@apple.com])"
     setting_reader :ssl, required: false, default: false, description: "Whether to use SSL or not"
 
-    def deliver
-      return no_recipient if message.to.blank?
-      return block unless MailAllowList.new(settings[:allow_list]).allowed?(message.to)
-      return block if Nuntius::Message.where(state: %w[complaint bounced], to: message.to).count >= 1
-
-      mail = if message.from.present?
-        Mail.new(sender: from_header, from: message.from)
-      else
-        Mail.new(from: from_header)
-      end
-
-      mail.header["X-Nuntius-Message-Id"] = message.id
-
-      if message.campaign.present? && message.subscriber.present?
-        mail.header["List-Unsubscribe"] = "<" + message.subscriber.unsubscribe_link(message.campaign, message) + ">"
-        mail.header["List-Unsubscribe-Post"] = "List-Unsubscribe=One-Click"
-      end
+    private
 
+    def configure_delivery_method(mail, null_sender)
       if Rails.env.test?
         mail.delivery_method :test
+      elsif null_sender
+        mail.delivery_method Nuntius::NullSenderSmtp, smtp_settings
       else
-        mail.delivery_method :smtp,
-          address: host,
-          port: port,
-          user_name: username,
-          password: password,
-          return_response: true,
-          ssl: ssl
-      end
-
-      mail.to = message.to
-      mail.subject = message.subject
-      mail.part content_type: "multipart/alternative" do |p|
-        p.text_part = Mail::Part.new(
-          body: message.text,
-          content_type: "text/plain",
-          charset: "UTF-8"
-        )
-        if message.html.present?
-          # Apply email tracking (tracking pixel and link wrapping)
-          Nuntius::EmailTrackingService.perform(message: message)
-
-          message.html = message.html.gsub("{{message_url}}") { message_url(message) }
-
-          p.html_part = Mail::Part.new(
-            body: message.html,
-            content_type: "text/html",
-            charset: "UTF-8"
-          )
-        end
+        mail.delivery_method :smtp, smtp_settings
       end
-
-      message.attachments.each do |attachment|
-        mail.attachments[attachment.filename.to_s] = {mime_type: attachment.content_type, content: attachment.download}
-      end
-
-      begin
-        response = mail.deliver!
-      rescue Net::SMTPFatalError
-        message.rejected
-        return message
-      rescue Net::SMTPServerBusy, Net::ReadTimeout
-        message.undelivered
-        return message
-      end
-
-      message.provider_id = mail.message_id
-      message.undelivered
-      message.sent if Rails.env.test? || response.success?
-      message.last_sent_at = Time.zone.now if message.sent?
-
-      message
     end
 
-    def block
-      message.blocked
-      message
-    end
-
-    def no_recipient
-      message.no_recipient
-      message
-    end
-
-    private
-
-    def message_url(message)
-      Nuntius::Engine.routes.url_helpers.message_url(message.id, host: Nuntius.config.host(message))
+    def smtp_settings
+      {
+        address: host,
+        port: port,
+        user_name: username,
+        password: password,
+        return_response: true,
+        ssl: ssl
+      }
     end
   end
 end

data/app/transports/nuntius/lmtp_transport.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Nuntius
+  # LMTP delivers actual email, so it shares all mail processing (premailer,
+  # per-recipient splitting) with MailTransport. Only the configured providers
+  # differ: the :lmtp transport routes to the LMTP provider.
+  class LmtpTransport < MailTransport
+  end
+end

data/app/views/nuntius/admin/templates/edit.html.slim

@@ -61,6 +61,18 @@
             .col-span-12
               = f.input :html, as: :editor, mode: 'text/markdown', height: '400px'
 
+          template data-toggle-target='toggleable' data-toggle-value='lmtp'
+            .col-span-6
+              = f.input :link_tracking, as: :switch
+            .col-span-6
+              = f.input :open_tracking, as: :switch
+            .col-span-12
+              = f.input :subject, as: :editor, mode: 'text/plain'
+            .col-span-12
+              = f.association :layout, collection: @layouts, include_blank: true
+            .col-span-12
+              = f.input :html, as: :editor, mode: 'text/markdown', height: '400px'
+
           template data-toggle-target='toggleable' data-toggle-value='voice'
             .col-span-12
               = f.input :text, as: :editor, mode: 'text/plain', height: '400px'

data/lib/generators/nuntius/tailwind_config_generator.rb

@@ -7,6 +7,8 @@ module Nuntius
       desc "Configures tailwind.config.js and application.tailwindcss.css"
 
       def add_content_to_tailwind_config
+        return unless File.exist?(File.join(destination_root, "config/tailwind.config.js"))
+
         inject_into_file "config/tailwind.config.js", before: "],\n  theme: {" do
           "  // Nuntius content\n" +
             %w[/app/views/**/* /app/helpers/**/* /app/controllers/**/* /app/components/**/* /app/javascript/**/*.js /app/assets/**/*.css].map { |path| "    \"#{Nuntius::Engine.root}#{path}\"" }.join(",\n") +
@@ -15,6 +17,8 @@ module Nuntius
       end
 
       def add_content_application_tailwind_css
+        return unless File.exist?(File.join(destination_root, "app/assets/stylesheets/application.tailwind.css"))
+
         inject_into_file "app/assets/stylesheets/application.tailwind.css", before: "@tailwind base;" do
           "@import '#{Nuntius::Engine.root}/app/assets/stylesheets/nuntius/application.css';\n"
         end

data/lib/generators/nuntius/templates/config/initializers/nuntius.rb

@@ -21,6 +21,17 @@ Nuntius.setup do |config|
     }
   }
 
+  # LMTP delivery to a mailbox, on its own `:lmtp` transport. Enable the
+  # transport and provider, then give such templates `transport: "lmtp"`. The
+  # recipient and per-message LMTP server are inline-encoded in the template
+  # `to` as `<email>@<host>:<port>`, e.g. `user@example.com@mx.internal:24`.
+  # `host`/`port` here are optional fallbacks for plain addresses.
+  # config.transport :lmtp
+  # config.provider :lmtp, transport: :lmtp, settings: {
+  #   from_header: "Example <example@example.com>",
+  #   allow_list: ["example.com"]
+  # }
+
   config.provider :houston, transport: :push, settings: {certificate: ""}
   config.provider :firebase, transport: :push, settings: {server_key: ""}
 

data/lib/nuntius/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Nuntius
-  VERSION = "1.5.2"
+  VERSION = "1.6.0"
 end

data/lib/tasks/nuntius_tasks.rake

@@ -7,7 +7,9 @@ namespace :nuntius do
   end
 end
 
-if Rake::Task.task_defined?("tailwindcss:build")
+# tailwindcss-rails v4 picks up app/assets/tailwind/nuntius/engine.css itself (via tailwindcss:engines),
+# so only hook in the v3 config generator when that task is absent.
+if Rake::Task.task_defined?("tailwindcss:build") && !Rake::Task.task_defined?("tailwindcss:engines")
   Rake::Task["tailwindcss:build"].enhance(["nuntius:tailwindcss:config"])
   Rake::Task["tailwindcss:watch"].enhance(["nuntius:tailwindcss:config"])
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nuntius
 version: !ruby/object:Gem::Version
-  version: 1.5.2
+  version: 1.6.0
 platform: ruby
 authors:
 - Tom de Grunt
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-20 00:00:00.000000000 Z
+date: 2026-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: apnotic
@@ -429,6 +429,7 @@ files:
 - README.md
 - Rakefile
 - app/assets/stylesheets/nuntius/application.css
+- app/assets/tailwind/nuntius/engine.css
 - app/controllers/nuntius/admin/campaigns_controller.rb
 - app/controllers/nuntius/admin/layouts_controller.rb
 - app/controllers/nuntius/admin/lists/subscribers_controller.rb
@@ -486,10 +487,14 @@ files:
 - app/models/nuntius/template.rb
 - app/presenters/application_presenter.rb
 - app/presenters/template_presenter.rb
+- app/providers/nuntius/abstract_mail_provider.rb
 - app/providers/nuntius/apnotic_push_provider.rb
 - app/providers/nuntius/base_provider.rb
 - app/providers/nuntius/firebase_push_provider.rb
+- app/providers/nuntius/lmtp_delivery_method.rb
+- app/providers/nuntius/lmtp_lmtp_provider.rb
 - app/providers/nuntius/message_bird_sms_provider.rb
+- app/providers/nuntius/null_sender_smtp.rb
 - app/providers/nuntius/slack_slack_provider.rb
 - app/providers/nuntius/smstools_sms_provider.rb
 - app/providers/nuntius/smtp_mail_provider.rb
@@ -513,6 +518,7 @@ files:
 - app/tables/nuntius/subscribers_table.rb
 - app/tables/nuntius/templates_table.rb
 - app/transports/nuntius/base_transport.rb
+- app/transports/nuntius/lmtp_transport.rb
 - app/transports/nuntius/mail_transport.rb
 - app/transports/nuntius/push_transport.rb
 - app/transports/nuntius/slack_transport.rb