kdeploy 1.2.12 → 1.2.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7619f068ed4e5681529a7f1a06574d116e7e1552f0f36742f44e4994610bde51
-  data.tar.gz: c388f8b7cd2e3833757f440ff535ec40d9baa7c5c3037bda7e2c418f288d0528
+  metadata.gz: 72ea750e6176a809ebf7e45a9b4568477bad90a81682ef49491f976f0484cad2
+  data.tar.gz: 54d0f9bca80bb59b6598152d84cbafb9c7b3f7aab21de1090e9de75bf1dce081
 SHA512:
-  metadata.gz: b8dc29c50ce326bfd7fb2e41e983432a8219140e23256f2521ce29d20f8ae28681193dc31ce2f04ddb3c93881434a9c43ff0f20439dae200800989527a26cbcb
-  data.tar.gz: 9d442d78aeacaa8c3577a98b66dd493790abbe88c6ca400b637ff3a938f25fdc47b50c736296d3d82026ac76045602ad76d70a8804d7d051d369f2703e6a8b01
+  metadata.gz: 150d44235775b15b9d23458a162c4f0f60668f07c6a6bdc4a40a64f973e5bfb5ceee0ce31045db6b6d3d1803540d3df5928792eade256f765aec8d7c38739bfb
+  data.tar.gz: 1f31cf01e39d1b43d7fbf0df12f764c870850be60b1da21642f7afba6eb1553f7fe911431485eb0ecf002d3b725725a125d8227a96739cd6dbb73cbdaa0941b4

data/lib/kdeploy/banner.rb

@@ -28,22 +28,38 @@ module Kdeploy
         VERSION
       end
 
-      def show_error(message)
+      def show_error(message, include_banner: false)
         pastel = Pastel.new
-        <<~ERROR
-          #{show}
-          #{pastel.red("Error: #{message}")}
+        error_msg = pastel.red("Error: #{message}")
+        if include_banner
+          <<~ERROR
+            #{show}
+            #{error_msg}
+
+          ERROR
+        else
+          <<~ERROR
+            #{error_msg}
 
-        ERROR
+          ERROR
+        end
       end
 
-      def show_success(message)
+      def show_success(message, include_banner: false)
         pastel = Pastel.new
-        <<~SUCCESS
-          #{show}
-          #{pastel.green("Success: #{message}")}
+        success_msg = pastel.green("Success: #{message}")
+        if include_banner
+          <<~SUCCESS
+            #{show}
+            #{success_msg}
+
+          SUCCESS
+        else
+          <<~SUCCESS
+            #{success_msg}
 
-        SUCCESS
+          SUCCESS
+        end
       end
 
       ASCII_LOGO = <<~'LOGO'

data/lib/kdeploy/cli.rb

@@ -45,9 +45,11 @@ module Kdeploy
     method_option :limit, type: :string, desc: 'Limit to specific hosts (comma-separated)'
     method_option :parallel, type: :numeric, default: 10, desc: 'Number of parallel executions'
     method_option :dry_run, type: :boolean, desc: 'Show what would be done'
+    method_option :debug, type: :boolean, desc: 'Show detailed command output (stdout/stderr)'
     def execute(task_file, task_name = nil)
       load_config_file
       show_banner_once
+      @task_file_dir = File.dirname(File.expand_path(task_file))
       load_task_file(task_file)
 
       tasks_to_run = determine_tasks(task_name)
@@ -96,7 +98,7 @@ module Kdeploy
 
     def print_dry_run(hosts, task_name)
       formatter = OutputFormatter.new
-      puts Kdeploy::Banner.show
+      # Banner already shown by show_banner_once, don't show again
       puts formatter.format_dry_run_header
       puts
 
@@ -113,8 +115,8 @@ module Kdeploy
       puts
     end
 
-    def print_results(results, task_name)
-      formatter = OutputFormatter.new
+    def print_results(results, task_name, show_summary: false, debug: false)
+      formatter = OutputFormatter.new(debug: debug)
       puts formatter.format_task_header(task_name)
 
       if results.empty?
