easy_caddy 0.1.0

data/lib/easy_caddy/commands/ensure.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'register_helpers'
+
+module EasyCaddy
+  module Commands
+    # One-shot: copies the project Caddyfile into global sites/, reloads Caddy, then exits.
+    # Site stays registered until `ecaddy down NAME` or `ecaddy remove NAME`.
+    class Ensure
+      include RegisterHelpers
+
+      def initialize(config_path:, site:)
+        @config_path = config_path
+        @site        = site
+      end
+
+      def call
+        register(@config_path, @site)
+      end
+    end
+  end
+end

data/lib/easy_caddy/commands/list.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative '../registry'
+require_relative '../paths'
+require_relative '../parser'
+
+module EasyCaddy
+  module Commands
+    class List
+      def initialize(format: 'table')
+        @format   = format
+        @registry = Registry.load
+      end
+
+      def call
+        sites = @registry.all
+        if sites.empty?
+          puts '  No sites registered. Use `ecaddy run --config ./Caddyfile --site NAME` to add one.'
+          return
+        end
+
+        if @format == 'json'
+          require 'json'
+          puts JSON.generate(sites.map { |s| row_data(s) })
+          return
+        end
+
+        require 'tty-table'
+        rows = sites.map { |s| row_data(s).values }
+
+        table = TTY::Table.new(
+          header: ['Name', 'Status', 'Domains', 'Ports', 'Source'],
+          rows:   rows
+        )
+        puts table.render(:unicode, padding: [0, 1])
+      end
+
+      private
+
+      def row_data(site)
+        frag   = Paths.site_file(site.name)
+        parsed = frag.exist? ? Parser.parse(frag.read) : nil
+        {
+          name:   site.name,
+          status: site.enabled ? 'up' : 'down',
+          domains: parsed&.domains&.join(', ') || '-',
+          ports:   parsed&.ports&.join(', ') || '-',
+          source:  site.source_path || '-'
+        }
+      end
+    end
+  end
+end

data/lib/easy_caddy/commands/logs.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative '../registry'
+require_relative '../paths'
+require_relative '../parser'
+
+module EasyCaddy
+  module Commands
+    # Tails Caddy access/error log files for a registered site.
+    class Logs
+      def initialize(site:, lines:, follow:)
+        @site   = site
+        @lines  = lines
+        @follow = follow
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      def call
+        registry = Registry.load
+        entry    = registry.find(@site)
+        abort "  [ecaddy] No site '#{@site}' in registry. Run `ecaddy list` to see registered sites." unless entry
+
+        fragment = resolve_fragment(entry)
+        abort "  [ecaddy] Fragment not found for '#{@site}' in sites/ or disabled/." unless fragment
+
+        paths = Parser.parse(File.read(fragment)).log_paths
+        if paths.empty?
+          puts "  [ecaddy] No 'output file' log directives found in #{fragment}."
+          puts '           Add a log block to your Caddyfile, e.g.:'
+          puts '             log { output file log/caddy.log }'
+          return
+        end
+
+        paths.each do |p|
+          next if File.exist?(p)
+
+          puts "  [ecaddy] Note: #{p} not yet created (Caddy writes it on first request)."
+        end
+
+        existing = paths.select { |p| File.exist?(p) }
+        if existing.empty?
+          puts '  [ecaddy] No log files exist yet. Make a request to the site first.'
+          return
+        end
+
+        tail_args = @follow ? ['-F'] : ['-n', @lines.to_s]
+        exec('tail', *tail_args, *existing)
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+      private
+
+      def resolve_fragment(entry)
+        enabled  = Paths.site_file(entry.name)
+        disabled = Paths.disabled_file(entry.name)
+        return enabled  if enabled.exist?
+        return disabled if disabled.exist?
+
+        nil
+      end
+    end
+  end
+end

