brunch 0.0.1 → 0.8.1

data/lib/brunch/hooks.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "open3"
+
+module Brunch
+  module Hooks
+    EVENTS = %w[branch-created remote-branch-created remote-branch-updated post-checkout worktree-created
+                worktree-removed worktree-moved worktree-pruned worktree-repaired].freeze
+
+    module_function
+
+    def install
+      abort "git-hooks-ext must be installed before running this command." unless system("ghe", "--version",
+                                                                                         out: File::NULL, err: File::NULL)
+      abort "Could not install the git-hooks-ext bridge." unless system("ghe", "install")
+
+      hooks_dir = git_output("rev-parse", "--git-path", "hooks")
+      EVENTS.each { |event| install_hook(File.join(hooks_dir, event), event) }
+      puts "Brunch hooks are installed."
+    end
+
+    def dispatch(event, arguments)
+      case event
+      when "post-checkout"
+        CLI.start(["activate"]) if arguments.fetch(2, "0") == "1"
+      when "branch-created", "remote-branch-created", "remote-branch-updated"
+        CLI.start(["register", arguments.fetch(0)])
+      when "worktree-created", "worktree-removed", "worktree-moved", "worktree-pruned", "worktree-repaired"
+        CLI.start(["worktree-event", event, *arguments])
+      else
+        abort "Unknown hook event: #{event}"
+      end
+    end
+
+    def git_output(*arguments)
+      output, status = Open3.capture2("git", *arguments)
+      abort "Git command failed: git #{arguments.join(' ')}" unless status.success?
+
+      output.strip
+    end
+    private_class_method :git_output
+
+    def install_hook(path, event)
+      contents = hook_contents(event)
+      abort "Refusing to replace existing hook: #{path}" if File.exist?(path) && File.read(path) != contents && !brunch_hook?(path)
+
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, contents)
+      FileUtils.chmod(0o755, path)
+    end
+    private_class_method :install_hook
+
+    def brunch_hook?(path)
+      contents = File.read(path)
+      contents.include?("require \"brunch\"") && contents.include?("Brunch::Hooks.dispatch")
+    end
+    private_class_method :brunch_hook?
+
+    def hook_contents(event)
+      library_path = File.expand_path("../brunch.rb", __dir__)
+      <<~RUBY
+        #!#{Gem.ruby}
+        # frozen_string_literal: true
+
+        repo_root = `git rev-parse --show-toplevel`.strip
+        gemfile = File.join(repo_root, "Gemfile")
+        bundled = false
+        if File.file?(gemfile) && File.read(gemfile).match?(/gem[[:space:]]+["']brunch["']/)
+          ENV["BUNDLE_GEMFILE"] = gemfile
+          begin
+            require "bundler/setup"
+            bundled = true
+          rescue LoadError, StandardError
+            ENV.delete("BUNDLE_GEMFILE")
+          end
+        end
+
+        if !bundled && File.file?(gemfile)
+          require #{library_path.inspect}
+        else
+          require "brunch"
+        end
+        Brunch::Hooks.dispatch(#{event.inspect}, ARGV)
+      RUBY
+    end
+    private_class_method :hook_contents
+  end
+end

data/lib/brunch/managers.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "open3"
+require "socket"
+
+module Brunch
+  module Managers
+    class Base
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      def available? = true
+
+      def create(_entry) = true
+
+      def environment(entry)
+        {
+          "BRUNCH_REF" => entry.fetch("ref", ""),
+          "BRUNCH_PORT" => entry.fetch("port").to_s,
+          "BRUNCH_PROJECT" => entry.fetch("project"),
+          "BRUNCH_SNAPSHOT" => entry.fetch("snapshot")
+        }
+      end
+
+      def port_available?(port)
+        socket = TCPSocket.new("127.0.0.1", port)
+        socket.close
+        false
+      rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ENETUNREACH
+        true
+      end
+
+      def stop(_entry); end
+
+      def status(_entry) = "unknown"
+
+      def healthy?(_entry) = false
+
+      def logs(_entry, *_arguments)
+        warn "Logs are not supported by this manager."
+        false
+      end
+
+      def reset(entry)
+        stop(entry)
+        remove_managed_files(entry)
+      end
+
+      def remove(entry)
+        stop(entry)
+        remove_managed_files(entry)
+        true
+      end
+
+      def remove_managed_files(entry)
+        target = entry["source_type"] == "worktree" ? entry["control"] : entry.fetch("snapshot")
+        FileUtils.rm_rf(target) if target
+      end
+    end
+
+    class DockerCompose < Base
+      def available?
+        system("docker", "info", out: File::NULL, err: File::NULL)
+      end
+
+      def start(entry) = compose(entry, "up", "--detach", "--build", "--remove-orphans")
+
+      def status(entry)
+        return "unavailable" unless available?
+
+        healthy?(entry) ? "running" : "stopped"
+      end
+
+      def healthy?(entry)
+        return false unless available?
+
+        output, status = Open3.capture2(*compose_command(entry, "ps", "--status", "running", "--quiet"))
+        status.success? && !output.strip.empty?
+      end
+
+      def logs(entry, *arguments)
+        arguments = ["--tail", "100"] if arguments.empty?
+        compose(entry, "logs", *arguments)
+      end
+
+      def port_available?(port)
+        ports, = Open3.capture2(*ports_command)
+        return false if ports.match?(/:#{port}->/)
+
+        super
+      end
+
+      def stop(entry)
+        compose(entry, "stop") if available?
+      end
+
+      def reset(entry)
+        compose(entry, "down", "--remove-orphans") if available?
+        remove_managed_files(entry)
+      end
+
+      def remove(entry)
+        return false unless available? && compose(entry, "down", "--volumes", "--remove-orphans")
+
+        remove_managed_files(entry)
+        true
+      end
+
+      private
+
+      def compose_command(entry, *arguments)
+        directory = compose_directory(entry)
+        compose_file = File.join(directory, entry.fetch("compose_file"))
+        ["docker", "compose", "--project-name", entry.fetch("project"), "--project-directory", directory, "--file",
+         compose_file, *arguments]
+      end
+
+      def compose_directory(entry)
+        source = entry.fetch("snapshot")
+        File.file?(File.join(source, entry.fetch("compose_file"))) ? source : entry.fetch("control", source)
+      end
+
+      def ports_command = ["docker", "ps", "--format", "{{.Ports}}"]
+
+      def compose(entry, *arguments)
+        system(environment(entry), *compose_command(entry, *arguments))
+      end
+    end
+
+    class PodmanCompose < DockerCompose
+      def available?
+        system("podman", "info", out: File::NULL, err: File::NULL)
+      end
+
+      def healthy?(entry)
+        return false unless available?
+
+        output, status = Open3.capture2("podman", "ps", "--filter",
+                                        "label=com.docker.compose.project=#{entry.fetch('project')}", "--quiet")
+        status.success? && !output.strip.empty?
+      end
+
+      private
+
+      def compose_command(entry, *arguments)
+        directory = compose_directory(entry)
+        compose_file = File.join(directory, entry.fetch("compose_file"))
+        ["podman", "compose", "-p", entry.fetch("project"), "-f", compose_file, *arguments]
+      end
+
+      def ports_command = ["podman", "ps", "--format", "{{.Ports}}"]
+
+      def compose(entry, *arguments)
+        system(environment(entry), *compose_command(entry, *arguments), chdir: compose_directory(entry))
+      end
+    end
+
+    class LocalProcess < Base
+      def start(entry)
+        log_directory = entry["source_type"] == "worktree" ? entry.fetch("control") : entry.fetch("snapshot")
+        log_path = File.join(log_directory, ".brunch.log")
+        entry["pid"] =
+          Process.spawn(environment(entry), "sh", "-lc", @configuration.fetch("command"), chdir: entry.fetch("snapshot"),
+                                                                                          out: [log_path, "a"], err: [log_path, "a"], pgroup: true)
+        entry["log_path"] = log_path
+        Process.detach(entry.fetch("pid"))
+        true
+      end
+
+      def stop(entry)
+        pid = entry["pid"]
+        return true unless pid
+
+        Process.kill("TERM", -pid)
+        true
+      rescue Errno::ESRCH
+        true
+      end
+
+      def status(entry) = running?(entry) ? "running" : "stopped"
+      def healthy?(entry) = running?(entry)
+
+      def logs(entry, *arguments)
+        return super unless arguments.empty?
+
+        path = entry["log_path"]
+        return super unless path && File.file?(path)
+
+        puts File.readlines(path).last(100)
+        true
+      end
+
+      private
+
+      def running?(entry)
+        Process.kill(0, entry.fetch("pid"))
+        true
+      rescue Errno::ESRCH
+        false
+      end
+    end
+
+    # Runs project-provided commands, making Brunch compatible with tools such
+    # as Podman, Kubernetes wrappers, Foreman, or custom process supervisors.
+    class Command < Base
+      def create(entry) = run("create", entry, optional: true)
+      def start(entry) = run("start", entry)
+      def stop(entry) = run("stop", entry)
+
+      def remove(entry)
+        run("remove", entry) && super
+      end
+
+      def status(entry)
+        if command?("status")
+          run("status", entry) ? "running" : "stopped"
+        else
+          "unknown"
+        end
+      end
+
+      def healthy?(entry)
+        return false unless command?("health")
+
+        run("health", entry)
+      end
+
+      def logs(entry, *arguments)
+        return super unless command?("logs")
+
+        run("logs", entry, arguments: arguments)
+      end
+
+      private
+
+      def run(action, entry, optional: false, arguments: [])
+        command = @configuration.fetch("commands")[action]
+        return true if optional && !command
+
+        abort "Missing commands.#{action} for the command manager." unless command
+        directory = if File.directory?(entry.fetch("snapshot"))
+                      entry.fetch("snapshot")
+                    else
+                      entry.fetch("control",
+                                  entry.fetch("snapshot"))
+                    end
+        system(environment(entry), "sh", "-lc", command, "brunch", *arguments, chdir: directory)
+      end
+
+      def command?(action) = @configuration.fetch("commands").key?(action)
+    end
+
+    module_function
+
+    def build(configuration)
+      case configuration.fetch("manager")
+      when "docker_compose" then DockerCompose.new(configuration)
+      when "podman_compose" then PodmanCompose.new(configuration)
+      when "local_process" then LocalProcess.new(configuration)
+      when "command" then Command.new(configuration)
+      else abort "Unknown Brunch manager: #{configuration.fetch('manager')}."
+      end
+    end
+  end
+end

data/lib/brunch/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Brunch
+  VERSION = "0.8.1"
+end

data/lib/brunch/worktree_mode.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Brunch
+  module WorktreeMode
+    def worktree_command(arguments)
+      case arguments
+      in ["worktree-event", "worktree-created", path, *_]
+        worktree_activate(path) if File.directory?(path)
+      in ["worktree-event", "worktree-removed" | "worktree-pruned", path, *_]
+        worktree_remove(path)
+      in ["worktree-event", "worktree-moved", old_path, new_path, *_]
+        worktree_move(old_path, new_path)
+      in ["worktree-event", "worktree-repaired", path, *_]
+        worktree_repair(path) if File.directory?(path)
+      in ["activate"] then worktree_activate(repo_root)
+      in ["restart"] then worktree_activate(repo_root, force: true)
+      in ["start", ref]
+        abort "Start the checked-out branch from its worktree." unless ref == worktree_ref(repo_root).first
+        worktree_activate(repo_root)
+      in ["stop"] then worktree_stop(repo_root)
+      in ["cleanup"] | ["register", _] then worktree_cleanup
+      in ["status"] then worktree_status
+      in ["ports"] then worktree_ports
+      in ["port"] then worktree_port
+      in ["logs", *arguments] then worktree_logs(arguments)
+      in ["run", "--", *command] if !command.empty? then worktree_run(command)
+      in ["doctor"] then worktree_doctor
+      else
+        warn "Usage: brunch {activate|start <current-ref>|stop|restart|status|ports|port|logs [args]|run -- <cmd>|doctor|cleanup}"
+        return 64
+      end
+      0
+    end
+
+    def with_state_lock
+      FileUtils.mkdir_p(state_root)
+      File.open(File.join(state_root, "lock"), "w") do |lock|
+        lock.flock(File::LOCK_EX)
+        data = state
+        result = yield(data)
+        save_state(data)
+        result
+      end
+    end
+
+    def with_worktree_lock(id)
+      directory = File.join(state_root, "worktree-locks")
+      FileUtils.mkdir_p(directory)
+      File.open(File.join(directory, id), "w") do |lock|
+        lock.flock(File::LOCK_EX)
+        yield
+      end
+    end
+
+    def worktree_identity(path)
+      git_dir, status = Open3.capture2("git", "-C", path, "rev-parse", "--absolute-git-dir")
+      abort "Not a Git worktree: #{path}" unless status.success?
+      Digest::SHA256.hexdigest(File.realpath(git_dir.strip))[0, 16]
+    end
+
+    def canonical_worktree_path(path)
+      File.join(File.realpath(File.dirname(path)), File.basename(path))
+    rescue Errno::ENOENT
+      File.expand_path(path)
+    end
+
+    def worktree_ref(path)
+      branch, status = Open3.capture2("git", "-C", path, "symbolic-ref", "--quiet", "--short", "HEAD")
+      head, head_status = Open3.capture2("git", "-C", path, "rev-parse", "HEAD")
+      abort "Worktree has no commit: #{path}" unless head_status.success?
+      [status.success? ? branch.strip : "detached-#{head.strip[0, 12]}", head.strip]
+    end
+
+    def worktree_manager(entry) = Managers.build(entry.fetch("configuration"))
+
+    def current_worktree_entry(data, path = repo_root)
+      id = worktree_identity(path)
+      record = data.fetch("worktrees", {})[id]
+      return [nil, nil] unless record
+
+      [record, record.fetch("environments", {})[record["current"]]]
+    end
+
+    def worktree_port_for(id, data, manager, base: preferred_port)
+      reserved = data.fetch("worktrees", {}).values.map { |record| record["port"] }
+      (base..CLI::PORT_RANGE.end).chain(CLI::PORT_RANGE.begin...base).find do |port|
+        !reserved.include?(port) && manager.port_available?(port)
+      end || abort("No free port for worktree #{id}.")
+    end
+
+    def worktree_activate(path, force: false)
+      path = File.realpath(path)
+      id = worktree_identity(path)
+      with_worktree_lock(id) do
+        ref, head = worktree_ref(path)
+        config = configuration(root: path)
+        manager = Managers.build(config)
+        abort "#{config.fetch('manager')} is unavailable." unless manager.available?
+
+        existing = nil
+        with_state_lock do |data|
+          record = data.fetch("worktrees", {})[id]
+          existing = record&.fetch("environments", {})&.[](ref)
+        end
+        return if existing && !force && existing["snapshot"] == path && existing["head"] == head && existing["status"] == "running"
+
+        previous = nil
+        port = nil
+        with_state_lock do |data|
+          record = (data["worktrees"] ||= {})[id] ||= { "path" => path, "environments" => {} }
+          previous = record.fetch("environments")[record["current"]] if record["current"] && record["current"] != ref
+          port = record["port"] ||= worktree_port_for(id, data, manager, base: config.fetch("preferred_port"))
+          record["path"] = path
+        end
+        if previous
+          abort "Could not stop previous environment for #{path}." unless worktree_manager(previous).stop(previous)
+          with_state_lock do |data|
+            data.fetch("worktrees").fetch(id).fetch("environments").fetch(previous.fetch("ref"))["status"] = "stopped"
+          end
+        end
+        abort "Could not reset environment for #{path}." if existing && !worktree_manager(existing).reset(existing)
+
+        project = "brunch-#{id[0, 12]}-#{Digest::SHA256.hexdigest(ref)[0, 12]}"
+        control = File.join(state_root, "controls", project)
+        archive_ref(head, control)
+        compose_file = config.fetch("compose_file")
+        if %w[docker_compose podman_compose].include?(config.fetch("manager"))
+          source_file = File.join(path, compose_file)
+          abort "Missing #{compose_file} in #{path}." unless File.file?(source_file)
+          destination = File.join(control, compose_file)
+          FileUtils.mkdir_p(File.dirname(destination))
+          FileUtils.cp(source_file, destination)
+        end
+        entry = { "source_type" => "worktree", "snapshot" => path, "control" => control,
+                  "ref" => ref, "head" => head, "port" => port, "project" => project,
+                  "compose_file" => compose_file, "configuration" => config, "status" => "starting" }
+        with_state_lock do |data|
+          record = data.fetch("worktrees").fetch(id)
+          record.fetch("environments")[ref] = entry
+          record["current"] = ref
+        end
+        abort "Could not create environment for #{path}." unless manager.create(entry)
+        abort "Could not start environment for #{path}." unless manager.start(entry)
+        with_state_lock do |data|
+          data.fetch("worktrees").fetch(id).fetch("environments")[ref] = entry.merge("status" => "running")
+        end
+        puts "Started #{ref} in #{path} at http://127.0.0.1:#{port}"
+      end
+    end
+
+    def worktree_stop(path)
+      id = worktree_identity(path)
+      with_worktree_lock(id) do
+        with_state_lock do |data|
+          _record, entry = current_worktree_entry(data, path)
+          raise CLI::OperationError, "No Brunch environment in this worktree." unless entry
+
+          abort "Could not stop #{entry.fetch('project')}." unless worktree_manager(entry).stop(entry)
+          entry["status"] = "stopped"
+          puts "Stopped #{entry.fetch('project')}."
+        end
+      end
+    end
+
+    def worktree_remove(path)
+      path = canonical_worktree_path(path)
+      data = state
+      id, = data.fetch("worktrees", {}).find { |_key, record| record["path"] == path }
+      return unless id
+
+      with_worktree_lock(id) do
+        record = state.fetch("worktrees").fetch(id)
+        record.fetch("environments").each do |ref, entry|
+          abort "Could not remove environment #{ref}." unless worktree_manager(entry).remove(entry)
+        end
+        with_state_lock { |locked| locked.fetch("worktrees").delete(id) }
+        puts "Removed Brunch environments for #{path}."
+      end
+    end
+
+    def worktree_move(old_path, new_path)
+      old_path = canonical_worktree_path(old_path)
+      new_path = File.realpath(new_path)
+      data = state
+      id, = data.fetch("worktrees", {}).find { |_key, record| record["path"] == old_path }
+      return worktree_activate(new_path) unless id
+
+      with_worktree_lock(id) do
+        record = state.fetch("worktrees").fetch(id)
+        record.fetch("environments").each_value do |entry|
+          next unless entry["status"] == "running"
+
+          abort "Could not stop environment during worktree move." unless worktree_manager(entry).stop(entry)
+        end
+        with_state_lock do |locked|
+          updated = locked.fetch("worktrees").fetch(id)
+          updated["path"] = new_path
+          updated.fetch("environments").each_value do |entry|
+            entry["snapshot"] = new_path
+            entry["status"] = "stopped"
+          end
+        end
+      end
+      worktree_activate(new_path, force: true)
+    end
+
+    def worktree_repair(path)
+      path = File.realpath(path)
+      record = state.fetch("worktrees", {})[worktree_identity(path)]
+      if record && record.fetch("path") != path
+        worktree_move(record.fetch("path"), path)
+      else
+        worktree_activate(path)
+      end
+    end
+
+    def worktree_paths
+      output, status = Open3.capture2("git", "worktree", "list", "--porcelain", "-z")
+      abort "Could not list Git worktrees." unless status.success?
+      output.split("\0").filter_map do |field|
+        canonical_worktree_path(field.delete_prefix("worktree ")) if field.start_with?("worktree ")
+      end
+    end
+
+    def worktree_cleanup
+      paths = worktree_paths
+      identities = paths.each_with_object({}) do |path, result|
+        result[worktree_identity(path)] = path if File.directory?(path)
+      end
+      data = state
+      data.fetch("worktrees", {}).each do |id, record|
+        path = record.fetch("path")
+        if identities[id] && identities[id] != path
+          worktree_move(path, identities[id])
+        elsif !paths.include?(path)
+          worktree_remove(path)
+        end
+      end
+    end
+
+    def worktree_status
+      data = state
+      record, current = current_worktree_entry(data)
+      return puts "No Brunch environment in this worktree." unless current
+
+      puts "#{current.fetch('ref')} (#{record.fetch('path')}): #{worktree_manager(current).status(current)}, http://127.0.0.1:#{record.fetch('port')}"
+    end
+
+    def worktree_ports
+      data = state
+      current_id = worktree_identity(repo_root)
+      data.fetch("worktrees", {}).sort_by { |_id, record| record.fetch("path") }.each do |id, record|
+        entry = record.fetch("environments", {})[record["current"]]
+        next unless entry
+
+        marker = id == current_id ? color("●", 32) : "○"
+        name = id == current_id ? color(entry.fetch("ref"), 32) : entry.fetch("ref")
+        puts "#{marker} #{name}  #{record.fetch('port')}  #{record.fetch('path')}"
+      end
+    end
+
+    def worktree_port
+      record, = current_worktree_entry(state)
+      raise CLI::OperationError, "No Brunch environment in this worktree." unless record
+
+      puts record.fetch("port")
+    end
+
+    def worktree_logs(arguments)
+      _record, entry = current_worktree_entry(state)
+      raise CLI::OperationError, "No Brunch environment in this worktree." unless entry
+
+      worktree_manager(entry).logs(entry, *arguments)
+    end
+
+    def worktree_run(command)
+      _record, entry = current_worktree_entry(state)
+      raise CLI::OperationError, "No Brunch environment in this worktree." unless entry
+
+      abort "Command failed: #{command.join(' ')}" unless system(worktree_manager(entry).environment(entry), *command,
+                                                                 chdir: entry.fetch("snapshot"))
+    end
+
+    def worktree_doctor
+      data = state
+      ports = data.fetch("worktrees", {}).values.map { |record| record["port"] }
+      paths = worktree_paths
+      hooks_dir = git_output("rev-parse", "--git-path", "hooks")
+      checks = {
+        "Git worktree" => !worktree_identity(repo_root).empty?,
+        "git-hooks-ext" => system("ghe", "--version", out: File::NULL, err: File::NULL),
+        "Brunch hooks" => Hooks::EVENTS.all? do |event|
+          path = File.join(hooks_dir, event)
+          File.file?(path) && File.read(path).include?("Brunch::Hooks.dispatch")
+        end,
+        "Configuration" => !configuration.nil?,
+        "Manager" => Managers.build(configuration).available?,
+        "Unique ports" => ports.uniq.size == ports.size,
+        "Port range" => ports.all? { |port| CLI::PORT_RANGE.cover?(port) },
+        "Git worktree paths" => data.fetch("worktrees", {}).values.all? do |record|
+          paths.include?(record.fetch("path"))
+        end
+      }
+      checks.each { |name, passed| puts "#{passed ? 'OK' : 'FAIL'} #{name}" }
+      abort "Brunch doctor found problems." unless checks.values.all?
+    end
+  end
+end

data/lib/brunch.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "brunch/version"
+require_relative "brunch/managers"
+require_relative "brunch/worktree_mode"
+require_relative "brunch/cli"
+require_relative "brunch/hooks"