@@ -128,7 +130,8 @@ module Kdeploy
         print_host_result(host, result, formatter)
       end
 
-      print_summary(results, formatter)
+      # Only show summary if explicitly requested (for single task execution)
+      print_summary(results, formatter) if show_summary
     end
 
     def print_host_result(_host, result, formatter)
@@ -194,9 +197,16 @@ module Kdeploy
     end
 
     def execute_tasks(tasks_to_run)
+      all_results = {}
+
       tasks_to_run.each do |task|
-        execute_single_task(task)
+        task_results = execute_single_task(task)
+        # Collect results for final summary
+        all_results[task] = task_results if task_results
       end
+
+      # Show combined summary at the end for all tasks
+      print_all_tasks_summary(all_results) unless all_results.empty?
     end
 
     def execute_single_task(task)
@@ -205,12 +215,12 @@ module Kdeploy
 
       if hosts.empty?
         puts Kdeploy::Banner.show_error("No hosts found for task: #{task}")
-        return
+        return nil
       end
 
       if options[:dry_run]
         print_dry_run(hosts, task)
-        return
+        return nil
       end
 
       run_task(hosts, task)
@@ -219,9 +229,40 @@ module Kdeploy
     def run_task(hosts, task)
       output = ConsoleOutput.new
       parallel_count = options[:parallel] || Configuration.default_parallel
-      runner = Runner.new(hosts, self.class.kdeploy_tasks, parallel: parallel_count, output: output)
+      debug_mode = options[:debug] || false
+      base_dir = @task_file_dir
+      runner = Runner.new(hosts, self.class.kdeploy_tasks, parallel: parallel_count, output: output, debug: debug_mode,
+                                                           base_dir: base_dir)
       results = runner.run(task)
-      print_results(results, task)
+      # Don't show summary here - it will be shown at the end for all tasks
+      print_results(results, task, show_summary: false, debug: debug_mode)
+      results
+    end
+
+    def print_all_tasks_summary(all_results)
+      debug_mode = options[:debug] || false
+      formatter = OutputFormatter.new(debug: debug_mode)
+      puts formatter.format_summary_header
+
+      # Collect all hosts from all tasks
+      all_hosts = {}
+      all_results.each do |task_name, task_results|
+        task_results.each do |host, result|
+          all_hosts[host] ||= { ok: 0, changed: 0, failed: 0, tasks: [] }
+          counts = formatter.calculate_summary_counts(result)
+          all_hosts[host][:ok] += counts[:ok]
+          all_hosts[host][:changed] += counts[:changed]
+          all_hosts[host][:failed] += counts[:failed]
+          all_hosts[host][:tasks] << task_name
+        end
+      end
+
+      max_host_len = all_hosts.keys.map(&:length).max || 16
+      all_hosts.keys.sort.each do |host|
+        counts = all_hosts[host]
+        line = formatter.build_summary_line(host, counts, max_host_len)
+        puts formatter.colorize_summary_line(line, counts)
+      end
     end
 
     def extract_error_message(result)

data/lib/kdeploy/command_executor.rb

@@ -3,9 +3,10 @@
 module Kdeploy
   # Executes a single command and records execution time
   class CommandExecutor
-    def initialize(executor, output)
+    def initialize(executor, output, debug: false)
       @executor = executor
       @output = output
+      @debug = debug
     end
 
     def execute_run(command, host_name)
@@ -15,7 +16,6 @@ module Kdeploy
 
       # Show progress indicator for long-running commands
       pastel = @output.respond_to?(:pastel) ? @output.pastel : Pastel.new
-      Time.now
 
       result, duration = measure_time do
         @executor.execute(cmd, use_sudo: use_sudo)
@@ -24,8 +24,8 @@ module Kdeploy
       # Show execution time if command took more than 1 second
       @output.write_line(pastel.dim("    [completed in #{format('%.2f', duration)}s]")) if duration > 1.0
 