data/lib/easy_caddy/commands/register_helpers.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'socket'
+require 'openssl'
+require_relative '../paths'
+require_relative '../registry'
+require_relative '../conflicts'
+require_relative '../caddy'
+require_relative '../site'
+require_relative '../parser'
+
+module EasyCaddy
+  module Commands
+    module RegisterHelpers
+      private
+
+      # Copies config_path into ~/.config/caddy/sites/<name>.caddy and reloads.
+      # Returns the site name on success.
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+      def register(config_path, name)
+        raise ArgumentError, 'Pass --site NAME to identify this project.' unless name
+
+        config_path = File.expand_path(config_path)
+        raise ArgumentError, "Config not found: #{config_path}" unless File.exist?(config_path)
+
+        content  = File.read(config_path)
+        registry = Registry.load
+        existing = registry.find(name)
+
+        findings = Conflicts.check(name: name, content: content, registry: registry,
+                                   skip_name: existing&.name)
+        blocks = findings.select { |f| f.severity == 'BLOCK' }
+        unless blocks.empty?
+          blocks.each { |f| warn "  BLOCK: #{f.message}\n         Hint: #{f.hint}" }
+          raise 'Aborting due to conflict.'
+        end
+
+        Paths.sites_dir.mkpath
+        rewritten = absolutize_log_paths(content, File.dirname(config_path))
+        Paths.site_file(name).write(rewritten)
+
+        ensure_log_dirs(rewritten)
+
+        site = Site.new(name: name, enabled: true, source_path: config_path)
+        existing ? registry.update(site) : registry.add(site)
+
+        Caddy.validate!(Paths.caddyfile)
+        Caddy.reload(Paths.caddyfile)
+
+        puts "  [ecaddy] #{name} registered (#{config_path})"
+        probe_tls(Parser.parse(rewritten).domains)
+        name
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+      # Rewrite `output file <relative>` log paths to absolute paths so Caddy can
+      # write logs regardless of its working directory when running as a service.
+      def absolutize_log_paths(content, base_dir)
+        content.gsub(/(\boutput\s+file\s+)(\S+)/) do
+          prefix = Regexp.last_match(1)
+          path   = Regexp.last_match(2)
+          absolute = File.expand_path(path, base_dir)
+          "#{prefix}#{absolute}"
+        end
+      end
+
+      def ensure_log_dirs(content)
+        Parser.parse(content).log_paths.each do |path|
+          FileUtils.mkdir_p(File.dirname(path))
+        end
+      end
+
+      def probe_tls(domains)
+        domains.each do |domain|
+          ok = tls_handshake_ok?(domain)
+          next if ok
+
+          warn "  [ecaddy] WARN  #{domain}: TLS handshake failed (Caddy may not be serving :443 yet)."
+          warn '                 Run `ecaddy audit` to diagnose.'
+        end
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def tls_handshake_ok?(domain)
+        require 'timeout'
+        Timeout.timeout(1) do
+          tcp = TCPSocket.new('localhost', 443)
+          ssl = OpenSSL::SSL::SSLSocket.new(tcp)
+          ssl.hostname   = domain
+          ssl.sync_close = true
+          ssl.connect
+          ssl.close
+        end
+        true
+      rescue StandardError
+        false
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def unregister(name)
+        Paths.site_file(name).delete if Paths.site_file(name).exist?
+
+        registry = Registry.load
+        registry.remove(name)
+
+        begin
+          Caddy.reload(Paths.caddyfile)
+        rescue StandardError
+          nil
+        end
+        puts "  [ecaddy] #{name} unregistered."
+      end
+    end
+  end
+end

data/lib/easy_caddy/commands/reload.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative '../caddy'
+require_relative '../paths'
+
+module EasyCaddy
+  module Commands
+    class Reload
+      def call
+        Caddy.validate!(Paths.caddyfile)
+        Caddy.reload(Paths.caddyfile)
+        puts '  Caddy reloaded.'
+      end
+    end
+  end
+end

