Add brew bundle exec --services

Library/Homebrew/bundle/brew_installer.rb

@@ -113,12 +113,15 @@ def changed?
 
       def service_change_state!(verbose:)
         require "bundle/brew_services"
+
+        file = Bundle::BrewServices.versioned_service_file(@name)
+
         if restart_service_needed?
           puts "Restarting #{@name} service." if verbose
-          BrewServices.restart(@full_name, verbose:)
+          BrewServices.restart(@full_name, file:, verbose:)
         elsif start_service_needed?
           puts "Starting #{@name} service." if verbose
-          BrewServices.start(@full_name, verbose:)
+          BrewServices.start(@full_name, file:, verbose:)
         else
           true
         end

Library/Homebrew/bundle/brew_services.rb

@@ -1,43 +1,58 @@
 # typed: true # rubocop:todo Sorbet/StrictSigil
 # frozen_string_literal: true
 
+require "services/system"
+
 module Homebrew
   module Bundle
     module BrewServices
-      module_function
-
-      def reset!
+      def self.reset!
         @started_services = nil
       end
 
-      def stop(name, verbose: false)
+      def self.stop(name, keep: false, verbose: false)
         return true unless started?(name)
 
-        return unless Bundle.brew("services", "stop", name, verbose:)
+        args = ["services", "stop", name]
+        args << "--keep" if keep
+        return unless Bundle.brew(*args, verbose:)
 
         started_services.delete(name)
         true
       end
 
-      def start(name, verbose: false)
-        return unless Bundle.brew("services", "start", name, verbose:)
+      def self.start(name, file: nil, verbose: false)
+        args = ["services", "start", name]
+        args << "--file=#{file}" if file
+        return unless Bundle.brew(*args, verbose:)
+
+        started_services << name
+        true
+      end
+
+      def self.run(name, file: nil, verbose: false)
+        args = ["services", "run", name]
+        args << "--file=#{file}" if file
+        return unless Bundle.brew(*args, verbose:)
 
         started_services << name
         true
       end
 
-      def restart(name, verbose: false)
-        return unless Bundle.brew("services", "restart", name, verbose:)
+      def self.restart(name, file: nil, verbose: false)
+        args = ["services", "restart", name]
+        args << "--file=#{file}" if file
+        return unless Bundle.brew(*args, verbose:)
 
         started_services << name
         true
       end
 
-      def started?(name)
+      def self.started?(name)
         started_services.include? name
       end
 
-      def started_services
+      def self.started_services
         @started_services ||= begin
           states_to_skip = %w[stopped none]
           Utils.safe_popen_read(HOMEBREW_BREW_FILE, "services", "list").lines.filter_map do |line|
@@ -48,6 +63,23 @@ def started_services
           end
         end
       end
+
+      def self.versioned_service_file(name)
+        env_version = Bundle.formula_versions_from_env[name]
+        return if env_version.nil?
+
+        formula = Formula[name]
+        prefix = formula.rack/env_version
+        return unless prefix.directory?
+
+        service_file = if Homebrew::Services::System.launchctl?
+          prefix/"#{formula.plist_name}.plist"
+        else
+          prefix/"#{formula.service_name}.service"
+        end
+
+        service_file if service_file.file?
+      end
     end
   end
 end

Library/Homebrew/bundle/commands/exec.rb

@@ -47,7 +47,7 @@
 
         PATH_LIKE_ENV_REGEX = /.+#{File::PATH_SEPARATOR}/
 
-        def self.run(*args, global: false, file: nil, subcommand: "")
+        def self.run(*args, global: false, file: nil, subcommand: "", services: false)
           # Cleanup Homebrew's global environment
           HOMEBREW_ENV_CLEANUP.each { |key| ENV.delete(key) }
 
@@ -157,7 +157,135 @@
             return
           end
 
