confctl 2.2.2 → 3.0.0

data/lib/confctl/cli/cluster.rb

@@ -2,6 +2,7 @@ require_relative 'command'
 require_relative '../hook'
 require 'json'
 require 'rainbow'
+require 'shellwords'
 require 'tty-pager'
 require 'tty-progressbar'
 require 'tty-spinner'
@@ -61,7 +62,7 @@ module ConfCtl::Cli
         list_machines(machines)
         puts
         puts "Generation: #{opts[:generation] || 'new build'}"
-        puts "Target action: #{action}#{opts[:reboot] ? ' + reboot' : ''}"
+        puts "Target action: #{action}#{' + reboot' if opts[:reboot]}"
       end
 
       ConfCtl::Hook.call(:cluster_deploy, kwargs: {
@@ -79,6 +80,9 @@ module ConfCtl::Cli
         end
 
       nix = ConfCtl::Nix.new(show_trace: opts['show-trace'])
+      machines, host_generations = skip_current_deploy_targets(machines, host_generations, action)
+
+      return if host_generations.empty?
 
       if opts['one-by-one']
         deploy_one_by_one(machines, host_generations, nix, action)
@@ -88,10 +92,10 @@ module ConfCtl::Cli
     end
 
     def health_check
-      machines = select_machines(args[0]).managed.select do |_host, machine|
+      machines = select_machines(args[0]).managed.runnable.select do |_host, machine|
         machine.health_checks.any?
       end
-      raise 'No machines to check or no health checks configured' if machines.empty?
+      raise 'No runnable machines to check or no health checks configured' if machines.empty?
 
       run_checks = machines.health_checks
 
@@ -110,6 +114,8 @@ module ConfCtl::Cli
     end
 
     def status
+      return status_flake if flake_config?
+
       machines = select_machines(args[0]).managed.select do |_host, machine|
         machine.target_host || machine.carried?
       end
@@ -216,7 +222,100 @@ module ConfCtl::Cli
       OutputFormatter.print(rows, cols, layout: :columns, color: use_color?)
     end
 
+    def status_flake
+      machines = select_machines(args[0]).managed.select do |_host, machine|
+        machine.target_host || machine.carried?
+      end
+
+      raise 'No machines to check' if machines.empty?
+
+      ask_confirmation! do
+        if opts[:generation]
+          puts 'The following machines will be checked:'
+        else
+          puts 'The following machines will be built and then checked:'
+        end
+
+        list_machines(machines)
+        puts
+        puts "Generation: #{opts[:generation] || 'new build'}"
+      end
+
+      statuses = machines.transform_values do |machine|
+        ConfCtl::MachineStatus.new(machine)
+      end
+
+      if opts[:generation] == 'none'
+        host_generations = nil
+      elsif opts[:generation]
+        host_generations = find_generations(machines, opts[:generation])
+
+        # Ignore statuses when no generation was found
+        statuses.delete_if do |host, _st|
+          !host_generations.has_key?(host)
+        end
+      else
+        host_generations = do_build(machines)
+        puts
+      end
+
+      if host_generations
+        host_generations.each do |host, gen|
+          statuses[host].target_toplevel = gen.toplevel
+        end
+      end
+
+      assign_target_inputs_info(
+        statuses,
+        host_generations: opts[:generation] && opts[:generation] != 'none' ? host_generations : nil
+      )
+
+      tw = ConfCtl::ParallelExecutor.new(machines.length)
+
+      statuses.each_value do |st|
+        tw.add do
+          st.query(toplevel: opts[:generation] != 'none', swpins: false, inputs: true)
+        end
+      end
+
+      tw.run
+
+      roles = inputs_roles_for_status(statuses)
+      rows = []
+      cols = %w[host online uptime status generations] + roles
+
+      statuses.each do |host, st|
+        build_generations = ConfCtl::Generation::BuildList.new(host)
+        online = st.uptime ? true : false
+
+        inputs_ok = inputs_ok?(st)
+        status_ok = online && inputs_ok
+        status_ok &&= st.target_toplevel == st.current_toplevel if st.target_toplevel
+
+        row = {
+          'host' => host,
+          'online' => online && Rainbow('yes').green,
+          'uptime' => st.uptime && format_duration(st.uptime),
+          'status' => status_ok ? Rainbow('ok').green : Rainbow('outdated').red,
+          'generations' => "#{build_generations.count}:#{st.generations && st.generations.count}"
+        }
+
+        roles.each do |role|
+          t_info = st.target_inputs_info && st.target_inputs_info[role]
+          d_info = st.inputs_info && st.inputs_info[role]
+          state = inputs_info_state(t_info, d_info)
+          row[role] = format_inputs_state(state, d_info)
+        end
+
+        rows << row
+      end
+
+      OutputFormatter.print(rows, cols, layout: :columns, color: use_color?)
+    end
+
     def changelog
+      return changelog_flake if flake_config?
+
       compare_swpins do |io, _host, status, sw_name, spec|
         s = spec.string_changelog_info(
           opts[:downgrade] ? :downgrade : :upgrade,
@@ -233,6 +332,8 @@ module ConfCtl::Cli
     end
 
     def diff
+      return diff_flake if flake_config?
+
       compare_swpins do |io, _host, status, sw_name, spec|
         s = spec.string_diff_info(
           opts[:downgrade] ? :downgrade : :upgrade,
@@ -246,6 +347,96 @@ module ConfCtl::Cli
       end
     end
 
+    def changelog_flake
+      compare_inputs_info do |io, host, target_info, deployed_info|
+        roles = inputs_roles(target_info, deployed_info)
+        if roles.empty?
+          io.puts "#{host}: no inputs info"
+          io.puts ''
+          next
+        end
+
+        entries = inputs_info_entries(target_info, deployed_info, pattern: args[1])
+        next if entries.empty?
+
+        any_changed = false
+        any_unknown = false
+
+        entries.each do |entry|
+          role = entry[:role]
+          t_info = entry[:target]
+          d_info = entry[:deployed]
+
+          case entry[:status]
+          when :unknown
+            any_unknown = true
+            io.puts "#{host} @ #{role} in unknown state"
+          when :changed
+            any_changed = true
+            io.puts "#{host} @ #{role}:"
+
+            begin
+              log = inputs_git_log(t_info, d_info)
+              io.puts(log || '(changelog unavailable)')
+            rescue StandardError => e
+              io.puts e.message
+            end
+
+            io.puts ''
+          end
+        end
+
+        unless any_changed || any_unknown
+          io.puts "#{host}: no changes"
+          io.puts ''
+        end
+
+        io.puts '' if any_unknown && !any_changed
+      end
+    end
+
+    def diff_flake
+      compare_inputs_info do |io, host, target_info, deployed_info|
+        roles = inputs_roles(target_info, deployed_info)
+        if roles.empty?
+          io.puts "#{host}: no inputs info"
+          io.puts ''
+          next
+        end
+
+        entries = inputs_info_entries(target_info, deployed_info, pattern: args[1])
+        next if entries.empty?
+
+        any_output = false
+
+        entries.each do |entry|
+          role = entry[:role]
+          t_info = entry[:target]
+          d_info = entry[:deployed]
+
+          case entry[:status]
+          when :unknown
+            any_output = true
+            io.puts "#{host} @ #{role} in unknown state"
+          when :changed
+            any_output = true
+            from = inputs_short_rev(d_info) || 'unknown'
+            to = inputs_short_rev(t_info) || 'unknown'
+            from, to = to, from if opts[:downgrade]
+            url = inputs_url(t_info, d_info)
+            label = url ? "#{role} (#{url})" : role
+            io.puts "#{host} @ #{label}: #{from} -> #{to}"
+          end
+        end
+
+        unless any_output
+          io.puts "#{host}: no changes"
+        end
+
+        io.puts ''
+      end
+    end
+
     def test_connection
       machines = select_machines_with_managed(args[0]).runnable
       raise 'No machines to test' if machines.empty?
@@ -327,6 +518,64 @@ module ConfCtl::Cli
 
     attr_reader :wait_online
 
+    def skip_current_deploy_targets(machines, host_generations, action)
+      return [machines, host_generations] if opts['copy-only']
+
+      statuses = deploy_target_statuses(machines, host_generations)
+
+      filtered_generations = host_generations.reject do |host, generation|
+        machine = machines[host]
+        status = statuses[host]
+
+        if already_using_target_generation?(machine, status, generation, action)
+          puts Rainbow("Skipping #{host}: already using target generation #{generation.name}").yellow
+          true
+        else
+          false
+        end
+      end
+
+      filtered_machines = machines.select do |host, _machine|
+        filtered_generations.has_key?(host)
+      end
+
+      [filtered_machines, filtered_generations]
+    end
+
+    def deploy_target_statuses(machines, host_generations)
+      statuses = {}
+      executor = ConfCtl::ParallelExecutor.new([host_generations.length, 5].min)
+
+      host_generations.each_key do |host|
+        statuses[host] = ConfCtl::MachineStatus.new(machines[host])
+
+        executor.add do
+          statuses[host].query(toplevel: true, generations: true, swpins: false)
+        end
+      end
+
+      executor.run
+      statuses
+    end
+
+    def already_using_target_generation?(machine, status, generation, action)
+      return false if status.nil? || status.current_toplevel.nil?
+
+      target_current = status.current_toplevel == generation.toplevel
+
+      return target_current if machine.carried? || %w[test dry-activate].include?(action)
+      return target_current && current_profile_toplevel(status) == generation.toplevel if %w[boot switch].include?(action)
+
+      false
+    end
+
+    def current_profile_toplevel(status)
+      return if status.generations.nil?
+
+      current = status.generations.current
+      current && current.toplevel
+    end
+
     def deploy_in_bulk(machines, host_generations, nix, action)
       skipped_copy = []
       skipped_activation = []
@@ -426,6 +675,16 @@ module ConfCtl::Cli
 
       return :skip if opts[:interactive] && !ask_confirmation(always: true)
 
+      unless ui_enabled?
+        ret = nix_copy(nix, machine, build_generation) do |i, n, path|
+          puts "[#{host}] [#{i}/#{n}] #{path}"
+        end
+
+        raise "Error while copying system to #{host}" unless ret
+
+        return true
+      end
+
       LogView.open(
         header: "#{Rainbow('Copying to').bright} #{host}\n",
         title: Rainbow('Live view').bright
@@ -453,6 +712,26 @@ module ConfCtl::Cli
     def concurrent_copy(machines, host_generations, nix)
       sorted_generations = sort_generations_for_copy(machines, host_generations)
 
+      unless ui_enabled?
+        executor = ConfCtl::ParallelExecutor.new(opts['max-concurrent-copy'])
+
+        sorted_generations.each do |host, gen|
+          executor.add do
+            ret = nix_copy(nix, machines[host], gen) do |i, n, path|
+              puts "[#{host}] [#{i}/#{n}] #{path}"
+            end
+
+            puts("[#{host}] copy failed") unless ret
+            ret ? nil : host
+          end
+        end
+
+        failed = executor.run.compact
+        raise "Copy failed to: #{failed.join(', ')}" if failed.any?
+
+        return
+      end
+
       LogView.open(
         header: "#{Rainbow("Copying to #{sorted_generations.length} machines").bright}\n",
         title: Rainbow('Live view').bright
@@ -521,13 +800,13 @@ module ConfCtl::Cli
       end
 
       until carried_groups.empty?
-        carried_groups.delete_if do |_, machines|
-          m = machines.shift
+        carried_groups.delete_if do |_, group_machines|
+          m = group_machines.shift
           next(true) if m.nil?
 
           sorted_generations << [m.name, host_generations[m.name]]
 
-          machines.empty?
+          group_machines.empty?
         end
       end
 
@@ -655,26 +934,43 @@ module ConfCtl::Cli
         m.reboot
       else
         since = Time.now
-        spinner = nil
-
-        secs = m.reboot_and_wait(
-          timeout: wait_online == :wait ? nil : wait_online
-        ) do |state, timeleft|
-          if state == :reboot
-            spinner = TTY::Spinner.new(
-              ":spinner Waiting for #{host} (:seconds s)",
-              format: :classic
-            )
-            spinner.auto_spin
-          elsif state == :is_up
-            spinner.success('up')
-            next
+
+        if ui_enabled?
+          spinner = nil
+
+          secs = m.reboot_and_wait(
+            timeout: wait_online == :wait ? nil : wait_online
+          ) do |state, timeleft|
+            if state == :reboot
+              spinner = TTY::Spinner.new(
+                ":spinner Waiting for #{host} (:seconds s)",
+                format: :classic
+              )
+              spinner.auto_spin
+            elsif state == :is_up
+              spinner.success('up')
+              next
+            end
+
+            if wait_online == :wait
+              spinner.update(seconds: (Time.now - since).round)
+            else
+              spinner.update(seconds: timeleft.round)
+            end
           end
+        else
+          puts "Waiting for #{host} to reboot..."
 
-          if wait_online == :wait
-            spinner.update(seconds: (Time.now - since).round)
-          else
-            spinner.update(seconds: timeleft.round)
+          secs = m.reboot_and_wait(
+            timeout: wait_online == :wait ? nil : wait_online
+          ) do |state, timeleft|
+            next unless %i[went_down is_down].include?(state)
+
+            if wait_online == :wait
+              puts "  #{host}: waiting #{(Time.now - since).round}s"
+            else
+              puts "  #{host}: #{timeleft.round}s left"
+            end
           end
         end
 
@@ -753,42 +1049,68 @@ module ConfCtl::Cli
 
       header << "\n" << Rainbow('Full log: ').bright << ConfCtl::Logger.relative_path << "\n"
 
-      LogView.open(
-        header:,
-        title: Rainbow('Live view').bright,
-        size: :auto,
-        reserved_lines: 10
-      ) do |lw|
-        pb = TTY::ProgressBar.new(
-          'Checks [:bar] :current/:total (:percent)',
-          width: 80,
-          total: run_checks.length
-        )
+      if ui_enabled?
+        LogView.open(
+          header:,
+          title: Rainbow('Live view').bright,
+          size: :auto,
+          reserved_lines: 10
+        ) do |lw|
+          pb = TTY::ProgressBar.new(
+            'Checks [:bar] :current/:total (:percent)',
+            width: 80,
+            total: run_checks.length
+          )
+
+          run_checks.each_with_index do |check, i|
+            tw.add do
+              prefix = "[#{i + 1}/#{run_checks.length}] #{check.machine}> "
+              lw << "#{prefix}#{check.description}"
+
+              check.run do |attempt, _errors|
+                lw << "#{prefix}failed ##{attempt}: #{check.message}"
+                ConfCtl::Logger.keep
+              end
+
+              lw << if check.successful?
+                      "#{prefix}succeeded"
+                    else
+                      "#{prefix}error: #{check.message}"
+                    end
+
+              lw.sync_console do
+                pb.advance
+              end
+            end
+          end
+
+          tw.run
+          lw.flush
+        end
+      else
+        puts header
 
         run_checks.each_with_index do |check, i|
           tw.add do
             prefix = "[#{i + 1}/#{run_checks.length}] #{check.machine}> "
-            lw << "#{prefix}#{check.description}"
+            puts "#{prefix}#{check.description}"
 
             check.run do |attempt, _errors|
-              lw << "#{prefix}failed ##{attempt}: #{check.message}"
+              puts "#{prefix}failed ##{attempt}: #{check.message}"
               ConfCtl::Logger.keep
             end
 
-            lw << if check.successful?
-                    "#{prefix}succeeded"
-                  else
-                    "#{prefix}error: #{check.message}"
-                  end
-
-            lw.sync_console do
-              pb.advance
-            end
+            puts(
+              if check.successful?
+                "#{prefix}succeeded"
+              else
+                "#{prefix}error: #{check.message}"
+              end
+            )
           end
         end
 
         tw.run
-        lw.flush
       end
 
       successful = []
@@ -847,7 +1169,7 @@ module ConfCtl::Cli
         puts 'Run command over SSH on the following machines:'
         list_machines(machines)
         puts
-        puts "Command: #{cmd.map(&:inspect).join(' ')}"
+        puts "Command: #{Shellwords.join(cmd)}"
       end
 
       if opts[:parallel]
@@ -889,31 +1211,44 @@ module ConfCtl::Cli
       results = {}
       tw = ConfCtl::ParallelExecutor.new(machines.length)
 
-      LogView.open_with_logger(
-        header: Rainbow('Executing').bright + " #{cmd.join(' ')}\n",
-        title: Rainbow('Live view').bright,
-        size: :auto,
-        reserved_lines: 10
-      ) do |lw|
-        pb = TTY::ProgressBar.new(
-          'Command [:bar] :current/:total (:percent)',
-          width: 80,
-          total: machines.length
-        )
+      if ui_enabled?
+        LogView.open_with_logger(
+          header: Rainbow('Executing').bright + " #{Shellwords.join(cmd)}\n",
+          title: Rainbow('Live view').bright,
+          size: :auto,
+          reserved_lines: 10
+        ) do |lw|
+          pb = TTY::ProgressBar.new(
+            'Command [:bar] :current/:total (:percent)',
+            width: 80,
+            total: machines.length
+          )
+
+          machines.each do |host, machine|
+            tw.add do
+              mc = ConfCtl::MachineControl.new(machine)
+
+              result = run_ssh_command_on_machine(mc, cmd)
+              results[host] = result
+
+              lw.sync_console { pb.advance }
+            end
+          end
+
+          tw.run
+          lw.flush
+        end
+      else
+        puts "Executing #{Shellwords.join(cmd)} on #{machines.length} machines"
 
         machines.each do |host, machine|
           tw.add do
             mc = ConfCtl::MachineControl.new(machine)
-
-            result = run_ssh_command_on_machine(mc, cmd)
-            results[host] = result
-
-            lw.sync_console { pb.advance }
+            results[host] = run_ssh_command_on_machine(mc, cmd)
           end
         end
 
         tw.run
-        lw.flush
       end
 
       if aggregate
@@ -1013,11 +1348,28 @@ module ConfCtl::Cli
 
     def list_generations(host_generations, missing_hosts:)
       swpin_names = []
+      input_roles = []
 
       host_generations.each_value do |gen|
         gen.swpin_names.each do |name|
           swpin_names << name unless swpin_names.include?(name)
         end
+
+        next unless flake_generation?(gen)
+
+        inputs_info = normalized_inputs_info(gen)
+        next if inputs_info.nil? || inputs_info.empty?
+
+        inputs_info.each_key do |role|
+          input_roles << role unless input_roles.include?(role)
+        end
+      end
+
+      input_column_names = {}
+      input_columns = input_roles.map do |role|
+        name = swpin_names.include?(role) ? "input:#{role}" : role
+        input_column_names[role] = name
+        { name: name, label: role.to_s.upcase }
       end
 
       rows = host_generations.map do |host, gen|
@@ -1031,6 +1383,13 @@ module ConfCtl::Cli
           row[name] = spec.version
         end
 
+        if flake_generation?(gen)
+          inputs_info = normalized_inputs_info(gen) || {}
+          input_roles.each do |role|
+            row[input_column_names[role]] = inputs_short_rev(inputs_info[role])
+          end
+        end
+
         row
       end
 
@@ -1040,7 +1399,7 @@ module ConfCtl::Cli
 
       OutputFormatter.print(
         rows,
-        %w[name generation kernel] + swpin_names,
+        %w[name generation kernel] + swpin_names + input_columns,
         layout: :columns,
         sort: %w[name generation]
       )
@@ -1058,7 +1417,11 @@ module ConfCtl::Cli
 
       raise 'one or more swpins need to be updated' unless host_swpin_specs
 
-      puts Rainbow("Evaluating swpins for #{machines.length} machines...").bright
+      if ConfCtl::ConfigType.flake?(ConfCtl::ConfDir.path)
+        puts Rainbow("Evaluating inputs for #{machines.length} machines...").bright
+      else
+        puts Rainbow("Evaluating swpins for #{machines.length} machines...").bright
+      end
 
       hosts_swpin_paths = nix.eval_host_swpins(machines.map { |host, _| host })
 
@@ -1066,7 +1429,7 @@ module ConfCtl::Cli
         hosts_swpin_paths[host].update(m.nix_paths)
       end
 
-      grps = swpin_build_groups(hosts_swpin_paths)
+      grps = swpin_build_groups(hosts_swpin_paths, nix)
       puts
       puts "Machines will be built in #{grps.length} groups"
       puts
@@ -1112,7 +1475,7 @@ module ConfCtl::Cli
     def do_build_group(group_index, group_count, hosts, swpin_paths, host_swpin_specs, nix, time)
       puts Rainbow('Building machines').bright
       hosts.each { |h| puts "  #{h}" }
-      puts 'with swpins'
+      puts ConfCtl::ConfigType.flake?(ConfCtl::ConfDir.path) ? 'with inputs' : 'with swpins'
       swpin_paths.each { |k, v| puts "  #{k}=#{v}" }
 
       header = '' \
@@ -1126,55 +1489,72 @@ module ConfCtl::Cli
         << " #{ConfCtl::Logger.relative_path}" \
         << "\n\n"
 
-      LogView.open_with_logger(
-        header:,
-        title: Rainbow('Live view').bright,
-        size: :auto,
-        reserved_lines: 10
-      ) do |lw|
-        multibar = TTY::ProgressBar::Multi.new(
-          'nix-build [:bar] :current/:total (:percent)',
-          width: 80
-        )
+      if ui_enabled?
+        LogView.open_with_logger(
+          header:,
+          title: Rainbow('Live view').bright,
+          size: :auto,
+          reserved_lines: 10
+        ) do |lw|
+          multibar = TTY::ProgressBar::Multi.new(
+            'nix-build [:bar] :current/:total (:percent)',
+            width: 80
+          )
 
-        build_pb = multibar.register(
-          'Building [:bar] :current/:total (:percent)'
-        )
+          build_pb = multibar.register(
+            'Building [:bar] :current/:total (:percent)'
+          )
 
-        fetch_pb = multibar.register(
-          'Fetching [:bar] :current/:total (:percent)'
-        )
+          fetch_pb = multibar.register(
+            'Fetching [:bar] :current/:total (:percent)'
+          )
 
-        built_generations = nix.build_attributes(
-          hosts:,
-          swpin_paths:,
-          time:,
-          host_swpin_specs:
-        ) do |type, _progress, total, _path|
-          if type == :build
-            lw.sync_console do
-              build_pb.update(total:) if total > 0 && build_pb.total.nil?
-              build_pb.advance
-            end
-          elsif type == :fetch
-            lw.sync_console do
-              fetch_pb.update(total:) if total > 0 && fetch_pb.total.nil?
-              fetch_pb.advance
+          built_generations = nix.build_attributes(
+            hosts:,
+            swpin_paths:,
+            time:,
+            host_swpin_specs:
+          ) do |type, _progress, total, _path|
+            if type == :build
+              lw.sync_console do
+                build_pb.update(total:) if total > 0 && build_pb.total.nil?
+                build_pb.advance
+              end
+            elsif type == :fetch
+              lw.sync_console do
+                fetch_pb.update(total:) if total > 0 && fetch_pb.total.nil?
+                fetch_pb.advance
+              end
             end
-          end
 
-          if build_pb.total && fetch_pb.total && multibar.top_bar.total.nil?
-            lw.sync_console do
-              multibar.top_bar.update(total: multibar.total)
+            if build_pb.total && fetch_pb.total && multibar.top_bar.total.nil?
+              lw.sync_console do
+                multibar.top_bar.update(total: multibar.total)
+              end
             end
           end
-        end
 
-        built_generations
+          built_generations
+        end
+      else
+        puts header
+        nix.build_attributes(
+          hosts:,
+          swpin_paths:,
+          time:,
+          host_swpin_specs:
+        ) do |type, progress, total, path|
+          puts "[#{type}] #{progress}/#{total} #{path}"
+        end
       end
     end
 
     def autoupdate_swpins(machines)
+      if ConfCtl::ConfigType.flake?(ConfCtl::ConfDir.path)
+        puts Rainbow('Skipping swpins auto updates for flake config').bright
+        return
+      end
+
       puts Rainbow('Running swpins auto updates...').bright
       channels_update = []
       any_updated = false
@@ -1250,6 +1630,13 @@ module ConfCtl::Cli
     end
 
     def check_swpins(machines)
+      if ConfCtl::ConfigType.flake?(ConfCtl::ConfDir.path)
+        puts Rainbow('Skipping swpins checks for flake config').bright
+        ret = {}
+        machines.each_key { |host| ret[host] = {} }
+        return ret
+      end
+
       ret = {}
       valid = true
 
@@ -1278,7 +1665,15 @@ module ConfCtl::Cli
       valid ? ret : false
     end
 
-    def swpin_build_groups(hosts_swpins)
+    def swpin_build_groups(hosts_swpins, nix = nil)
+      if ConfCtl::ConfigType.flake?(ConfCtl::ConfDir.path)
+        legacy_nix_path = false
+        if nix
+          legacy_nix_path = nix.confctl_settings.dig('nix', 'legacyNixPath') == true
+        end
+        return [[hosts_swpins.keys, {}]] unless legacy_nix_path
+      end
+
       ret = []
       all_swpins = hosts_swpins.values.uniq
 
@@ -1295,6 +1690,50 @@ module ConfCtl::Cli
       ret
     end
 
+    def compare_inputs_info
+      machines = select_machines(args[0]).managed
+
+      ask_confirmation! do
+        puts 'Compare inputs on the following machines:'
+        list_machines(machines)
+        puts
+        puts "Generation: #{opts[:generation] || 'current configuration'}"
+      end
+
+      statuses = machines.transform_values do |machine|
+        ConfCtl::MachineStatus.new(machine)
+      end
+
+      if opts[:generation]
+        host_generations = find_generations(machines, opts[:generation])
+
+        # Ignore statuses when no generation was found
+        statuses.delete_if do |host, _st|
+          !host_generations.has_key?(host)
+        end
+
+        assign_target_inputs_info(statuses, host_generations:)
+      else
+        assign_target_inputs_info(statuses)
+      end
+
+      TTY::Pager.page(enabled: use_pager?) do |io|
+        statuses.each do |host, st|
+          st.query(toplevel: false, generations: false, swpins: false, inputs: true)
+
+          if st.uptime.nil?
+            io.puts "#{host} is offline"
+            next
+          end
+
+          target_info = st.target_inputs_info || {}
+          deployed_info = st.inputs_info || {}
+
+          yield(io, host, target_info, deployed_info)
+        end
+      end
+    end
+
     def compare_swpins
       machines = select_machines(args[0]).managed
 
@@ -1355,6 +1794,132 @@ module ConfCtl::Cli
       end
     end
 
+    def assign_target_inputs_info(statuses, host_generations: nil)
+      if host_generations
+        host_generations.each do |host, gen|
+          next unless statuses[host]
+
+          statuses[host].target_inputs_info = ConfCtl::InputsInfo.normalize(gen.inputs_info)
+        end
+      else
+        nix = ConfCtl::Nix.new(show_trace: opts['show-trace'])
+
+        statuses.each do |host, st|
+          st.target_inputs_info = ConfCtl::InputsInfo.normalize(nix.eval_inputs_info(host))
+        rescue StandardError
+          st.target_inputs_info = nil
+        end
+      end
+    end
+
+    def inputs_roles_for_status(statuses)
+      roles = []
+
+      statuses.each_value do |st|
+        roles.concat((st.target_inputs_info || {}).keys)
+        roles.concat((st.inputs_info || {}).keys)
+      end
+
+      roles.uniq.sort
+    end
+
+    def inputs_ok?(status)
+      target_info = status.target_inputs_info
+      return false if target_info.nil? || target_info.empty?
+
+      target_info.all? do |role, info|
+        inputs_info_state(info, status.inputs_info && status.inputs_info[role]) == :same
+      end
+    end
+
+    def inputs_info_entries(target_info, deployed_info, pattern: nil)
+      inputs_roles(target_info, deployed_info).filter_map do |role|
+        next if pattern && !ConfCtl::Pattern.match?(pattern, role)
+
+        t_info = target_info[role]
+        d_info = deployed_info[role]
+        { role:, target: t_info, deployed: d_info, status: inputs_info_state(t_info, d_info) }
+      end
+    end
+
+    def inputs_roles(target_info, deployed_info)
+      roles = []
+      roles.concat(target_info.keys) if target_info
+      roles.concat(deployed_info.keys) if deployed_info
+      roles.uniq.sort
+    end
+
+    def inputs_info_state(target_info, deployed_info)
+      return :unknown if target_info.nil? || deployed_info.nil?
+
+      target_rev = inputs_rev(target_info)
+      deployed_rev = inputs_rev(deployed_info)
+      return :unknown if target_rev.nil? || deployed_rev.nil?
+
+      target_rev == deployed_rev ? :same : :changed
+    end
+
+    def inputs_rev(info)
+      return nil unless info.is_a?(Hash)
+
+      info['rev']
+    end
+
+    def inputs_short_rev(info)
+      return nil unless info.is_a?(Hash)
+
+      info['shortRev'] || (info['rev'] && info['rev'][0, 8])
+    end
+
+    def normalized_inputs_info(gen)
+      return nil unless gen.respond_to?(:inputs_info)
+
+      ConfCtl::InputsInfo.normalize(gen.inputs_info)
+    end
+
+    def flake_generation?(gen)
+      gen.respond_to?(:flakes_mode?) && gen.flakes_mode?
+    end
+
+    def inputs_url(target_info, deployed_info)
+      (target_info && target_info['url']) || (deployed_info && deployed_info['url'])
+    end
+
+    def inputs_git_log(target_info, deployed_info)
+      url = inputs_url(target_info, deployed_info)
+      old_rev = inputs_rev(deployed_info)
+      new_rev = inputs_rev(target_info)
+      return nil if url.nil? || old_rev.nil? || new_rev.nil?
+
+      old_rev, new_rev = new_rev, old_rev if opts[:downgrade]
+
+      log_opts = []
+      log_opts << '--oneline' unless opts[:verbose]
+      log_opts << '-p' if opts[:patch]
+      log_opts << '--max-count=50' unless opts[:verbose] || opts[:patch]
+
+      mirror = ConfCtl::GitRepoMirror.new(url, quiet: true)
+      mirror.setup
+      mirror.log(old_rev, new_rev, opts: log_opts)
+    end
+
+    def format_inputs_state(state, deployed_info)
+      rev = inputs_short_rev(deployed_info) || 'unknown'
+
+      case state
+      when :same
+        Rainbow(rev).green
+      when :changed
+        Rainbow(rev).red
+      else
+        Rainbow(rev).yellow
+      end
+    end
+
+    def flake_config?
+      ConfCtl::ConfigType.flake?(ConfCtl::ConfDir.path)
+    end
+
     def parse_wait_online
       @wait_online =
         case opts['wait-online']
@@ -1371,9 +1936,13 @@ module ConfCtl::Cli
 
     def format_command(reserved_cols = 0)
       cmd = "#{$0.split('/').last} #{ARGV.join(' ')}"
-      _, cols = IO.console.winsize
+      cols = IO.console&.winsize&.last
+      cols = cols.to_i
+      cols = 80 if cols <= 0
       max_length = cols - reserved_cols
 
+      return cmd if max_length <= 4
+
       if cmd.length > max_length
         "#{cmd[0..(max_length - 4)]}..."
       else
@@ -1404,6 +1973,10 @@ module ConfCtl::Cli
       nix.copy(machine, paths, &)
     end
 
+    def ui_enabled?
+      ConfCtl::Ui.tty?
+    end
+
     def enable_auto_rollback?(machine, generation)
       !opts['disable-auto-rollback'] \
         && (opts['enable-auto-rollback'] || machine.auto_rollback?) \