railsmaker-core 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b0ed25a62bb449bb3710dafb3d4cc089df97477d7b6439df3f8d8b1b0b6efbbd
+  data.tar.gz: d128667d1ef969f12940bd0f84a8081753afa2ab33432341564a746a5fb4169f
+SHA512:
+  metadata.gz: e503c24961bfe8c4919dfafe60ee4910c304f9d9145a179b42f02cbf7bef3564b0bc3b2efdc3d3f3dd4a24841ebf761b1b33dd061c7f7d7d40e27d68f2270b7e
+  data.tar.gz: de25342c872d7c3a49c5035fe98f90935a9fa31bde6954bbe28245c169ae0f9941fc9a7a9c83db42955dd98c346d9566cbe12e0ec15d069b459227dd4a9464f5

data/README.md

@@ -0,0 +1,169 @@
+[![Gem Version](https://img.shields.io/gem/v/railsmaker?color=blue&logo=rubygems)](https://rubygems.org/gems/railsmaker)
+[![Support](https://img.shields.io/badge/Support-%F0%9F%8D%B8-yellow)](https://buymeacoffee.com/sgerov)
+[![Live Demo](https://img.shields.io/badge/Live_Demo-Try_Now_-brightgreen?logo=rocket&color=00cc99)](https://railsmaker.com)
+[![Live Demo Repo](https://img.shields.io/badge/Live_Demo_Repo-View_Code-blue?logo=github)](https://github.com/sgerov/railsmaker-sample)
+[![Guide](https://img.shields.io/badge/Guide-10_Steps_To_Prod-orange?logo=book)](./10-STEPS-TO-PROD.md)
+
+# 📦 Railsmaker
+
+Ship your MVP in hours, not weeks • Zero config needed • Save $120+/month and 20+ dev hours
+
+## ⚡ Why Railsmaker?
+- **Ship Faster**: From zero to production in 15 minutes
+- **Growth Ready**: Built-in analytics, SEO, and monitoring
+- **Own Your Data**: Fully self-hosted, full control, full flexibility
+- **Cost Efficient**: You decide how much you want to spend
+- **DX Focused**: Modern stack, zero configuration
+
+## ✨ Features
+
+#### Growth & Analytics
+- **Privacy-focused**: Self-hosted Plausible and Signoz
+- **SEO**: Auto-optimized meta-tags & sitemaps
+- **Performance**: Lightning-fast ~50ms page loads
+- **Mobile First**: Instant responsive layouts
+
+#### Developer Experience
+- **UI**: Latest TailwindCSS 4 + DaisyUI 5
+- **Auth**: Battle-tested Clearance + OmniAuth
+- **Storage**: SQLite + Litestream
+- **Email**: Production-ready Mailjet integration
+- **Modern Stack**: Rails 8, Ruby 3.2, Hotwire magic
+
+#### Infrastructure
+- **Monitoring**: Full SigNoz & Sentry integration
+- **Deploy**: One-command Kamal deployments
+- **Observability**: Enterprise-grade OpenTelemetry + Lograge
+- **Scale-ready**: Global CDN support, multi-environment
+
+## 🚀 Setup
+
+### Prerequisites
+- Ruby 3.x (`rbenv` or `rvm` recommended)
+- Bundler: `gem install bundler`
+- Bun: [Install guide](https://bun.sh)
+- Git
+- Dev tools:
+  - Ubuntu/Debian: `sudo apt install build-essential libyaml-dev`
+  - macOS: `xcode-select --install`
+- Docker (for analytics & monitoring)
+
+### 1. Bootstrapping your app
+
+#### A. Set Required Environment Variables
+
+```bash
+# Docker registry access (required)
+export KAMAL_REGISTRY_PASSWORD="docker-registry-password"
+
+# Litestream backup configuration (optional)
+export LITESTREAM_ACCESS_KEY_ID="access-key"
+export LITESTREAM_SECRET_ACCESS_KEY="secret-access-key"
+export LITESTREAM_BUCKET="https://eu2.yourbucketendpoint.com/"
+export LITESTREAM_REGION="eu2"
+```
+
+#### B. Install and Deploy
+
+```bash
+gem install railsmaker-core
+
+# Interactive wizard (2 minutes)
+railsmaker new:wizard
+
+# Deploy to any cloud
+kamal setup
+```
+
+If you have chosen to include litestream keep in mind that the corresponding kamal accessory will also be deployed.
+
+### 2. Setting up Monitoring (Optional)
+
+#### A. Install SigNoz Server
+```bash
+railsmaker remote signoz \
+  --ssh-host=monitor.example.com \
+  --ssh-user=deploy
+```
+
+#### B. Add OpenTelemetry Collector to apps server
+```bash
+railsmaker remote signoz:opentelemetry \
+  --ssh-host=app.example.com \
+  --ssh-user=deploy \
+  --signoz-host=monitor.example.com \
+  --hostname=my-production-apps
+```
+
+### 3. Setting up Analytics (Optional)
+```bash
+railsmaker remote plausible \
+  --ssh-host=analytics.example.com \
+  --ssh-user=deploy \
+  --analytics-host=plausible.example.com
+```
+
+### Verification
+
+- SigNoz Dashboard: `https://monitor.example.com:3301`
+- Plausible Analytics: `https://analytics.example.com`
+- Your App: `https://app.example.com`
+
+> **Note**: All services are tested on Ubuntu 24.04 and macOS 15.2.
+
+**For a more detailed guide, check out [10 Steps To Prod](./10-STEPS-TO-PROD.md).**
+
+### Environment Requirements
+
+- **SigNoz Server**: 2 CPU, 4GB RAM minimum
+- **Plausible**: 1 CPU, 2GB RAM minimum
+- **App Server**: 1 CPU, 2GB RAM minimum
+
+You can decide how to split the services between your servers (e.g. SigNoz & Plausible on a separate server from the app or apps).
+
+### Database Recovery
+
+In case of DB failure, follow these steps to recover your data:
+
+1. Stop the application:
+```bash
+kamal app stop
+```
+
+2. Remove existing database files:
+```bash
+kamal app exec /bin/sh -i
+rm -rf ./storage/*
+exit
+```
+
+3. Recover files and set proper ownership to files:
+```bash
+kamal restore-db-app
+kamal restore-db-cache
+kamal restore-db-queue
+kamal restore-db-cable
+kamal restore-db-ownership
+```
+
+4. Restart Litestream to initiate recovery:
+```bash
+kamal accessory reboot litestream
+```
+
+5. Start the application:
+```bash
+kamal app boot
+```
+
+### Cloudflare DNS
+
+If you are relying on Cloudflare, make sure you set-up SSL/TLS to Full.
+
+## Support
+
+This project is **pay-what-you-want**. If it helps you ship faster:
+
+[![Support](https://img.shields.io/badge/Support-%F0%9F%8D%B8-yellow?style=for-the-badge)](https://buymeacoffee.com/sgerov)
+
+*Give it a try at [railsmaker.com](https://railsmaker.com)*

data/bin/railsmaker

@@ -0,0 +1,344 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'railsmaker'
+require 'thor'
+
+module RailsMaker
+  class BaseCLI < Thor
+    include Thor::Actions
+
+    no_commands do
+      def colorize(str, color)
+        case color
+        when :green then "\e[32m#{str}\e[0m"
+        when :red then "\e[31m#{str}\e[0m"
+        when :blue then "\e[34m#{str}\e[0m"
+        when :gray then "\e[90m#{str}\e[0m"
+        else str
+        end
+      end
+
+      def status_indicator(value)
+        if value == true || (value.is_a?(String) && !value.empty?)
+          colorize('●', :green) + ' Enabled'
+        else
+          colorize('○', :red) + ' Disabled'
+        end
+      end
+
+      def print_summary(title, sections)
+        max_label_width = sections.values.flatten(1).map { |item| item[0].length }.max
+
+        say "\n#{colorize("═══ #{title} ═══", :blue)}\n\n"
+
+        sections.each do |section_title, items|
+          say colorize(section_title.upcase, :gray)
+          say colorize('─' * section_title.length, :gray)
+
+          items.each do |label, value, format = :default|
+            formatted_value = case format
+                              when :status then status_indicator(value)
+                              when :highlight then colorize(value, :blue)
+                              else value.to_s
+                              end
+
+            say "  #{label.ljust(max_label_width)}  #{formatted_value}"
+          end
+          say "\n"
+        end
+      end
+
+      def to_generator_args(options)
+        options.flat_map { |key, value| ["--#{key}", value.to_s] }
+      end
+    end
+  end
+
+  class RemoteCLI < BaseCLI
+    map 'signoz:opentelemetry' => :signoz_opentelemetry
+
+    desc 'signoz SERVER', 'Install SigNoz observability server on a remote machine'
+    long_desc <<-LONGDESC
+      Installs SigNoz server on a remote machine. SigNoz is a full-stack open-source APM#{' '}
+      and observability tool.
+
+      Examples:
+        # Install using SSH key authentication
+        $ railsmaker remote signoz --ssh-host=example.com --ssh-user=deploy --key-path=~/.ssh/id_rsa
+
+        # Install using password authentication (will prompt for password)
+        $ railsmaker remote signoz --ssh-host=example.com --ssh-user=deploy
+
+        # Force reinstallation of existing instance
+        $ railsmaker remote signoz --ssh-host=example.com --ssh-user=deploy --force
+    LONGDESC
+    method_option :ssh_host, type: :string, required: true, desc: 'SSH host (e.g., 123.456.789.0)'
+    method_option :ssh_user, type: :string, default: 'root', desc: 'SSH user with sudo access'
+    method_option :key_path, type: :string, desc: 'Path to SSH key (if not provided, will use password auth)'
+    method_option :force, type: :boolean, default: false, desc: 'Force reinstallation if already installed'
+    def signoz
+      print_remote_summary('SigNoz Installation', options)
+      RailsMaker::Generators::SignozGenerator.start(to_generator_args(options))
+    end
+
+    desc 'signoz:opentelemetry', 'Install SigNoz OpenTelemetry collector on a remote machine'
+    long_desc <<-LONGDESC
+      Installs and configures the OpenTelemetry collector on a remote machine to send metrics,#{' '}
+      traces, and logs to your SigNoz server.
+
+      The collector will be configured to:
+        • Collect Docker container logs
+        • Forward metrics and traces
+        • Auto-discover running services
+
+      Examples:
+        # Basic installation
+        $ railsmaker remote signoz:opentelemetry --ssh-host=app.example.com --ssh-user=deploy \\
+            --signoz-host=signoz.example.com
+
+        # With custom hostname for better identification
+        $ railsmaker remote signoz:opentelemetry --ssh-host=app.example.com --ssh-user=deploy \\
+            --signoz-host=signoz.example.com --hostname=production-app-1
+    LONGDESC
+    method_option :ssh_host, type: :string, required: true, desc: 'SSH host where collector will be installed'
+    method_option :signoz_server_host, type: :string, required: true, desc: 'Host where SigNoz server is running'
+    method_option :ssh_user, type: :string, default: 'root', desc: 'SSH user with sudo access'
+    method_option :hostname, type: :string, default: 'rails-apps-1', desc: 'Custom hostname identifier of the server'
+    method_option :key_path, type: :string, desc: 'Path to SSH key (if not provided, will use password auth)'
+    method_option :force, type: :boolean, default: false, desc: 'Force reinstallation if already installed'
+    def signoz_opentelemetry
+      print_remote_summary('SigNoz OpenTelemetry Installation', options)
+      RailsMaker::Generators::SignozOpentelemetryGenerator.start(to_generator_args(options))
+    end
+
+    desc 'plausible', 'Install Plausible Analytics on a remote server'
+    long_desc <<-LONGDESC
+      Installs Plausible Analytics on a remote machine. Plausible is a lightweight,#{' '}
+      open-source alternative to Google Analytics.
+
+      Examples:
+        # Basic installation
+        $ railsmaker remote plausible --ssh-host=analytics.example.com --ssh-user=deploy \\
+            --analytics-host=plausible.example.com
+
+        # With custom SSH key
+        $ railsmaker remote plausible --ssh-host=analytics.example.com --ssh-user=deploy \\
+            --analytics-host=plausible.example.com --key-path=~/.ssh/analytics_key
+    LONGDESC
+    method_option :ssh_host, type: :string, required: true, desc: 'SSH host where Plausible will be installed'
+    method_option :analytics_host, type: :string, required: true, desc: 'Domain where Plausible will be accessible'
+    method_option :ssh_user, type: :string, default: 'root', desc: 'SSH user with sudo access'
+    method_option :key_path, type: :string, desc: 'Path to SSH key (if not provided, will use password auth)'
+    method_option :force, type: :boolean, default: false, desc: 'Force reinstallation if already installed'
+    def plausible
+      print_remote_summary('Plausible Installation', options)
+      RailsMaker::Generators::PlausibleGenerator.start(to_generator_args(options))
+    end
+
+    private
+
+    def print_remote_summary(title, opts)
+      sections = {
+        'Connection Details' => [
+          ['SSH Host', opts[:ssh_host], :highlight],
+          ['SSH User', opts[:ssh_user], :highlight]
+        ]
+      }
+
+      if opts[:signoz_server_host]
+        sections['Configuration'] = [
+          ['SigNoz Host', opts[:signoz_server_host], :highlight],
+          ['Custom Hostname', opts[:hostname], :highlight]
+        ]
+      end
+
+      if opts[:analytics_host]
+        sections['Configuration'] = [
+          ['Analytics Host', opts[:analytics_host], :highlight]
+        ]
+      end
+
+      print_summary(title, sections)
+    end
+  end
+
+  class CLI < BaseCLI
+    map 'new:wizard' => :new_wizard
+
+    desc 'new', 'Generate a new Rails application with integrated features'
+    method_option :name, type: :string, required: true, aliases: '-n', desc: 'Application name'
+    method_option :docker, type: :string, required: true, aliases: '-d', desc: 'Docker username'
+    method_option :ip, type: :string, required: true, aliases: '-i', desc: 'Server IP address'
+    method_option :domain, type: :string, required: true, aliases: '-D', desc: 'Domain name'
+    method_option :auth, type: :boolean, default: true, desc: 'Include authentication'
+    method_option :mailjet, type: :boolean, default: true, desc: 'Configure Mailjet for email'
+    method_option :bucketname, type: :string, desc: 'Enable litestream backups (provide your BUCKETNAME)'
+    method_option :opentelemetry, type: :boolean, default: true, desc: 'Configure OpenTelemetry'
+    method_option :analytics, type: :string, desc: 'Set up Plausible Analytics (provide your ANALYTICS_DOMAIN)'
+    method_option :sentry, type: :boolean, default: true, desc: 'Configure Sentry error tracking'
+    method_option :ui, type: :boolean, default: true, desc: 'Include UI assets'
+    def new
+      self.destination_root = File.expand_path(options[:name], Dir.pwd)
+      say "Generating new Rails application: #{options[:name]}", :yellow
+      generate_application(options)
+    end
+
+    desc 'new:wizard', 'Launch an interactive wizard for generating a Rails application'
+    def new_wizard
+      say 'Welcome to the RailsMaker wizard!', :blue
+      wizard_options = collect_wizard_options
+      self.destination_root = File.expand_path(wizard_options[:name], Dir.pwd)
+      say "Generating new Rails application: #{wizard_options[:name]}", :yellow
+      generate_application(wizard_options)
+    end
+
+    desc 'remote', 'Manage remote services'
+    subcommand 'remote', RailsMaker::RemoteCLI
+
+    def self.exit_on_failure?
+      true
+    end
+
+    private
+
+    def cleanup_on_failure
+      return unless File.directory?(destination_root)
+      return unless $!.to_s.include?('Failed to generate app')
+
+      say_status 'cleanup', "Removing directory: #{destination_root}", :yellow
+      FileUtils.rm_rf(destination_root)
+    end
+
+    def generate_application(opts)
+      print_app_summary(opts)
+      return unless yes?('Do you want to proceed with the installation? (y/N)')
+
+      begin
+        generate_components(opts)
+        say 'Successfully generated RailsMaker template 🎉', :green
+      rescue StandardError => e
+        cleanup_on_failure
+        raise
+      end
+    end
+
+    def print_app_summary(opts)
+      sections = {
+        'Application Settings' => [
+          ['Name:', opts[:name], :highlight],
+          ['Docker:', opts[:docker], :highlight],
+          ['IP:', opts[:ip], :highlight],
+          ['Domain:', opts[:domain], :highlight]
+        ],
+        'Features & Integrations' => [
+          ['Authentication', opts[:auth], :status],
+          ['Mailjet Email', opts[:mailjet], :status],
+          ['Litestream Backups', opts[:bucketname], :status],
+          ['OpenTelemetry', opts[:opentelemetry], :status],
+          ['Plausible Analytics', opts[:analytics], :status],
+          ['Sentry Error Tracking', opts[:sentry], :status],
+          ['UI Components', opts[:ui], :status]
+        ]
+      }
+
+      print_summary('Configuration Summary', sections)
+      print_warnings(opts)
+    end
+
+    def print_warnings(opts)
+      warnings = []
+      if !opts[:ui] && opts[:analytics]
+        warnings << "- Analytics was enabled but won't be installed because UI is disabled"
+      end
+
+      if !opts[:ui] && opts[:auth]
+        warnings << "- Authentication was enabled but won't be installed because UI is disabled"
+      end
+
+      return unless warnings.any?
+
+      say "\nWarnings:", :yellow
+      warnings.each { |warning| say warning, :yellow }
+    end
+
+    def generate_components(opts)
+      generator_args = to_generator_args(opts)
+
+      RailsMaker::Generators::AppGenerator.start(generator_args)
+
+      if opts[:ui]
+        RailsMaker::Generators::AuthGenerator.start(generator_args) if opts[:auth]
+        RailsMaker::Generators::UiGenerator.start(generator_args)
+        RailsMaker::Generators::PlausibleInstrumentationGenerator.start(generator_args) if opts[:analytics]
+      end
+
+      RailsMaker::Generators::MailjetGenerator.start(generator_args) if opts[:mailjet]
+      RailsMaker::Generators::LitestreamGenerator.start(generator_args) if opts[:bucketname]
+      RailsMaker::Generators::OpentelemetryGenerator.start(generator_args) if opts[:opentelemetry]
+      RailsMaker::Generators::SentryGenerator.start(generator_args) if opts[:sentry]
+    end
+
+    def collect_wizard_options
+      wizard_options = {
+        name: options[:name],
+        docker: options[:docker],
+        ip: options[:ip],
+        domain: options[:domain],
+        auth: options[:auth],
+        mailjet: options[:mailjet],
+        bucketname: options[:bucketname],
+        opentelemetry: options[:opentelemetry],
+        analytics: options[:analytics],
+        sentry: options[:sentry],
+        ui: options[:ui]
+      }
+
+      # Only ask for values that weren't provided via command line
+      while wizard_options[:name].to_s.empty?
+        wizard_options[:name] = ask('Application name:')
+        say 'Application name is required', :red if wizard_options[:name].empty?
+      end
+
+      while wizard_options[:docker].to_s.empty?
+        wizard_options[:docker] = ask('Docker username:')
+        say 'Docker username is required', :red if wizard_options[:docker].empty?
+      end
+
+      while wizard_options[:ip].to_s.empty?
+        wizard_options[:ip] = ask('Server IP address:')
+        say 'Server IP address is required', :red if wizard_options[:ip].empty?
+      end
+
+      while wizard_options[:domain].to_s.empty?
+        wizard_options[:domain] = ask('Domain name:')
+        say 'Domain name is required', :red if wizard_options[:domain].empty?
+      end
+
+      wizard_options[:auth] = yes?('Include authentication? (y/N)') if wizard_options[:auth].nil?
+      wizard_options[:mailjet] = yes?('Configure Mailjet for email? (y/N)') if wizard_options[:mailjet].nil?
+      wizard_options[:bucketname] ||= ask('Litestream bucketname: Provide BUCKET_NAME (leave blank to skip):')
+      if wizard_options[:opentelemetry].nil?
+        wizard_options[:opentelemetry] =
+          yes?('Configure OpenTelemetry for metrics? (y/N)')
+      end
+      wizard_options[:analytics] ||= ask('Plausible Analytics: Provide ANALYTICS_DOMAIN (leave blank to skip):')
+      wizard_options[:sentry] = yes?('Configure Sentry error tracking? (y/N)') if wizard_options[:sentry].nil?
+      wizard_options[:ui] = yes?('Include UI assets? (y/N)') if wizard_options[:ui].nil?
+
+      wizard_options[:bucketname] = nil if wizard_options[:bucketname] && wizard_options[:bucketname].empty?
+      wizard_options[:analytics] = nil if wizard_options[:analytics] && wizard_options[:analytics].empty?
+
+      wizard_options
+    end
+  end
+end
+
+begin
+  RailsMaker::CLI.start
+rescue StandardError => e
+  puts "\nError: #{e.message}"
+  puts e.backtrace if ENV['DEBUG']
+  puts "\nIf you need help, please create an issue at: https://github.com/sgerov/railsmaker/issues"
+  exit 1
+end

data/lib/railsmaker/generators/app_generator.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module RailsMaker
+  module Generators
+    class AppGenerator < BaseGenerator
+      source_root File.expand_path('templates/app', __dir__)
+
+      class_option :name, type: :string, required: true, desc: 'Name of the application'
+      class_option :docker, type: :string, required: true, desc: 'Docker username'
+      class_option :ip, type: :string, required: true, desc: 'Server IP address'
+      class_option :domain, type: :string, required: true, desc: 'Domain name'
+      class_option :ui, type: :boolean, default: false, desc: 'Include UI assets?'
+
+      def check_required_env_vars
+        super(%w[
+          KAMAL_REGISTRY_PASSWORD
+        ])
+      end
+
+      def generate_app
+        self.destination_root = File.expand_path(options[:name], current_dir)
+
+        if !in_minitest? && File.directory?(destination_root)
+          say_status 'error', "Directory '#{options[:name]}' already exists", :red
+          raise BaseGeneratorError, 'Directory already exists'
+        end
+
+        say('Creating new Rails app')
+        rails_args = [options[:name]]
+        rails_args << '--javascript=bun' if options[:ui]
+        Rails::Generators::AppGenerator.start(rails_args)
+
+        setup_frontend if options[:ui]
+
+        validate_gsub_strings([
+                                {
+                                  file: 'config/deploy.yml',
+                                  patterns: ['your-user', "web:\n    - 192.168.0.1", 'ssl: true', 'app.example.com']
+                                }
+                              ])
+
+        setup_kamal
+
+        say('Modifying ApplicationController to allow all browsers (mobile)')
+        comment_lines 'app/controllers/application_controller.rb', /allow_browser versions: :modern/
+
+        say('Generating main controller with a landing page')
+        generate :controller, 'main'
+
+        if options[:ui]
+          copy_file 'main_index.html.erb', 'app/views/main/index.html.erb'
+        else
+          create_file 'app/views/main/index.html.erb', "<h1>Welcome to #{options[:name]}</h1>"
+        end
+
+        copy_file 'credentials.example.yml', 'config/credentials.example.yml'
+
+        route "root 'main#index'"
+      rescue StandardError => e
+        say_status 'error', "Failed to generate app: #{e.message} in #{destination_root}", :red
+        raise BaseGeneratorError, e.message
+      end
+
+      def git_commit
+        git add: '.', commit: %(-m 'Initial railsmaker commit')
+
+        say 'Successfully created Rails app with RailsMaker', :green
+      end
+
+      private
+
+      def setup_frontend
+        say('Adding Tailwind CSS')
+        gem 'tailwindcss-rails', '~> 4.0.0.rc5'
+
+        say('Installing gems')
+        run 'bundle install --quiet'
+
+        say('Setting up Tailwind')
+        run 'bun add -d tailwindcss@4.0.0 @tailwindcss/cli@4.0.0'
+        rails_command 'tailwindcss:install'
+
+        say('Installing DaisyUI')
+        run 'bun add -d daisyui@5.0.0-beta.2'
+
+        validate_gsub_strings([
+                                {
+                                  file: 'app/views/layouts/application.html.erb',
+                                  patterns: ['<main class="container mx-auto mt-28 px-5 flex">', '<html>']
+                                },
+                                {
+                                  file: 'app/assets/tailwind/application.css',
+                                  patterns: ['@import "tailwindcss";']
+                                },
+                                {
+                                  file: 'Dockerfile',
+                                  patterns: ['bun.lockb', 'RUN SECRET_KEY_BASE_DUMMY=1 ./bin/rails assets:precompile',
+                                             '# Precompiling assets for production']
+                                },
+                                {
+                                  file: 'app/views/layouts/application.html.erb',
+                                  patterns: []
+                                }
+                              ])
+
+        inject_into_file 'app/assets/tailwind/application.css', after: '@import "tailwindcss";' do
+          <<~RUBY
+
+
+            @plugin "daisyui" {
+              themes: light --default, dark --prefersdark, cupcake;
+            }
+          RUBY
+        end
+        gsub_file 'app/views/layouts/application.html.erb', '<html>', '<html data-theme="cupcake">'
+        gsub_file 'app/views/layouts/application.html.erb', '<main class="container mx-auto mt-28 px-5 flex">',
+                  '<main>'
+
+        say('Dockerfile: fixing legacy bun.lockb')
+        gsub_file 'Dockerfile', 'bun.lockb', 'bun.lock'
+
+        say('Dockerfile: fixing for Apple Silicon amd64 emulation')
+        gsub_file 'Dockerfile',
+                  'RUN SECRET_KEY_BASE_DUMMY=1 ./bin/rails assets:precompile',
+                  'RUN TAILWINDCSS_INSTALL_DIR=node_modules/.bin SECRET_KEY_BASE_DUMMY=1 ./bin/rails assets:precompile'
+        inject_into_file 'Dockerfile', before: /# Precompiling assets for production/ do
+          <<~RUBY
+            # Ensure bun handles tailwind node bash binary
+            RUN ln -s /usr/local/bun/bin/bun /usr/local/bun/bin/node\n
+          RUBY
+        end
+      end
+
+      def setup_kamal
+        say('Configuring Kamal')
+
+        inject_into_file 'config/deploy.yml', after: 'service: railsmaker' do
+          "\ndeploy_timeout: 60 # to avoid timeout on first deploy"
+        end
+        gsub_file 'config/deploy.yml', 'your-user', options[:docker]
+        gsub_file 'config/deploy.yml', "web:\n    - 192.168.0.1", "web:\n    hosts:\n      - #{options[:ip]}"
+        gsub_file 'config/deploy.yml', 'app.example.com', options[:domain]
+        inject_into_file 'config/deploy.yml', after: 'ssl: true' do
+          "\n  forward_headers: true"
+        end
+      end
+
+      def current_dir
+        Dir.pwd
+      end
+
+      def in_minitest?
+        defined?(Minitest)
+      end
+    end
+  end
+end