plum-cms 0.2.1 → 0.2.3

data/docs/zero-to-agency.md

@@ -0,0 +1,172 @@
+# Zero to Agency
+
+How to go from an empty directory to hosting client sites — with one
+cheap VPS, the `plum` CLI, and nothing else. No GitHub required, no
+container registry, no CI pipeline, no platform-as-a-service bill. Your
+laptop builds, your server runs, SSH connects them.
+
+The stack under the hood: Rails + Plum in a Docker container, managed by
+[Once](https://once.com) (37signals' single-container deploy tool) behind
+its bundled TLS-terminating proxy, on any Linux box. The examples use
+DigitalOcean; any VPS provider works the same way.
+
+## What you need
+
+- A [DigitalOcean](https://digitalocean.com) account (or any VPS provider)
+- Docker on your laptop (Docker Desktop or Docker Engine) — `plum deploy`
+  builds images locally
+- The `plum` CLI
+- Ruby and Rails — and if you don't have them, `plum new` offers to
+  install both for you (via [mise](https://mise.jdx.dev))
+
+## 1. Create the server
+
+In DigitalOcean: **Create → Droplet**. Ubuntu LTS, the $6/month size is
+enough to start (pick $12 for headroom). Add your SSH key if you have one
+— if you don't, that's fine: `plum connect` will generate one and offer
+to copy it over with the root password DigitalOcean emails you. Note the
+droplet's IP.
+
+That's the last time you touch a cloud dashboard.
+
+## 2. Create the site
+
+```bash
+plum new client-site
+cd client-site
+bin/rails server
+```
+
+You have a running Plum site at `http://localhost:3000` — the control
+panel is at `/cp`. Build the client's theme in `app/themes/`, model
+their content types in the CP (or as YAML in `plum/` — see
+`docs/config-as-code.md`), and load in their content.
+
+## 3. Connect the server
+
+```bash
+plum connect 203.0.113.5      # your droplet's IP
+```
+
+The wizard handles the entire first-contact ritual: SSH keys, passwordless
+login, detecting that this is a Once-shaped app, and — on a fresh droplet —
+**installing Docker Engine and Once for you** (each with your
+confirmation). When it asks for the app hostname, give it the client's
+real domain (`clientname.com`): that's how the server routes requests and
+provisions TLS.
+
+## 4. Point DNS
+
+At the client's DNS: an **A record** for their domain (and `www`) to the
+droplet's IP. **This must happen before the first deploy** — Once
+verifies `https://<domain>` end-to-end as the final step of a first
+deploy and rolls back if the domain doesn't reach the server yet
+(`plum deploy` checks this up front and warns you). Proxied DNS
+(Cloudflare in Full strict mode) is fine.
+
+Building ahead of a domain cutover? That's what previews are for:
+
+```bash
+plum deploy --preview
+```
+
+This ships the site as a *separate* Once app under a preview hostname —
+by default `<app>.<server-ip>.sslip.io`, magic wildcard DNS that reaches
+your server with zero configuration, so you have a shareable client
+preview URL before any real DNS exists. For branded previews, point one
+wildcard record (`*.preview.your-agency.com`) at the droplet and set
+`preview_host: client.preview.your-agency.com` on the remote in
+plum.yml.
+
+Iterate on the preview as long as you like — build the content, tune the
+theme, let the client click around. Then, when they flip DNS to the
+droplet:
+
+```bash
+plum promote
+```
+
+The preview app *becomes* the site: same container, same database, every
+word of content you built during the preview — it simply starts answering
+to the real domain, with TLS provisioned on the spot. No rebuild, no
+content migration, no separate go-live deploy. (If the site should live
+on its own droplet instead, `plum connect` it there and `plum deploy` —
+site archives carry the content across.)
+
+## 5. Deploy
+
+```bash
+plum deploy
+```
+
+Watch it go: the image builds on your laptop, streams to the server over
+SSH (`docker save | docker load` — this is why no registry account
+exists in this guide), Once starts it behind the proxy, and the CLI waits
+for the container to report healthy. `https://clientname.com` is live.
+
+Deploys are explicit — the site changes when you run `plum deploy`,
+never by surprise. Ship again any time with the same command.
+
+## 6. The agency rhythm
+
+Day-to-day, the CLI is your relationship with every client site:
+
+```bash
+plum pull                # production content → your laptop, any DB engine
+plum push                # content-model changes (plum/ YAML) → production
+plum check               # did anyone drift the model? (CI-friendly)
+plum logs --follow       # heroku-style tail, prettified
+plum backup              # timestamped archive on the server
+plum run -- TASK         # any rake task, any remote
+```
+
+Content pulls down, structure pushes up. Clients edit in `/cp` on
+production; you develop locally against a full copy of their real
+content. Turn on **static caching** (`docs/static-caching.md`) and the
+site serves rendered pages from disk — SQLite happily runs a
+production site on the smallest droplet, because cached reads never
+touch the database at all.
+
+## 7. The second client
+
+This is where it becomes an agency:
+
+```bash
+plum new second-client
+cd second-client
+plum connect             # the host prompt offers your existing server
+plum deploy
+```
+
+Once runs each site in its own container on the same box, routing by
+hostname, each with its own TLS certificate. A $6–12 droplet comfortably
+hosts several small client sites; each new client is marginal-cost-zero
+until the box runs hot. Manage the fleet from anywhere:
+
+```bash
+plum projects list       # every site you run
+plum use second-client   # switch the active project
+plum pull --project client-site   # or target one explicitly
+```
+
+## 8. When you outgrow one box
+
+- **More sites than one droplet likes**: create a second droplet,
+  `plum connect` the new sites there. The registry doesn't care how many
+  servers are behind it.
+- **A client needs Postgres** (heavy dynamic features): switch that app's
+  database and redeploy — `plum pull` still works across engines.
+- **Backups off the box**: `plum backup` writes archives on the server;
+  Once's auto-backup handles scheduling. Pull copies down with `plum pull`
+  or scp them to storage you control.
+
+## Costs, honestly
+
+| Thing | Cost |
+| --- | --- |
+| Droplet (several small sites) | $6–12/mo |
+| Domains | the client's problem |
+| Registry, CI, PaaS, per-seat CMS pricing | $0 — none exist in this setup |
+
+The whole model: you charge for design and content strategy; the
+infrastructure is a rounding error.

data/lib/generators/plum/install/install_generator.rb

@@ -30,7 +30,19 @@ module Plum
       def mount_engine
         return if options[:skip_route]
 
-        route %(mount Plum::Engine, at: "#{options[:mount_path]}")
+        # Mounted at "/", Plum serves every path the app doesn't claim — so
+        # it must come AFTER the app's own routes (notably `get "up"`, the
+        # health check load balancers and deploy tooling probe). Rails'
+        # `route` helper prepends, which would shadow them; append at the
+        # bottom of the block instead.
+        inject_into_file "config/routes.rb", before: /^end\s*\z/ do
+          <<~RUBY.indent(2)
+
+            # Plum last: mounted at #{options[:mount_path].inspect} it serves every path
+            # the app doesn't claim, so app routes (like /up) must come first.
+            mount Plum::Engine, at: #{options[:mount_path].inspect}
+          RUBY
+        end
       end
 
       def print_next_steps

data/lib/generators/plum/install/templates/plum_initializer.rb

@@ -12,6 +12,14 @@ Plum.configure do |config|
     Plum::Engine.root.join("app/themes")
   ]
 
+  # Static page caching serves rendered pages from disk instead of hitting
+  # the database/Liquid on every request — a big win on a single server, but
+  # only correct on a single server. See docs/static-caching.md before
+  # enabling this on a multi-node/PaaS deployment (Heroku, Render, etc. with
+  # 2+ dynos or instances).
+  #
+  # config.static_cache_enabled = true
+
   # White-label the control panel:
   #
   # config.cp_name = "My Brand"

data/lib/plum/configuration.rb

@@ -6,7 +6,8 @@ module Plum
                   :mailer_sender, :cp_name, :cp_subtitle, :cp_logo_path,
                   :cp_accent_color, :cp_sidebar_bg, :cp_sidebar_header_bg, :cp_sidebar_text, :cp_sidebar_muted,
                   :cp_back_url, :cp_back_label,
-                  :powered_by_name, :powered_by_url
+                  :powered_by_name, :powered_by_url,
+                  :static_cache_enabled, :static_cache_path, :config_path
     attr_writer :theme_paths
     attr_reader :content_sources
 
@@ -25,6 +26,16 @@ module Plum
       @cp_back_label = "← Back"
       @powered_by_name = "Plum"
       @powered_by_url = "https://plumcms.com"
+      # Explicit opt-in — see docs/static-caching.md before enabling. Off by
+      # default because it's only correct on a single-server deployment;
+      # silently corrupts pages (stale content served forever from whichever
+      # node didn't get the invalidation) on multi-node platforms like
+      # Heroku/Render with 2+ dynos.
+      @static_cache_enabled = false
+      @static_cache_path = nil
+      # Directory for config-as-code YAML (content types, fieldsets).
+      # nil = default to Rails.root/plum when the tasks are invoked.
+      @config_path = nil
       @content_sources = ContentSourceRegistry.new
       @current_site_resolver = ->(_controller) { Plum::Site.first_or_create_standalone! }
       @current_user_resolver = lambda { |controller|

data/lib/plum/engine.rb

@@ -1,4 +1,6 @@
 require_relative "configuration"
+require_relative "static_cache"
+require_relative "static_cache/middleware"
 
 module Plum
   class Engine < ::Rails::Engine
@@ -6,6 +8,11 @@ module Plum
     config.paths["config/routes.rb"] = "config/plum_routes.rb"
     config.paths["db/migrate"] = [ "db/engine_migrate" ]
 
+    initializer "plum.static_cache" do |app|
+      # Always installed; it no-ops per request unless StaticCache.enabled?
+      app.middleware.use Plum::StaticCache::Middleware
+    end
+
     initializer "plum.assets" do |app|
       app.config.assets.paths << root.join("app/assets/javascripts")
       # Importmap exposes these files as `plum/*`, so Propshaft must resolve
@@ -23,10 +30,17 @@ module Plum
       end
     end
 
-    initializer "plum.importmap", before: "importmap" do |app|
-      if app.config.respond_to?(:importmap)
-        app.config.importmap.paths << root.join("config/plum_importmap.rb")
-      end
+    # Build a Plum-scoped importmap instead of merging Plum's pins into the
+    # host app's global importmap. Plum's layouts render this map (host JS stack
+    # + Plum's additions), while the host app's own pages keep a clean importmap
+    # free of Plum's controllers/lexxy/activestorage pins. Runs after the host's
+    # importmap is configured so we can copy its paths.
+    initializer "plum.importmap", after: "importmap" do |app|
+      next unless defined?(Importmap::Map) && app.config.respond_to?(:importmap)
+
+      Plum.importmap = Importmap::Map.new
+      Array(app.config.importmap.paths).each { |path| Plum.importmap.draw(path) }
+      Plum.importmap.draw(root.join("config/plum_importmap.rb"))
     end
   end
 end

data/lib/plum/static_cache/middleware.rb

@@ -0,0 +1,61 @@
+require_relative "../static_cache"
+
+module Plum
+  module StaticCache
+    # Serves cached pages before the request reaches Rails and captures
+    # renders on the way out. Controllers opt responses in by setting the
+    # X-Plum-Static-Cache header to "store" (see PagesController); everything
+    # else passes through untouched.
+    class Middleware
+      MARKER = StaticCache::MARKER_HEADER.downcase
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if StaticCache.enabled? && cacheable_request?(env) && (file = StaticCache.read(env["HTTP_HOST"], env["PATH_INFO"]))
+          return serve(file, env)
+        end
+
+        status, headers, body = @app.call(env)
+        maybe_store(env, status, headers, body)
+      end
+
+      private
+
+      def cacheable_request?(env)
+        return false unless env["REQUEST_METHOD"] == "GET" || env["REQUEST_METHOD"] == "HEAD"
+
+        env["QUERY_STRING"].to_s.empty?
+      end
+
+      def serve(file, env)
+        body = env["REQUEST_METHOD"] == "HEAD" ? [] : [ file.binread ]
+        headers = {
+          "content-type" => StaticCache.content_type_for(file),
+          "content-length" => file.size.to_s,
+          MARKER => "hit"
+        }
+        [ 200, headers, body ]
+      end
+
+      def maybe_store(env, status, headers, body)
+        # The marker is internal — strip it even when the response isn't stored.
+        marker = headers.delete(MARKER) || headers.delete(StaticCache::MARKER_HEADER)
+        return [ status, headers, body ] unless marker == "store" && StaticCache.enabled? && cacheable_request?(env)
+        return [ status, headers, body ] unless status == 200 && env["REQUEST_METHOD"] == "GET"
+        return [ status, headers, body ] if headers["set-cookie"].present? || headers["Set-Cookie"].present?
+
+        chunks = []
+        body.each { |chunk| chunks << chunk.to_s }
+        body.close if body.respond_to?(:close)
+        full_body = chunks.join
+
+        StaticCache.store(env["HTTP_HOST"], env["PATH_INFO"], full_body)
+        headers[MARKER] = "miss"
+        [ status, headers, [ full_body ] ]
+      end
+    end
+  end
+end

data/lib/plum/static_cache.rb

@@ -0,0 +1,103 @@
+require "rack/mime"
+
+module Plum
+  # Full-page static cache. Rendered public pages are written to disk keyed by
+  # host + path; subsequent requests are served from the file without touching
+  # the database or Liquid. A web server can serve the same files directly
+  # (nginx try_files) for the "full measure" where Rails never sees the hit.
+  #
+  # Cache entries are invalidated by deletion (see StaticCacheInvalidation) —
+  # the next request re-renders and re-stores the page. Over-flushing is cheap,
+  # so anything ambiguous flushes the whole site.
+  module StaticCache
+    MARKER_HEADER = "X-Plum-Static-Cache".freeze
+
+    class << self
+      # Explicit opt-in only — see docs/static-caching.md. There is
+      # deliberately no "auto-on in production" mode: this cache is only
+      # correct on a single-server deployment, and defaulting it on would
+      # silently corrupt pages the moment an app scales to 2+ nodes.
+      def enabled?
+        !!Plum.configuration.static_cache_enabled
+      end
+
+      def cache_root
+        Pathname(Plum.configuration.static_cache_path || Rails.root.join("storage", "plum_static_cache"))
+      end
+
+      # Pages are stored as {host}/{path}/index.html so a web server can map
+      # URLs to files directly. Paths with a file extension (theme assets) are
+      # stored verbatim.
+      def file_path(host, path)
+        key = normalized_path(path)
+        return nil unless key
+
+        base = cache_root.join(sanitized_host(host))
+        full = File.extname(key).present? ? base.join(key) : base.join(key, "index.html")
+        full = Pathname(File.expand_path(full))
+        return nil unless full.to_s.start_with?(cache_root.to_s + File::SEPARATOR)
+
+        full
+      end
+
+      def read(host, path)
+        file = file_path(host, path)
+        file if file&.file?
+      end
+
+      def store(host, path, body)
+        file = file_path(host, path)
+        return unless file
+
+        file.dirname.mkpath
+        tmp = file.sub_ext(".tmp-#{Process.pid}-#{Thread.current.object_id}")
+        tmp.binwrite(body)
+        File.rename(tmp, file)
+        file
+      rescue SystemCallError => e
+        Rails.logger.error("[Plum] static cache write failed for #{path}: #{e.message}")
+        nil
+      end
+
+      def flush_site!(site)
+        return flush_all! if site.nil? || site.domain.blank?
+
+        [ site.domain, "www.#{site.domain}" ].each do |host|
+          dir = cache_root.join(sanitized_host(host))
+          FileUtils.rm_rf(dir) if dir.to_s.start_with?(cache_root.to_s) && dir.exist?
+        end
+      end
+
+      def flush_all!
+        return unless cache_root.exist?
+
+        cache_root.children.each { |child| FileUtils.rm_rf(child) }
+      end
+
+      def content_type_for(file)
+        Rack::Mime.mime_type(File.extname(file.to_s), "text/html")
+      end
+
+      private
+
+      def sanitized_host(host)
+        cleaned = host.to_s.downcase.gsub(/[^a-z0-9.\-]/, "")
+        cleaned.presence || "_default"
+      end
+
+      # Rejects anything that could escape the cache directory and normalizes
+      # "/" and "/about/" style paths to a shared key.
+      def normalized_path(path)
+        decoded = begin
+          URI.decode_www_form_component(path.to_s)
+        rescue ArgumentError
+          return nil
+        end
+        return nil if decoded.include?("..") || decoded.include?("\0")
+
+        trimmed = decoded.delete_prefix("/").chomp("/")
+        trimmed.presence || "_root"
+      end
+    end
+  end
+end

data/lib/plum/version.rb

@@ -1,6 +1,6 @@
 module Plum
   module Version
-    STRING = "0.2.1"
+    STRING = "0.2.3"
   end
 
   VERSION = Version::STRING

data/lib/plum.rb

@@ -3,6 +3,13 @@ require_relative "plum/content_source"
 require_relative "plum/configuration"
 
 module Plum
+  class << self
+    # A Plum-scoped importmap (host pins + Plum's own pins), used only by Plum's
+    # layouts. Keeps Plum's controllers/lexxy/activestorage out of the host
+    # app's global importmap so a mounted Plum can't pollute the host's JS.
+    attr_accessor :importmap
+  end
+
   def self.table_name_prefix
     "plum_"
   end

data/lib/tasks/plum_config.rake

@@ -0,0 +1,48 @@
+# This repo is both the engine and an app, so Rails loads lib/tasks twice
+# (engine railtie + application). Rake appends actions on re-definition, which
+# would run every task body twice — guard against the second load.
+unless Rake::Task.task_defined?("plum:config:export")
+  namespace :plum do
+    namespace :config do
+      def plum_config_site
+        site = ENV["SITE_ID"].present? ? Plum::Site.find(ENV["SITE_ID"]) : Plum::Site.first
+        abort "No Plum site exists" unless site
+        site
+      end
+
+      def plum_config_dir
+        ENV["DIR"].presence || Plum.configuration.config_path || Rails.root.join("plum")
+      end
+
+      desc "Write the content model (content types, fieldsets) to YAML files (SITE_ID optional; DIR defaults to plum/)"
+      task export: :environment do
+        files = Plum::ConfigSync.export(site: plum_config_site, dir: plum_config_dir)
+        puts "Exported #{files.length} config files to #{plum_config_dir}"
+      end
+
+      desc "Apply YAML config files to the database (SITE_ID optional; PRUNE=1 deletes types absent from files; FORCE=1 allows deleting types with entries)"
+      task sync: :environment do
+        result = Plum::ConfigSync.apply(
+          site: plum_config_site,
+          dir: plum_config_dir,
+          prune: ENV["PRUNE"].present?,
+          force: ENV["FORCE"].present?
+        )
+        puts "Config sync: #{result.summary}"
+      rescue Plum::ConfigSync::UnsafePruneError => e
+        abort e.message
+      end
+
+      desc "Fail if the database content model has drifted from the YAML files (for CI)"
+      task check: :environment do
+        drift = Plum::ConfigSync.check(site: plum_config_site, dir: plum_config_dir)
+        if drift.any?
+          drift.each { |line| puts "DRIFT #{line}" }
+          abort "Content model has drifted from config files (#{drift.length} differences)"
+        else
+          puts "Content model matches config files"
+        end
+      end
+    end
+  end
+end

data/lib/tasks/plum_portability.rake

@@ -1,37 +1,62 @@
-namespace :plum do
-  namespace :site do
-    desc "Export a complete Plum site archive (SITE_ID or first site; ARCHIVE required)"
-    task export: :environment do
-      path = ENV.fetch("ARCHIVE") { abort "ARCHIVE is required" }
-      site = ENV["SITE_ID"].present? ? Plum::Site.find(ENV["SITE_ID"]) : Plum::Site.first
-      abort "No Plum site exists" unless site
-
-      archive = Plum::SiteArchive.dump(site: site, path: path)
-      puts "Exported #{site.name} to #{archive}"
-    end
+# This repo is both the engine and an app, so Rails loads lib/tasks twice
+# (engine railtie + application). Rake appends actions on re-definition, which
+# would run every task body twice — guard against the second load.
+unless Rake::Task.task_defined?("plum:site:export")
+  namespace :plum do
+    namespace :site do
+      desc "Export a complete Plum site archive (SITE_ID or first site; ARCHIVE required)"
+      task export: :environment do
+        path = ENV.fetch("ARCHIVE") { abort "ARCHIVE is required" }
+        site = ENV["SITE_ID"].present? ? Plum::Site.find(ENV["SITE_ID"]) : Plum::Site.first
+        abort "No Plum site exists" unless site
+
+        archive = Plum::SiteArchive.dump(site: site, path: path)
+        puts "Exported #{site.name} to #{archive}"
+      end
 
-    desc "Import a Plum site archive as a new site (ARCHIVE required; NAME and DOMAIN optional)"
-    task import: :environment do
-      path = ENV.fetch("ARCHIVE") { abort "ARCHIVE is required" }
-      site = Plum::SiteArchive.load(path: path, name: ENV["NAME"], domain: ENV["DOMAIN"])
-      puts "Imported #{site.name} as site #{site.id}"
+      desc "Import a Plum site archive as a new site (ARCHIVE required; NAME and DOMAIN optional)"
+      task import: :environment do
+        path = ENV.fetch("ARCHIVE") { abort "ARCHIVE is required" }
+        site = Plum::SiteArchive.load(path: path, name: ENV["NAME"], domain: ENV["DOMAIN"])
+        puts "Imported #{site.name} as site #{site.id}"
+      end
     end
-  end
 
-  namespace :backup do
-    desc "Create a timestamped Plum site backup (SITE_ID optional; DIRECTORY defaults to backups/plum)"
-    task create: :environment do
-      site = ENV["SITE_ID"].present? ? Plum::Site.find(ENV["SITE_ID"]) : Plum::Site.first
-      abort "No Plum site exists" unless site
-      directory = Rails.root.join(ENV.fetch("DIRECTORY", "backups/plum"))
-      filename = "plum-site-#{site.id}-#{Time.current.utc.strftime('%Y%m%d%H%M%S')}.plum.zip"
-      archive = Plum::SiteArchive.dump(site: site, path: directory.join(filename))
-      puts "Backed up #{site.name} to #{archive}"
+    namespace :site do
+      desc "Replace the local site with an archive — the 'pull' refresh (ARCHIVE required; SITE_ID optional; FORCE=1 required in production)"
+      task replace: :environment do
+        path = ENV.fetch("ARCHIVE") { abort "ARCHIVE is required" }
+        if Rails.env.production? && ENV["FORCE"].blank?
+          abort "Refusing to replace a site in production (set FORCE=1 to override)"
+        end
+
+        old_site = ENV["SITE_ID"].present? ? Plum::Site.find(ENV["SITE_ID"]) : Plum::Site.first
+        old_name = old_site&.name
+
+        site = ActiveRecord::Base.transaction do
+          old_site&.destroy!
+          Plum::SiteArchive.load(path: path, name: ENV["NAME"], domain: ENV["DOMAIN"])
+        end
+
+        puts old_name ? "Replaced #{old_name} with #{site.name} (site #{site.id})" : "Imported #{site.name} as site #{site.id}"
+      end
     end
 
-    desc "Restore a Plum backup as a new site (ARCHIVE required; NAME and DOMAIN optional)"
-    task restore: :environment do
-      Rake::Task["plum:site:import"].invoke
+    namespace :backup do
+      desc "Create a timestamped Plum site backup (SITE_ID optional; DIRECTORY defaults to backups/plum)"
+      task create: :environment do
+        site = ENV["SITE_ID"].present? ? Plum::Site.find(ENV["SITE_ID"]) : Plum::Site.first
+        abort "No Plum site exists" unless site
+        directory = Rails.root.join(ENV.fetch("DIRECTORY", "backups/plum"))
+        filename = "plum-site-#{site.id}-#{Time.current.utc.strftime('%Y%m%d%H%M%S')}.plum.zip"
+        archive = Plum::SiteArchive.dump(site: site, path: directory.join(filename))
+        puts "Backed up #{site.name} to #{archive}"
+      end
+
+      desc "Restore a Plum backup as a new site (ARCHIVE required; NAME and DOMAIN optional)"
+      task restore: :environment do
+        Rake::Task["plum:site:import"].invoke
+      end
     end
   end
 end

data/lib/tasks/plum_styles.rake

@@ -1,12 +1,17 @@
-require "fileutils"
+# This repo is both the engine and an app, so Rails loads lib/tasks twice
+# (engine railtie + application). Rake appends actions on re-definition, which
+# would run every task body twice — guard against the second load.
+unless Rake::Task.task_defined?("plum:build_styles")
+  require "fileutils"
 
-namespace :plum do
-  desc "Build Tailwind and copy the result into Plum's packaged stylesheet"
-  task build_styles: :environment do
-    system(Rails.root.join("bin/rails").to_s, "tailwindcss:build", exception: true)
-    source = Rails.root.join("app/assets/builds/tailwind.css")
-    destination = Rails.root.join("app/assets/stylesheets/plum/control_panel.css")
-    FileUtils.cp(source, destination)
-    puts "Packaged #{destination.relative_path_from(Rails.root)}"
+  namespace :plum do
+    desc "Build Tailwind and copy the result into Plum's packaged stylesheet"
+    task build_styles: :environment do
+      system(Rails.root.join("bin/rails").to_s, "tailwindcss:build", exception: true)
+      source = Rails.root.join("app/assets/builds/tailwind.css")
+      destination = Rails.root.join("app/assets/stylesheets/plum/control_panel.css")
+      FileUtils.cp(source, destination)
+      puts "Packaged #{destination.relative_path_from(Rails.root)}"
+    end
   end
 end