-      # Show command output
-      show_command_output(result)
+      # Show command output only in debug mode
+      show_command_output(result) if @debug
       { command: cmd, output: result, duration: duration, type: :run }
     end
 
@@ -87,9 +87,8 @@ module Kdeploy
     end
 
     def show_command_header(host_name, type, description)
-      pastel = pastel_instance
-      @output.write_line(pastel.bright_white("\n#{host_name.ljust(24)} : "))
-      format_command_by_type(type, description, pastel)
+      # Don't show command header during execution - it will be shown in results
+      # This reduces noise during execution
     end
 
     def pastel_instance

data/lib/kdeploy/executor.rb

@@ -2,6 +2,7 @@
 
 require 'net/ssh'
 require 'net/scp'
+require 'pathname'
 
 module Kdeploy
   # SSH/SCP executor for remote command execution and file operations
@@ -15,6 +16,7 @@ module Kdeploy
       @port = host_config[:port] # 新增端口支持
       @use_sudo = host_config[:use_sudo] || false
       @sudo_password = host_config[:sudo_password]
+      @base_dir = host_config[:base_dir] # Base directory for resolving relative paths
     end
 
     def execute(command, use_sudo: nil)
@@ -63,22 +65,75 @@ module Kdeploy
       }
     end
 
-    def upload(source, destination)
-      Net::SCP.start(@ip, @user, ssh_options) do |scp|
-        scp.upload!(source, destination)
+    def upload(source, destination, use_sudo: nil)
+      use_sudo = @use_sudo if use_sudo.nil?
+
+      # Resolve relative paths relative to base_dir
+      resolved_source = resolve_path(source)
+
+      # If destination requires sudo, upload to temp location first, then move with sudo
+      if use_sudo || requires_sudo?(destination)
+        upload_with_sudo(resolved_source, destination)
+      else
+        Net::SCP.start(@ip, @user, ssh_options) do |scp|
+          scp.upload!(resolved_source, destination)
+        end
       end
     rescue StandardError => e
       raise SCPError.new("SCP upload failed: #{e.message}", e)
     end
 
     def upload_template(source, destination, variables = {})
-      Template.render_and_upload(self, source, destination, variables)
+      # Resolve relative paths relative to base_dir
+      resolved_source = resolve_path(source)
+      Template.render_and_upload(self, resolved_source, destination, variables)
     rescue StandardError => e
       raise TemplateError.new("Template upload failed: #{e.message}", e)
     end
 
     private
 
+    def upload_with_sudo(source, destination)
+      # Generate a unique temp file name
+      temp_dest = "/tmp/kdeploy_#{File.basename(destination)}_#{Time.now.to_i}_#{rand(10_000)}"
+
+      # Upload to temp location first
+      Net::SCP.start(@ip, @user, ssh_options) do |scp|
+        scp.upload!(source, temp_dest)
+      end
+
+      # Move to final destination with sudo
+      move_command = "mv #{temp_dest} #{destination}"
+      execute(move_command, use_sudo: true)
+    rescue StandardError => e
+      # Try to clean up temp file if it exists
+      begin
+        execute("rm -f #{temp_dest}", use_sudo: false) if defined?(temp_dest)
+      rescue StandardError
+        # Ignore cleanup errors
+      end
+      raise SCPError.new("SCP upload failed: #{e.message}", e)
+    end
+
+    def resolve_path(path)
+      # If path is absolute, return as is
+      return path if Pathname.new(path).absolute?
+
+      # If base_dir is set, resolve relative to base_dir
+      if @base_dir
+        File.expand_path(path, @base_dir)
+      else
+        # Otherwise, resolve relative to current working directory
+        File.expand_path(path)
+      end
+    end
+
+    def requires_sudo?(path)
+      # Check if path is in system directories that typically require sudo
+      system_dirs = %w[/etc /usr /var /opt /sbin /bin /lib /lib64 /root]
+      system_dirs.any? { |dir| path.start_with?(dir) }
+    end
+
     def ssh_options
       options = base_ssh_options
       add_authentication(options)