data/lib/easy_caddy/commands/remove.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative '../paths'
+require_relative '../registry'
+require_relative '../caddy'
+
+module EasyCaddy
+  module Commands
+    class Remove
+      def initialize(name:, force:, prompt:)
+        @name     = name.downcase
+        @force    = force
+        @prompt   = prompt
+        @registry = Registry.load
+      end
+
+      def call
+        site = @registry.find(@name)
+        unless site
+          warn "  Site '#{@name}' is not registered."
+          exit 1
+        end
+
+        unless @force
+          unless @prompt.yes?("Remove #{@name} and delete its Caddy fragment?")
+            puts '  Aborted.'
+            return
+          end
+        end
+
+        [Paths.site_file(@name), Paths.disabled_file(@name)].each do |f|
+          f.delete if f.exist?
+        end
+
+        @registry.remove(@name)
+        Caddy.reload(Paths.caddyfile)
+        puts "  Removed '#{@name}'."
+      end
+    end
+  end
+end

data/lib/easy_caddy/commands/run.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'register_helpers'
+
+module EasyCaddy
+  module Commands
+    # Foreground command for Procfile.dev.
+    # Registers the project Caddyfile on start, blocks until SIGTERM/SIGINT,
+    # then unregisters and exits cleanly.
+    class Run
+      include RegisterHelpers
+
+      def initialize(config_path:, site:)
+        @config_path = config_path
+        @site        = site
+      end
+
+      def call
+        @registered_name = register(@config_path, @site)
+
+        cleanup = proc do
+          puts "\n  [ecaddy] Shutting down — removing #{@registered_name}..."
+          unregister(@registered_name)
+          exit 0
+        end
+
+        Signal.trap('TERM', &cleanup)
+        Signal.trap('INT',  &cleanup)
+
+        puts "  [ecaddy] Watching. Send SIGTERM or Ctrl-C to unregister."
+        loop { sleep 5 }
+      end
+    end
+  end
+end