-          exec(*args)
+          if services
+            require "bundle/brew_services"
+
+            exit_code = 0
+            run_services(@dsl.entries) do
+              Kernel.system(*args)
+              exit_code = $CHILD_STATUS.exitstatus
+            end
+            exit!(exit_code)
+          else
+            exec(*args)
+          end
+        end
+
+        sig {
+          params(
+            entries: T::Array[Homebrew::Bundle::Dsl::Entry],
+            _block:  T.proc.params(
+              info:                 T::Hash[String, T.anything],
+              service_file:         Pathname,
+              conflicting_services: T::Array[T::Hash[String, T.anything]],
+            ).void,
+          ).void
+        }
+        private_class_method def self.map_service_info(entries, &_block)
+          entries_formulae = entries.filter_map do |entry|
+            next if entry.type != :brew
+
+            formula = Formula[entry.name]
+            next unless formula.any_version_installed?
+
+            [entry, formula]
+          end.to_h
+
+          # The formula + everything that could possible conflict with the service
+          names_to_query = entries_formulae.flat_map do |entry, formula|
+            [
+              formula.name,
+              *formula.versioned_formulae_names,
+              *formula.conflicts.map(&:name),
+              *entry.options[:conflicts_with],
+            ]
+          end
+
+          # We parse from a command invocation so that brew wrappers can invoke special actions
+          # for the elevated nature of `brew services`
+          services_info = JSON.parse(
+            Utils.safe_popen_read(HOMEBREW_BREW_FILE, "services", "info", "--json", *names_to_query),
+          )
+
+          entries_formulae.filter_map do |entry, formula|
+            service_file = Bundle::BrewServices.versioned_service_file(entry.name)
+
+            unless service_file&.file?
+              prefix = formula.any_installed_prefix
+              next if prefix.nil?
+
+              service_file = if Homebrew::Services::System.launchctl?
+                prefix/"#{formula.plist_name}.plist"
+              else
+                prefix/"#{formula.service_name}.service"
+              end
+            end
+
+            next unless service_file.file?
+
+            info = services_info.find { |candidate| candidate["name"] == formula.name }
+            conflicting_services = services_info.select do |candidate|
+              next unless candidate["running"]
+
+              formula.versioned_formulae_names.include?(candidate["name"])
+            end
+
+            raise "Failed to get service info for #{entry.name}" if info.nil?
+
+            yield info, service_file, conflicting_services
+          end
+        end
+
+        sig { params(entries: T::Array[Homebrew::Bundle::Dsl::Entry], _block: T.nilable(T.proc.void)).void }
+        private_class_method def self.run_services(entries, &_block)
+          services_to_restart = []
+
+          map_service_info(entries) do |info, service_file, conflicting_services|
+            if info["running"] && !Bundle::BrewServices.stop(info["name"], keep: true)
+              opoo "Failed to stop #{info["name"]} service"
+            end
+
+            conflicting_services.each do |conflict|
+              if Bundle::BrewServices.stop(conflict["name"], keep: true)
+                services_to_restart << conflict["name"] if conflict["registered"]
+              else
+                opoo "Failed to stop #{conflict["name"]} service"
+              end
+            end
+
+            unless Bundle::BrewServices.run(info["name"], file: service_file)
+              opoo "Failed to start #{info["name"]} service"
+            end
+          end
+
+          return unless block_given?
+
+          begin
+            yield
+          ensure
+            # Do a full re-evaluation of services instead state has changed
+            stop_services(entries)
+
+            services_to_restart.each do |service|
+              next if Bundle::BrewServices.run(service)
+
+              opoo "Failed to restart #{service} service"
+            end
+          end
+        end
+
+        sig { params(entries: T::Array[Homebrew::Bundle::Dsl::Entry]).void }
+        private_class_method def self.stop_services(entries)
+          map_service_info(entries) do |info, _, _|
+            next unless info["loaded"]
+
+            # Try avoid services not started by `brew bundle services`
+            next if Homebrew::Services::System.launchctl? && info["registered"]
+
+            if info["running"] && !Bundle::BrewServices.stop(info["name"], keep: true)
+              opoo "Failed to stop #{info["name"]} service"
+            end
+          end
         end
       end
     end

Library/Homebrew/cmd/bundle.rb

@@ -83,6 +83,8 @@
                             "even if `$HOMEBREW_BUNDLE_NO_UPGRADE` is set. "
         switch "--install",
                description: "Run `install` before continuing to other operations e.g. `exec`."
+        switch "--services",
+               description: "Temporarily start services while running the `exec` or `sh` command."
         switch "-f", "--force",
                description: "`install` runs with `--force`/`--overwrite`. " \
                             "`dump` overwrites an existing `Brewfile`. " \
@@ -133,7 +135,7 @@
         require "bundle"
 
         subcommand = args.named.first.presence
-        if ["exec", "add", "remove"].exclude?(subcommand) && args.named.size > 1
+        if %w[exec add remove].exclude?(subcommand) && args.named.size > 1
           raise UsageError, "This command does not take more than 1 subcommand argument."
         end
 