@@ -109,9 +164,20 @@ module Kdeploy
       # 如果命令已经以 sudo 开头，不重复添加
       return command if command.strip.start_with?('sudo')
 
-      if @sudo_password
-        # 使用 echo 和管道传递密码给 sudo -S
-        # 注意：密码会出现在进程列表中，建议使用 NOPASSWD 配置
+      # 对于多行命令或包含 shell 控制结构的命令，使用 bash -c 包装
+      is_multiline = command.include?("\n") || command.match?(/\b(if|for|while|case|function)\b/)
+
+      if is_multiline
+        # 转义命令中的单引号，然后用 bash -c 执行
+        escaped_command = command.gsub("'", "'\"'\"'")
+        if @sudo_password
+          escaped_password = @sudo_password.gsub('\'', "'\"'\"'").gsub('$', '\\$').gsub('`', '\\`')
+          "echo '#{escaped_password}' | sudo -S bash -c '#{escaped_command}'"
+        else
+          "sudo bash -c '#{escaped_command}'"
+        end
+      elsif @sudo_password
+        # 单行命令直接包装
         escaped_password = @sudo_password.gsub('\'', "'\"'\"'").gsub('$', '\\$').gsub('`', '\\`')
         "echo '#{escaped_password}' | sudo -S #{command}"
       else

data/lib/kdeploy/output_formatter.rb

@@ -6,21 +6,22 @@ require 'tty-box'
 module Kdeploy
   # Formats and displays execution results
   class OutputFormatter
-    def initialize
+    def initialize(debug: false)
       @pastel = Pastel.new
+      @debug = debug
     end
 
     def format_task_header(task_name)
-      @pastel.cyan("\nPLAY [#{task_name}] " + ('*' * 64))
+      "#{@pastel.bright_cyan("\n🚀 Task: #{task_name}")}\n#{@pastel.dim('─' * 60)}"
     end
 
     def format_host_status(host, status)
       status_str = case status
-                   when :success then @pastel.green('ok')
-                   when :changed then @pastel.yellow('changed')
-                   else @pastel.red('failed')
+                   when :success then @pastel.green('✓ ok')
+                   when :changed then @pastel.yellow('~ changed')
+                   else @pastel.red('✗ failed')
                    end
-      @pastel.bright_white("\n#{host.ljust(24)} : #{status_str}")
+      @pastel.bright_white("  #{host.ljust(20)} #{status_str}")
     end
 
     def format_upload_steps(steps, shown)
@@ -31,8 +32,8 @@ module Kdeploy
       format_file_steps(steps, shown, :upload_template, @pastel.yellow('  === Template ==='), 'upload_template: ')
     end
 
-    def format_file_steps(steps, shown, type, header, prefix)
-      output = [header]
+    def format_file_steps(steps, shown, type, _header, prefix)
+      output = []
       steps.each do |step|
         next if step_already_shown?(step, type, shown)
 
@@ -44,13 +45,16 @@ module Kdeploy
 
     def format_file_step(step, type, prefix)
       duration_str = format_duration(step[:duration])
-      label = type == :upload ? '[upload]' : '[template]'
-      color("    #{label} #{step[:command].sub(prefix, '')}#{duration_str}")
+      icon = type == :upload ? '📤' : '📝'
+      file_path = step[:command].sub(prefix, '')
+      # Truncate long paths for cleaner output
+      display_path = file_path.length > 50 ? "...#{file_path[-47..]}" : file_path
+      color_method = type == :upload ? :green : :yellow
+      @pastel.dim("    #{icon} ") + @pastel.send(color_method, display_path) + duration_str
     end
 
     def format_run_steps(steps, shown)
       output = []
-      output << @pastel.cyan('  === Run ===')
       steps.each do |step|
         next if step_already_shown?(step, :run, shown)
 
@@ -64,20 +68,24 @@ module Kdeploy
       output = []
       duration_str = format_duration(step[:duration])
       command_line = step[:command].to_s.lines.first.strip