data/lib/easy_caddy/commands/setup.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative '../paths'
+require_relative '../caddy'
+
+module EasyCaddy
+  module Commands
+    class Setup
+      GLOBAL_CADDYFILE_CONTENT = <<~CADDY
+        {
+          admin localhost:2019
+        }
+
+        import sites/*.caddy
+      CADDY
+
+      def initialize(prompt:)
+        @prompt = prompt
+      end
+
+      def call
+        step('Checking Caddy binary') { ensure_caddy_installed }
+        step('Scaffolding config directories') { scaffold_dirs }
+        step('Writing global Caddyfile') { write_caddyfile }
+        step('Symlinking for brew services') { symlink_brew }
+        step('Trusting local CA') { trust_ca }
+        step('Starting caddy service') { start_service }
+        print_success
+      end
+
+      private
+
+      def step(label)
+        print "  #{label}... "
+        yield
+        puts 'done'
+      rescue StandardError => e
+        puts "FAILED\n    #{e.message}"
+        raise
+      end
+
+      def ensure_caddy_installed
+        return if Caddy.installed?
+
+        unless @prompt.yes?('caddy is not installed. Install via Homebrew now?')
+          raise 'caddy is required. Install it with: brew install caddy'
+        end
+
+        Caddy.install_via_brew
+        raise 'caddy installation failed' unless Caddy.installed?
+      end
+
+      def scaffold_dirs
+        [Paths.root, Paths.sites_dir, Paths.disabled_dir].each(&:mkpath)
+      end
+
+      def write_caddyfile
+        return if Paths.caddyfile.exist?
+
+        Paths.caddyfile.write(GLOBAL_CADDYFILE_CONTENT)
+      end
+
+      def symlink_brew
+        target  = Paths.caddyfile
+        symlink = Paths.brew_caddyfile
+        return if symlink.symlink? && symlink.readlink == target
+
+        if symlink.exist? && !symlink.symlink?
+          bak = "#{symlink}.bak.#{Time.now.strftime('%Y%m%d%H%M%S')}"
+          symlink.rename(bak)
+          puts "\n    Backed up existing #{symlink} → #{bak}"
+        end
+
+        symlink.parent.mkpath
+        symlink.make_symlink(target)
+      end
+
+      def trust_ca
+        puts "\n    Running `caddy trust` — you may be prompted for your password."
+        raise '`caddy trust` failed — re-run `ecaddy setup` or run `sudo caddy trust` manually.' unless Caddy.trust
+      end
+
+      def start_service
+        if Caddy.running?
+          Caddy.restart_service
+        else
+          Caddy.start_service
+        end
+      end
+
+      def print_success
+        puts
+        puts '  ecaddy setup complete!'
+        puts
+        puts '  Next steps:'
+        puts '    ecaddy add myapp --port 3001 --vite-port 3050'
+        puts '    # then visit https://myapp.localhost'
+        puts
+        puts '  Or in your Procfile.dev:'
+        puts '    caddy: ecaddy run --config ./Caddyfile'
+      end
+    end
+  end
+end

data/lib/easy_caddy/commands/status.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../registry'
+require_relative '../caddy'
+require_relative '../conflicts'
+require_relative '../paths'
+
+module EasyCaddy
+  module Commands
+    class Status
+      def call
+        running = Caddy.running?
+        puts "  Caddy service: #{running ? 'running' : 'STOPPED'}"
+        puts "  Config:        #{Paths.caddyfile}"
+        puts
+
+        registry = Registry.load
+        sites    = registry.all
+
+        if sites.empty?
+          puts '  No sites registered.'
+          return
+        end
+
+        dead_msgs = Conflicts.doctor(registry: registry)
+          .select { |f| f.severity == 'INFO' }
+          .map(&:message)
+
+        sites.each do |s|
+          site_dead = dead_msgs.any? { |m| m.start_with?(s.name) }
+          label     = !s.enabled ? 'down' : (site_dead ? 'up (app not running)' : 'up')
+          puts "  #{s.name.ljust(20)} #{label}"
+          puts "    fragment: #{Paths.site_file(s.name)}" if s.enabled
+          puts "    source:   #{s.source_path}" if s.source_path
+        end
+      end
+    end
+  end
+end

data/lib/easy_caddy/commands/up.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative '../paths'
+require_relative '../registry'
+require_relative '../caddy'
+require_relative '../site'
+
+module EasyCaddy
+  module Commands
+    class Up
+      def initialize(name:)
+        @name     = name.downcase
+        @registry = Registry.load
+      end
+
+      def call
+        site = @registry.find(@name)
+        unless site
+          warn "  Site '#{@name}' is not registered."
+          exit 1
+        end
+
+        if site.enabled
+          puts "  '#{@name}' is already up."
+          return
+        end
+
+        disabled = Paths.disabled_file(@name)
+        unless disabled.exist?
+          warn "  Fragment not found in disabled/: #{disabled}"
+          exit 1
+        end
+
+        disabled.rename(Paths.site_file(@name))
+        @registry.update(Site.new(name: site.name, enabled: true, source_path: site.source_path))
+        Caddy.validate!(Paths.caddyfile)
+        Caddy.reload(Paths.caddyfile)
+        puts "  '#{@name}' is up."
+      end
+    end
+  end
+end

data/lib/easy_caddy/conflicts.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require_relative 'registry'
+require_relative 'paths'
+require_relative 'parser'
+
+module EasyCaddy
+  class Conflicts
+    Finding = Data.define(:severity, :message, :hint)
+
+    # Check a fragment file about to be written for domain/port collisions with existing enabled sites.
+    # skip_name: the site being updated (exclude it from collision checks against itself).
+    def self.check(name:, content:, registry:, skip_name: nil)
+      new(name: name, content: content, registry: registry, skip_name: skip_name).check
+    end
+
+    def self.doctor(registry:)
+      new(name: nil, content: nil, registry: registry, skip_name: nil).doctor
+    end
+
+    def initialize(name:, content:, registry:, skip_name:)
+      @name      = name
+      @content   = content
+      @registry  = registry
+      @skip_name = skip_name
+    end
+
+    def check
+      return [] unless @content
+
+      incoming = Parser.parse(@content)
+      findings = []
+      findings += domain_conflicts(incoming.domains)
+      findings += port_conflicts(incoming.ports)
+      findings
+    end
+
+    def doctor
+      findings = []
+      findings += cross_site_conflicts
+      findings += dead_upstream_findings
+      findings
+    end
+
+    private
+
+    def domain_conflicts(incoming_domains)
+      existing_domains = enabled_site_data
+        .reject { |name, _| name == (@skip_name || @name) }
+        .values.flat_map { |d| d[:domains] }
+
+      (incoming_domains & existing_domains).map do |d|
+        owner = enabled_site_data.find { |_, data| data[:domains].include?(d) }&.first
+        Finding.new(
+          severity: 'BLOCK',
+          message:  "Domain #{d} is already registered by '#{owner}'.",
+          hint:     "Run `ecaddy list` to see which project owns this domain."
+        )
+      end
+    end
+
+    def port_conflicts(incoming_ports)
+      findings = []
+      existing_ports = enabled_site_data
+        .reject { |name, _| name == (@skip_name || @name) }
+        .transform_values { |d| d[:ports] }
+
+      incoming_ports.each do |port|
+        existing_ports.each do |owner, ports|
+          next unless ports.include?(port)
+
+          findings << Finding.new(
+            severity: 'BLOCK',
+            message:  "Port #{port} is already used by '#{owner}'.",
+            hint:     "Choose a different port or run `ecaddy list` to see all ports in use."
+          )
+        end
+      end
+      findings
+    end
+
+    def cross_site_conflicts
+      findings = []
+      seen_ports   = {}
+      seen_domains = {}
+
+      enabled_site_data.each do |name, data|
+        data[:ports].each do |p|
+          if seen_ports[p]
+            findings << Finding.new(
+              severity: 'BLOCK',
+              message:  "Port #{p} is shared by '#{seen_ports[p]}' and '#{name}'.",
+              hint:     "Edit the conflicting Caddyfile and run `ecaddy run` again."
+            )
+          else
+            seen_ports[p] = name
+          end
+        end
+
+        data[:domains].each do |d|
+          if seen_domains[d]
+            findings << Finding.new(
+              severity: 'BLOCK',
+              message:  "Domain #{d} is shared by '#{seen_domains[d]}' and '#{name}'.",
+              hint:     "Edit the conflicting Caddyfile and run `ecaddy run` again."
+            )
+          else
+            seen_domains[d] = name
+          end
+        end
+      end
+      findings
+    end
+
+    def dead_upstream_findings
+      @registry.all.flat_map do |site|
+        fragment = Paths.site_file(site.name)
+        next [] unless fragment.exist?
+
+        parsed = Parser.parse(fragment.read)
+        parsed.ports.filter_map do |port|
+          next if tcp_open?(port)
+
+          Finding.new(
+            severity: 'INFO',
+            message:  "#{site.name}: upstream localhost:#{port} is not listening.",
+            hint:     "Start your app on port #{port}."
+          )
+        end
+      end
+    end
+
+    # Parse all enabled fragment files once, memoised.
+    def enabled_site_data
+      @enabled_site_data ||= @registry.all.each_with_object({}) do |site, h|
+        frag = Paths.site_file(site.name)
+        next unless frag.exist?
+
+        parsed = Parser.parse(frag.read)
+        h[site.name] = { domains: parsed.domains, ports: parsed.ports }
+      end
+    end
+
+    def tcp_open?(port)
+      require 'socket'
+      TCPSocket.new('localhost', port).close
+      true
+    rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT
+      false
+    end
+  end
+end