@@ -232,7 +234,7 @@
             ["env"]
           end
           require "bundle/commands/exec"
-          Homebrew::Bundle::Commands::Exec.run(*named_args, global:, file:, subcommand:)
+          Homebrew::Bundle::Commands::Exec.run(*named_args, global:, file:, subcommand:, services: args.services?)
         when "list"
           require "bundle/commands/list"
           Homebrew::Bundle::Commands::List.run(

Library/Homebrew/cmd/services.rb

@@ -38,13 +38,14 @@ class Services < AbstractCommand
           [`sudo`] `brew services start` (<formula>|`--all`|`--file=`):
           Start the service <formula> immediately and register it to launch at login (or boot).
 
-          [`sudo`] `brew services stop` (<formula>|`--all`):
-          Stop the service <formula> immediately and unregister it from launching at login (or boot).
+          [`sudo`] `brew services stop` (`--keep`) (`--no-wait`|`--max-wait=`) (<formula>|`--all`):
+          Stop the service <formula> immediately and unregister it from launching at login (or boot),
+          unless `--keep` is specified.
 
           [`sudo`] `brew services kill` (<formula>|`--all`):
           Stop the service <formula> immediately but keep it registered to launch at login (or boot).
 
-          [`sudo`] `brew services restart` (<formula>|`--all`):
+          [`sudo`] `brew services restart` (<formula>|`--all`|`--file=`):
           Stop (if necessary) and start the service <formula> immediately and register it to launch at login (or boot).
 
           [`sudo`] `brew services cleanup`:
@@ -57,6 +58,7 @@ class Services < AbstractCommand
         switch "--all", description: "Run <subcommand> on all services."
         switch "--json", description: "Output as JSON."
         switch "--no-wait", description: "Don't wait for `stop` to finish stopping the service."
+        switch "--keep", description: "When stopped, don't unregister the service from launching at login (or boot)."
         conflicts "--max-wait=", "--no-wait"
         named_args
       end
@@ -108,6 +110,7 @@ def run
           file_commands = [
             *Homebrew::Services::Commands::Start::TRIGGERS,
             *Homebrew::Services::Commands::Run::TRIGGERS,
+            *Homebrew::Services::Commands::Restart::TRIGGERS,
           ]
           if file_commands.exclude?(subcommand)
             raise UsageError, "The `#{subcommand}` subcommand does not accept the --file= argument!"
@@ -117,6 +120,14 @@ def run
           end
         end
 
+        unless Homebrew::Services::Commands::Stop::TRIGGERS.include?(subcommand)
+          raise UsageError, "The `#{subcommand}` subcommand does not accept the --keep argument!" if args.keep?
+          raise UsageError, "The `#{subcommand}` subcommand does not accept the --no-wait argument!" if args.no_wait?
+          if args.max_wait
+            raise UsageError, "The `#{subcommand}` subcommand does not accept the --max-wait= argument!"
+          end
+        end
+
         opoo "The --all argument overrides provided formula argument!" if formulae.present? && args.all?
 
         targets = if args.all?
@@ -156,14 +167,19 @@ def run
         when *Homebrew::Services::Commands::Info::TRIGGERS
           Homebrew::Services::Commands::Info.run(targets, verbose: args.verbose?, json: args.json?)
         when *Homebrew::Services::Commands::Restart::TRIGGERS
-          Homebrew::Services::Commands::Restart.run(targets, verbose: args.verbose?)
+          Homebrew::Services::Commands::Restart.run(targets, args.file, verbose: args.verbose?)
         when *Homebrew::Services::Commands::Run::TRIGGERS
           Homebrew::Services::Commands::Run.run(targets, args.file, verbose: args.verbose?)
         when *Homebrew::Services::Commands::Start::TRIGGERS
           Homebrew::Services::Commands::Start.run(targets, args.file, verbose: args.verbose?)
         when *Homebrew::Services::Commands::Stop::TRIGGERS
-          max_wait = args.max_wait.to_f
-          Homebrew::Services::Commands::Stop.run(targets, verbose: args.verbose?, no_wait: args.no_wait?, max_wait:)
+          Homebrew::Services::Commands::Stop.run(
+            targets,
+            verbose:  args.verbose?,
+            no_wait:  args.no_wait?,
+            max_wait: args.max_wait.to_f,
+            keep:     args.keep?,
+          )
         when *Homebrew::Services::Commands::Kill::TRIGGERS
           Homebrew::Services::Commands::Kill.run(targets, verbose: args.verbose?)
         else