-      output << @pastel.cyan("    [run]    #{command_line}#{duration_str}")
-      output.concat(format_multiline_command(step[:command]))
-      # Format and add command output (stdout/stderr)
-      cmd_output = format_command_output(step[:output])
-      output.concat(cmd_output) if cmd_output.any?
+      # Truncate long commands for cleaner output
+      display_cmd = command_line.length > 60 ? "#{command_line[0..57]}..." : command_line
+      output << (@pastel.dim('    • ') + @pastel.cyan(display_cmd) + duration_str)
+      # Only show multiline details in debug mode
+      if @debug
+        output.concat(format_multiline_command(step[:command]))
+        cmd_output = format_command_output(step[:output])
+        output.concat(cmd_output) if cmd_output.any?
+      end
       output
     end
 
     def format_error(error_message)
-      @pastel.red("  ERROR: #{error_message}")
+      @pastel.red("    ✗ ERROR: #{error_message}")
     end
 
     def format_summary_header
-      @pastel.cyan("\nPLAY RECAP #{'*' * 64}")
+      "#{@pastel.bright_cyan("\n📊 Execution Summary")}\n#{@pastel.dim('─' * 60)}"
     end
 
     def format_summary_line(host, result, max_host_len)
@@ -168,24 +176,33 @@ module Kdeploy
       result = []
       return result unless output
 
-      # Handle Hash with stdout/stderr keys
       if output.is_a?(Hash)
-        # Check for stdout key
-        if output.key?(:stdout)
-          stdout = output[:stdout]
-          format_stdout_lines(stdout, result) if stdout && !stdout.to_s.strip.empty?
-        end
-        # Check for stderr key
-        if output.key?(:stderr)
-          stderr = output[:stderr]
-          format_stderr_lines(stderr, result) if stderr && !stderr.to_s.strip.empty?
-        end
+        format_hash_output(output, result)
       elsif output.is_a?(String) && !output.strip.empty?
         format_stdout_lines(output, result)
       end
       result
     end
 
+    def format_hash_output(output, result)
+      format_stdout_from_hash(output, result)
+      format_stderr_from_hash(output, result)
+    end
+
+    def format_stdout_from_hash(output, result)
+      return unless output.key?(:stdout)
+
+      stdout = output[:stdout]
+      format_stdout_lines(stdout, result) if stdout && !stdout.to_s.strip.empty?
+    end
+
+    def format_stderr_from_hash(output, result)
+      return unless output.key?(:stderr)
+
+      stderr = output[:stderr]
+      format_stderr_lines(stderr, result) if stderr && !stderr.to_s.strip.empty?
+    end
+
     def format_stdout_lines(stdout, result)
       return result if stdout.nil? || stdout.to_s.empty?
 

data/lib/kdeploy/runner.rb

@@ -5,18 +5,22 @@ require 'concurrent'
 module Kdeploy
   # Concurrent task runner for executing tasks across multiple hosts
   class Runner
-    def initialize(hosts, tasks, parallel: Configuration.default_parallel, output: ConsoleOutput.new)
+    def initialize(hosts, tasks, parallel: Configuration.default_parallel, output: ConsoleOutput.new, debug: false,
+                   base_dir: nil)
       @hosts = hosts
       @tasks = tasks
       @parallel = parallel
       @output = output
+      @debug = debug
+      @base_dir = base_dir
       @pool = Concurrent::FixedThreadPool.new(@parallel)
       @results = Concurrent::Hash.new
     end
 
     def run(task_name)
       task = find_task(task_name)
-      execute_concurrent_tasks(task)
+      results = execute_concurrent_tasks(task)
+      results
     ensure
       @pool.shutdown
     end
@@ -32,12 +36,52 @@ module Kdeploy
     def execute_concurrent_tasks(task)
       futures = create_task_futures(task)
 
+      # If no hosts, return empty results immediately
+      return @results if futures.empty?
+
       # Show progress while waiting for tasks to complete
       total = futures.length
       completed = 0
 
-      futures.each do |future|
-        future.wait
+      # Collect results from futures
+      futures.each_with_index do |future, index|
+        host_name = @host_names[index] # Get host name from the stored list
+        begin
+          # Wait for future to complete and get its value
+          # This ensures the future has finished executing
+          future_result = future.value
+
+          # Handle the result
+          if future_result.nil?
+            # Future returned nil - create a default result
+            @results[host_name] = { status: :unknown, error: 'Future returned nil', output: [] }
+          elsif future_result.is_a?(Array) && future_result.length == 2
+            name, result = future_result
+            # Store the result using the name from the future
+            @results[name] = result
+          else
+            # Handle unexpected result format - create a default result
+            @results[host_name] =
+              { status: :unknown, error: "Unexpected result format: #{future_result.class}", output: [] }
+          end
+
+          # Check if future raised an exception
+          if future.rejected?
+            error = begin
+              future.reason
+            rescue StandardError
+              'Unknown error'
+            end
+            @results[host_name] = { status: :failed, error: error, output: [] } unless @results.key?(host_name)
+          end
+        rescue StandardError => e
+          # If future.value raises an exception, create an error result
+          @results[host_name] = { status: :failed, error: "#{e.class}: #{e.message}", output: [] }
+        ensure
+          # Ensure we always have a result for this host
+          @results[host_name] ||= { status: :unknown, error: 'No result collected', output: [] }
+        end
+
         completed += 1
         # Show progress for multiple hosts
         next unless total > 1
@@ -51,6 +95,8 @@ module Kdeploy
     end
 
     def create_task_futures(task)
+      # Store host names in order to match with futures
+      @host_names = @hosts.keys
       @hosts.map do |name, config|
         Concurrent::Future.execute(executor: @pool) do
           execute_task_for_host(name, config, task)
@@ -61,14 +107,22 @@ module Kdeploy
     private
 
     def execute_task_for_host(name, config, task)
-      executor = Executor.new(config)
-      command_executor = CommandExecutor.new(executor, @output)
+      # Add base_dir to config for path resolution
+      config_with_base_dir = config.merge(base_dir: @base_dir)
+      executor = Executor.new(config_with_base_dir)
+      command_executor = CommandExecutor.new(executor, @output, debug: @debug)
       result = { status: :success, output: [] }
 
-      execute_grouped_commands(task, command_executor, name, result)
-      @results[name] = result
-    rescue StandardError => e
-      @results[name] = { status: :failed, error: e.message }
+      begin
+        execute_grouped_commands(task, command_executor, name, result)
+      rescue StandardError => e
+        # Ensure result is always set, even on error
+        # Don't re-raise, as it would cause future.value to fail
+        result = { status: :failed, error: e.message, output: [] }
+      end
+
+      # Return the result so it can be collected from the future
+      [name, result]
     end
 
     def execute_grouped_commands(task, command_executor, name, result)
@@ -111,8 +165,8 @@ module Kdeploy
     end
 
     def show_task_header(task_desc)
-      pastel = @output.respond_to?(:pastel) ? @output.pastel : Pastel.new
-      @output.write_line(pastel.cyan("\nTASK [#{task_desc}] " + ('*' * 64)))
+      # Don't show command header during execution - it will be shown in results
+      # This reduces noise during execution
     end
   end
 end

data/lib/kdeploy/version.rb

@@ -2,5 +2,5 @@
 
 # Kdeploy module for version management
 module Kdeploy
-  VERSION = '1.2.12' unless const_defined?(:VERSION)
+  VERSION = '1.2.14' unless const_defined?(:VERSION)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kdeploy
 version: !ruby/object:Gem::Version
-  version: 1.2.12
+  version: 1.2.14
 platform: ruby
 authors:
 - Kk
@@ -10,6 +10,20 @@ bindir: exe
 cert_chain: []
 date: 2025-11-19 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bcrypt_pbkdf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -24,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: ed25519
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: net-scp
   requirement: !ruby/object:Gem::Requirement