kdeploy 1.2.33 → 1.2.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba776f38e5a34ec7e6dac606aac7202391fdab2e4869aec08f526b3228bc8deb
-  data.tar.gz: aaa348b87ad83b9c8c1ad3291a2e45395594b922c1594fa82d54cd2a9b7c6d30
+  metadata.gz: 29a2ac38f02097f22a48646d3d6483b4e3fd65513f01eb6044ba7efd85f9e51f
+  data.tar.gz: 27d6af727a2929a8fe7ec7bca6e7b63a8b2acc6a373ab73baa89b536fbb76941
 SHA512:
-  metadata.gz: 7d731fd05fddc4b03c0aaef558e5200b6584772159262405d80cf807eae5f096689201e60aad944f0dd51b2a5e0db7d1d883476ec945cd3984a19383c840830c
-  data.tar.gz: 6ce986d5b3a60685ed51340298a0d0fbe22d25c2ee7c7cf584b3870d23174d004597e5135c7bb52a2f2f1d1006806c552d49ddcdb92080808348a580ec865947
+  metadata.gz: 6ec34aac0c945e25101d9a3d91b68121660a5ab16d47cb7d8cb736805d83ef4f09fd92701351051449ecf6427f85f955a93384ef99cffebebeae09cf1b9a11e1
+  data.tar.gz: 416f3adfc65db0a5534cafc2853296fe585742470a482802ad08156f13acb1259ff86bf33c5a10c6c5d671eaae2b04b5a8de3c1f2bdfb0e82646a58bc3512cfd

data/README.md

@@ -529,6 +529,67 @@ sync "./config", "/etc/app",
 - 同步静态资源文件
 - 保持本地和远程目录结构一致
 
+### Chef 风格资源 DSL
+
+Kdeploy 提供类似 Chef 的声明式资源 DSL，可替代或与底层原语（`run`、`upload`、`upload_template`）混用。
+
+#### `package` - 安装系统包
+
+```ruby
+package "nginx"
+package "nginx", version: "1.18"
+package "nginx", platform: :yum  # CentOS/RHEL
+```
+
+默认使用 apt（Ubuntu/Debian）；`platform: :yum` 生成 yum 命令。
+
+#### `service` - 管理系统服务（systemd）
+
+```ruby
+service "nginx", action: [:enable, :start]
+service "nginx", action: :restart
+service "nginx", action: [:stop, :disable]
+```
+
+支持 `:start`、`:stop`、`:restart`、`:reload`、`:enable`、`:disable`。
+
+#### `template` - 部署 ERB 模板
+
+```ruby
+template "/etc/nginx/nginx.conf", source: "./config/nginx.conf.erb", variables: { port: 3000 }
+# 或 block 语法
+template "/etc/app.conf" do
+  source "./config/app.erb"
+  variables(domain: "example.com")
+end
+```
+
+#### `file` - 上传本地文件
+
+```ruby
+file "/etc/nginx/conf.d/app.conf", source: "./config/app.conf"
+```
+
+#### `directory` - 确保远程目录存在
+
+```ruby
+directory "/etc/nginx/conf.d"
+directory "/var/log/app", mode: "0755"
+```
+
+**示例：使用资源 DSL 部署 Nginx**
+
+```ruby
+task :deploy_nginx, roles: :web do
+  package "nginx"
+  directory "/etc/nginx/conf.d"
+  template "/etc/nginx/nginx.conf", source: "./config/nginx.conf.erb", variables: { port: 3000 }
+  file "/etc/nginx/conf.d/app.conf", source: "./config/app.conf"
+  run "nginx -t"
+  service "nginx", action: [:enable, :restart]
+end
+```
+
 ### 模板支持
 
 Kdeploy 支持 ERB（嵌入式 Ruby）模板，用于动态配置生成。
@@ -875,7 +936,6 @@ kdeploy execute deploy.rb deploy --parallel 3
 - **Executor** (`executor.rb`): SSH/SCP 执行引擎
 - **Runner** (`runner.rb`): 并发任务执行协调器
 - **CommandExecutor** (`command_executor.rb`): 单个命令执行
-- **CommandGrouper** (`command_grouper.rb`): 命令分组逻辑
 - **Template** (`template.rb`): ERB 模板渲染
 - **Output** (`output.rb`): 输出格式化和显示
 - **Configuration** (`configuration.rb`): 配置管理
@@ -885,10 +945,9 @@ kdeploy execute deploy.rb deploy --parallel 3
 
 1. **解析配置**: 加载并解析 `deploy.rb`
 2. **解析主机**: 根据任务定义确定目标主机
-3. **分组命令**: 按类型分组命令以提高执行效率
-4. **并发执行**: 跨主机并行运行任务
-5. **收集结果**: 收集执行结果和状态
-6. **显示输出**: 格式化并向用户显示结果
+3. **并发执行**: 跨主机并行运行任务，按序执行每台主机上的命令
+4. **收集结果**: 收集执行结果和状态
+5. **显示输出**: 格式化并向用户显示结果
 
 ### 并发模型
 
@@ -928,7 +987,6 @@ kdeploy/
 │       ├── executor.rb         # SSH/SCP 执行器
 │       ├── runner.rb           # 任务运行器
 │       ├── command_executor.rb # 命令执行器
-│       ├── command_grouper.rb  # 命令分组器
 │       ├── template.rb         # 模板处理器
 │       ├── output.rb           # 输出接口
 │       ├── configuration.rb    # 配置

data/README_EN.md

@@ -486,6 +486,67 @@ upload_template "./config/nginx.conf.erb", "/etc/nginx/nginx.conf",
 - `destination`: Remote file path
 - `variables`: Hash of variables for template rendering
 
+### Chef-Style Resource DSL
+
+Kdeploy provides a declarative resource DSL similar to Chef, which can replace or mix with low-level primitives (`run`, `upload`, `upload_template`).
+
+#### `package` - Install System Packages
+
+```ruby
+package "nginx"
+package "nginx", version: "1.18"
+package "nginx", platform: :yum  # CentOS/RHEL
+```
+
+Uses apt (Ubuntu/Debian) by default; `platform: :yum` generates yum commands.
+
+#### `service` - Manage System Services (systemd)
+
+```ruby
+service "nginx", action: [:enable, :start]
+service "nginx", action: :restart
+service "nginx", action: [:stop, :disable]
+```
+
+Supports `:start`, `:stop`, `:restart`, `:reload`, `:enable`, `:disable`.
+
+#### `template` - Deploy ERB Templates
+
+```ruby
+template "/etc/nginx/nginx.conf", source: "./config/nginx.conf.erb", variables: { port: 3000 }
+# Or block syntax
+template "/etc/app.conf" do
+  source "./config/app.erb"
+  variables(domain: "example.com")
+end
+```
+
+#### `file` - Upload Local Files
+
+```ruby
+file "/etc/nginx/conf.d/app.conf", source: "./config/app.conf"
+```
+
+#### `directory` - Ensure Remote Directory Exists
+
+```ruby
+directory "/etc/nginx/conf.d"
+directory "/var/log/app", mode: "0755"
+```
+
+**Example: Deploy Nginx Using Resource DSL**
+
+```ruby
+task :deploy_nginx, roles: :web do
+  package "nginx"
+  directory "/etc/nginx/conf.d"
+  template "/etc/nginx/nginx.conf", source: "./config/nginx.conf.erb", variables: { port: 3000 }
+  file "/etc/nginx/conf.d/app.conf", source: "./config/app.conf"
+  run "nginx -t"
+  service "nginx", action: [:enable, :restart]
+end
+```
+
 ### Template Support
 
 Kdeploy supports ERB (Embedded Ruby) templates for dynamic configuration generation.
@@ -883,7 +944,6 @@ Enable verbose output by checking the execution output. Kdeploy provides detaile
 - **Executor** (`executor.rb`): SSH/SCP execution engine
 - **Runner** (`runner.rb`): Concurrent task execution coordinator
 - **CommandExecutor** (`command_executor.rb`): Individual command execution
-- **CommandGrouper** (`command_grouper.rb`): Command grouping logic
 - **Template** (`template.rb`): ERB template rendering
 - **Output** (`output.rb`): Output formatting and display
 - **Configuration** (`configuration.rb`): Configuration management
@@ -893,10 +953,9 @@ Enable verbose output by checking the execution output. Kdeploy provides detaile
 
 1. **Parse Configuration**: Load and parse `deploy.rb`
 2. **Resolve Hosts**: Determine target hosts based on task definition
-3. **Group Commands**: Group commands by type for efficient execution
-4. **Execute Concurrently**: Run tasks in parallel across hosts
-5. **Collect Results**: Gather execution results and status
-6. **Display Output**: Format and display results to user
+3. **Execute Concurrently**: Run tasks in parallel across hosts, executing commands in order per host
+4. **Collect Results**: Gather execution results and status
+5. **Display Output**: Format and display results to user
 
 ### Concurrency Model
 
@@ -936,7 +995,6 @@ kdeploy/
 │       ├── executor.rb         # SSH/SCP executor
 │       ├── runner.rb           # Task runner
 │       ├── command_executor.rb # Command executor
-│       ├── command_grouper.rb  # Command grouper
 │       ├── template.rb         # Template handler
 │       ├── output.rb           # Output interface
 │       ├── configuration.rb    # Configuration

data/lib/kdeploy/cli.rb

@@ -142,21 +142,24 @@ module Kdeploy
       print_summary(results, formatter) if show_summary
     end
 
-    def print_host_result(_host, result, formatter)
+    def print_host_result(host, result, formatter)
       if %i[success changed].include?(result[:status])
-        print_success_result(result, formatter)
+        print_success_result(host, result, formatter)
       else
-        print_failure_result(result, formatter)
+        print_failure_result(host, result, formatter)
       end
+
+      duration = formatter.calculate_host_duration(result)
+      puts "#{formatter.host_prefix(host)}#{formatter.format_host_completed(duration)}" if duration.positive?
     end
 
-    def print_success_result(result, formatter)
+    def print_success_result(host, result, formatter)
       shown = {}
       grouped = group_output_by_type(result[:output])
 
       grouped.each do |type, steps|
         output_lines = format_steps_by_type(type, steps, shown, formatter)
-        output_lines.each { |line| puts line }
+        output_lines.each { |line| puts "#{formatter.host_prefix(host)}#{line}" }
       end
     end
 
@@ -179,9 +182,21 @@ module Kdeploy
       end
     end
 
-    def print_failure_result(result, formatter)
+    def print_failure_result(host, result, formatter)
       error_message = extract_error_message(result)
-      puts formatter.format_error(error_message)
+      puts "#{formatter.host_prefix(host)}#{formatter.format_error(error_message)}"
+
+      # On failure, show steps that were executed (and any captured output)
+      # to make troubleshooting easier, even if --debug is not enabled.
+      return unless result[:output].is_a?(Array) && result[:output].any?
+
+      debug_formatter = OutputFormatter.new(debug: true)
+      shown = {}
+      grouped = group_output_by_type(result[:output])
+      grouped.each do |type, steps|
+        output_lines = format_steps_by_type(type, steps, shown, debug_formatter)
+        output_lines.each { |line| puts "#{debug_formatter.host_prefix(host)}#{line}" }
+      end
     end
 
     def print_summary(results, formatter)
@@ -214,6 +229,9 @@ module Kdeploy
         task_results = execute_single_task(task)
         # Collect results for final summary
         all_results[task] = task_results if task_results
+
+        # Stop executing remaining tasks once any host failed for this task.
+        break if task_failed?(task_results)
       end
 
       # Show combined summary at the end for all tasks
@@ -275,6 +293,12 @@ module Kdeploy
       end
     end
 
+    def task_failed?(task_results)
+      return false unless task_results.is_a?(Hash)
+
+      task_results.values.any? { |result| result[:status] == :failed }
+    end
+
     def print_all_tasks_summary(all_results)
       debug_mode = options[:debug] || false
       formatter = OutputFormatter.new(debug: debug_mode)

data/lib/kdeploy/command_executor.rb

@@ -11,26 +11,18 @@ module Kdeploy
       @retry_delay = retry_delay.to_f
     end
 
-    def execute_run(command, host_name)
+    def execute_run(command, _host_name)
       cmd = command[:command]
       use_sudo = command[:sudo]
-      show_command_header(host_name, :run, cmd)
-
-      # Show progress indicator for long-running commands
-      pastel = @output.respond_to?(:pastel) ? @output.pastel : Pastel.new
 
       result, duration = measure_time do
         with_retries { @executor.execute(cmd, use_sudo: use_sudo) }
       end
 
-      # 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
-
       { command: cmd, output: result, duration: duration, type: :run }
     end
 
-    def execute_upload(command, host_name)
-      show_command_header(host_name, :upload, "#{command[:source]} -> #{command[:destination]}")
+    def execute_upload(command, _host_name)
       _result, duration = measure_time do
         with_retries { @executor.upload(command[:source], command[:destination]) }
       end
@@ -41,8 +33,7 @@ module Kdeploy
       }
     end
 
-    def execute_upload_template(command, host_name)
-      show_command_header(host_name, :upload_template, "#{command[:source]} -> #{command[:destination]}")
+    def execute_upload_template(command, _host_name)
       _result, duration = measure_time do
         with_retries do
           @executor.upload_template(command[:source], command[:destination], command[:variables])
@@ -55,11 +46,9 @@ module Kdeploy
       }
     end
 
-    def execute_sync(command, host_name)
+    def execute_sync(command, _host_name)
       source = command[:source]
       destination = command[:destination]
-      description = build_sync_description(source, destination, command[:delete])
-      show_command_header(host_name, :sync, description)
 
       result, duration = measure_time do
         with_retries do
@@ -78,12 +67,6 @@ module Kdeploy
 
     private
 
-    def build_sync_description(source, destination, delete)
-      desc = "sync: #{source} -> #{destination}"
-      desc += " (delete: #{delete})" if delete
-      desc
-    end
-
     def build_sync_result(source, destination, result, duration)
       {
         command: "sync: #{source} -> #{destination}",
@@ -115,32 +98,5 @@ module Kdeploy
         retry
       end
     end
-
-    def show_command_header(host_name, type, description)
-      # Don't show command header during execution - it will be shown in results
-      # This reduces noise during execution
-    end
-
-    def pastel_instance
-      @output.respond_to?(:pastel) ? @output.pastel : Pastel.new
-    end
-
-    def format_command_by_type(type, description, pastel)
-      case type
-      when :run
-        format_run_command(description, pastel)
-      when :upload
-        @output.write_line(pastel.green("  [upload] #{description}"))
-      when :upload_template
-        @output.write_line(pastel.yellow("  [template] #{description}"))
-      end
-    end
-
-    def format_run_command(description, pastel)
-      @output.write_line(pastel.cyan("  [run]    #{description.lines.first.strip}"))
-      description.lines[1..].each do |line|
-        @output.write_line("           > #{line.strip}") unless line.strip.empty?
-      end
-    end
   end
 end

data/lib/kdeploy/dsl.rb

@@ -1,8 +1,27 @@
 # frozen_string_literal: true
 
 require 'set'
+require 'shellwords'
 
 module Kdeploy
+  # Helper for template resource block: captures source and variables
+  class TemplateOptions
+    def initialize
+      @source = nil
+      @variables = {}
+    end
+
+    def variables(val = nil)
+      @variables = val if val
+      @variables
+    end
+
+    def source(val = nil)
+      @source = val if val
+      @source
+    end
+  end
+
   # Domain-specific language for defining hosts, roles, and tasks
   module DSL
     def self.included(base)
@@ -154,6 +173,60 @@ module Kdeploy
       }
     end
 
+    # -------------------------------------------------------------------------
+    # Chef-style resource DSL (compiles to run/upload/upload_template)
+    # -------------------------------------------------------------------------
+
+    # 安装系统包。默认 apt 平台；支持 platform: :yum。
+    def package(name, version: nil, platform: :apt)
+      @kdeploy_commands ||= []
+      cmd = build_package_command(name, version, platform)
+      @kdeploy_commands << { type: :run, command: cmd, sudo: true }
+    end
+
+    # 管理系统服务（systemd）。action 支持 :start, :stop, :restart, :reload, :enable, :disable。
+    def service(name, action: :start)
+      @kdeploy_commands ||= []
+      actions = Array(action)
+      actions.each do |a|
+        cmd = "systemctl #{a} #{Shellwords.escape(name.to_s)}"
+        @kdeploy_commands << { type: :run, command: cmd, sudo: true }
+      end
+    end
+
+    # 部署 ERB 模板到远程路径。支持 block 或关键字参数。
+    def template(destination, source: nil, variables: nil, &block)
+      @kdeploy_commands ||= []
+      if block
+        opts = TemplateOptions.new
+        opts.instance_eval(&block)
+        src = opts.source || raise(ArgumentError, 'template requires source')
+        vars = opts.variables || {}
+      else
+        raise ArgumentError, 'template requires source' unless source
+
+        src = source
+        vars = variables || {}
+      end
+      upload_template(src, destination, vars)
+    end
+
+    # 上传本地文件到远程路径。
+    def file(destination, source:)
+      @kdeploy_commands ||= []
+      upload(source, destination)
+    end
+
+    # 确保远程目录存在。支持 mode 参数。
+    def directory(path, mode: nil)
+      @kdeploy_commands ||= []
+      cmd = "mkdir -p #{Shellwords.escape(path.to_s)}"
+      @kdeploy_commands << { type: :run, command: cmd, sudo: true }
+      return unless mode
+
+      @kdeploy_commands << { type: :run, command: "chmod #{mode} #{Shellwords.escape(path.to_s)}", sudo: true }
+    end
+
     def inventory(&block)
       instance_eval(&block) if block_given?
     end
@@ -188,5 +261,20 @@ module Kdeploy
         end
       end
     end
+
+    def build_package_command(name, version, platform)
+      n = Shellwords.escape(name.to_s)
+      case platform.to_sym
+      when :yum, :rpm
+        if version
+          "yum install -y #{n}-#{Shellwords.escape(version.to_s)}"
+        else
+          "yum install -y #{n}"
+        end
+      else
+        base = "apt-get update && apt-get install -y #{n}"
+        version ? "#{base}=#{Shellwords.escape(version.to_s)}" : base
+      end
+    end
   end
 end

data/lib/kdeploy/errors.rb

@@ -20,12 +20,16 @@ module Kdeploy
 
   # Raised when SSH operation fails
   class SSHError < Error
-    def initialize(message, original_error = nil)
+    def initialize(message, original_error = nil, command: nil, exit_status: nil, stdout: nil, stderr: nil)
       super("SSH operation failed: #{message}")
       @original_error = original_error
+      @command = command
+      @exit_status = exit_status
+      @stdout = stdout
+      @stderr = stderr
     end
 
-    attr_reader :original_error
+    attr_reader :original_error, :command, :exit_status, :stdout, :stderr
   end
 
   # Raised when SCP operation fails

data/lib/kdeploy/executor.rb

@@ -38,16 +38,21 @@ module Kdeploy
     def execute_command_on_ssh(ssh, command)
       stdout = String.new
       stderr = String.new
+      exit_status = nil
 
       ssh.open_channel do |channel|
         channel.exec(command) do |_ch, success|
           raise SSHError, "Could not execute command: #{command}" unless success
 
           setup_channel_handlers(channel, stdout, stderr)
+          channel.on_request('exit-status') do |_ch, data|
+            exit_status = data.read_long
+          end
         end
       end
       ssh.loop
-      build_command_result(stdout, stderr, command)
+      raise_nonzero_exit!(command, exit_status, stdout, stderr)
+      build_command_result(stdout, stderr, command, exit_status)
     end
 
     def setup_channel_handlers(channel, stdout, stderr)
@@ -60,14 +65,29 @@ module Kdeploy
       end
     end
 
-    def build_command_result(stdout, stderr, command)
+    def build_command_result(stdout, stderr, command, exit_status)
       {
         stdout: stdout.strip,
         stderr: stderr.strip,
-        command: command
+        command: command,
+        exit_status: exit_status
       }
     end
 
+    def raise_nonzero_exit!(command, exit_status, stdout, stderr)
+      return if exit_status.nil?
+      return if exit_status.zero?
+
+      raise SSHError.new(
+        "Command exited with status #{exit_status}",
+        nil,
+        command: command,
+        exit_status: exit_status,
+        stdout: stdout.strip,
+        stderr: stderr.strip
+      )
+    end
+
     def upload(source, destination, use_sudo: nil)
       use_sudo = @use_sudo if use_sudo.nil?
 

data/lib/kdeploy/initializer.rb

@@ -39,27 +39,21 @@ module Kdeploy
         role :web, %w[web01 web02]
         role :db, %w[db01]
 
-        # Define deployment task for web servers
+        # Define deployment task for web servers (Chef-style resource DSL)
         task :deploy_web, roles: :web do
-          # Example: Using sudo option for specific command
-          # run "systemctl stop nginx", sudo: true
-          run <<~SHELL
-            sudo systemctl stop nginx
-            echo "Deploying..."
-          SHELL
-
-          upload_template './config/nginx.conf.erb', '/etc/nginx/nginx.conf',
-            domain_name: 'example.com',
-            port: 3000,
-            worker_processes: 4,
-            worker_connections: 2048
-
-          upload './config/app.conf', '/etc/nginx/conf.d/app.conf'
-
-          run <<~SHELL
-            sudo systemctl start nginx
-            sudo systemctl status nginx
-          SHELL
+          package 'nginx'
+          directory '/etc/nginx/conf.d'
+          template '/etc/nginx/nginx.conf',
+            source: './config/nginx.conf.erb',
+            variables: {
+              domain_name: 'example.com',
+              port: 3000,
+              worker_processes: 4,
+              worker_connections: 2048
+            }
+          file '/etc/nginx/conf.d/app.conf', source: './config/app.conf'
+          run 'nginx -t', sudo: true
+          service 'nginx', action: %i[enable restart]
         end
 
         # Define backup task for database servers
@@ -71,13 +65,11 @@ module Kdeploy
           SHELL
         end
 
-        # Define task for specific hosts
+        # Define task for specific hosts (resource DSL example)
         task :maintenance, on: %w[web01] do
-          run <<~SHELL
-            sudo systemctl stop nginx
-            sudo apt-get update && sudo apt-get upgrade -y
-            sudo systemctl start nginx
-          SHELL
+          service 'nginx', action: :stop
+          run 'apt-get update && apt-get upgrade -y', sudo: true
+          service 'nginx', action: %i[start enable]
         end
 
         # Define task for all hosts
@@ -199,12 +191,12 @@ module Kdeploy
         server_name <%= domain_name %>;
         ```
 
-        Variables are passed when uploading the template:
+        Variables are passed when uploading the template (Chef-style resource DSL):
 
         ```ruby
-        upload_template "./config/nginx.conf.erb", "/etc/nginx/nginx.conf",
-          domain_name: "example.com",
-          worker_processes: 4
+        template "/etc/nginx/nginx.conf",
+          source: "./config/nginx.conf.erb",
+          variables: { domain_name: "example.com", worker_processes: 4 }
         ```
 
         ## 🔐 Using Sudo

data/lib/kdeploy/output_formatter.rb

@@ -24,64 +24,60 @@ module Kdeploy
       @pastel.bright_white("  #{host.ljust(20)} #{status_str}")
     end
 
-    def format_upload_steps(steps, shown)
-      format_file_steps(steps, shown, :upload, @pastel.green('  === Upload ==='), 'upload: ')
+    # Prefix for per-step lines to make multi-host logs easier to scan.
+    def host_prefix(host)
+      @pastel.dim("  #{host.ljust(20)} ")
     end
 
-    def format_template_steps(steps, shown)
-      format_file_steps(steps, shown, :upload_template, @pastel.yellow('  === Template ==='), 'upload_template: ')
+    def format_host_completed(duration)
+      @pastel.dim("    [completed in #{format('%.2f', duration)}s]")
     end
 
-    def format_sync_steps(steps, shown)
-      output = []
-      steps.each do |step|
-        next if step_already_shown?(step, :sync, shown)
+    def calculate_host_duration(result)
+      return 0.0 unless result.is_a?(Hash)
 
-        mark_step_as_shown(step, :sync, shown)
-        output << format_sync_step(step)
-      end
-      output
+      Array(result[:output]).sum { |step| step[:duration].to_f }
     end
 
-    def format_file_steps(steps, shown, type, _header, prefix)
-      output = []
-      steps.each do |step|
-        next if step_already_shown?(step, type, shown)
+    def format_upload_steps(steps, _shown = nil)
+      format_file_steps(steps, :upload, 'upload: ')
+    end
 
-        mark_step_as_shown(step, type, shown)
-        output << format_file_step(step, type, prefix)
-      end
-      output
+    def format_template_steps(steps, _shown = nil)
+      format_file_steps(steps, :upload_template, 'upload_template: ')
+    end
+
+    def format_sync_steps(steps, _shown = nil)
+      steps.map { |step| format_sync_step(step) }
+    end
+
+    def format_file_steps(steps, type, prefix)
+      steps.map { |step| format_file_step(step, type, prefix) }
     end
 
     def format_file_step(step, type, prefix)
       duration_str = format_duration(step[:duration])
+      status_str = format_step_status(step)
       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
+      @pastel.dim("    #{icon} ") + @pastel.send(color_method, display_path) + duration_str + " #{status_str}"
     end
 
-    def format_run_steps(steps, shown)
-      output = []
-      steps.each do |step|
-        next if step_already_shown?(step, :run, shown)
-
-        mark_step_as_shown(step, :run, shown)
-        output.concat(format_single_run_step(step))
-      end
-      output
+    def format_run_steps(steps, _shown = nil)
+      steps.flat_map { |step| format_single_run_step(step) }
     end
 
     def format_single_run_step(step)
       output = []
       duration_str = format_duration(step[:duration])
-      command_line = step[:command].to_s.lines.first.strip
+      status_str = format_step_status(step)
+      command_line = first_meaningful_command_line(step[:command].to_s)
       # 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)
+      output << (@pastel.dim('    • ') + @pastel.cyan(display_cmd) + duration_str + " #{status_str}")
       # Only show multiline details in debug mode
       if @debug
         output.concat(format_multiline_command(step[:command]))
@@ -187,6 +183,17 @@ module Kdeploy
       output
     end
 
+    def first_meaningful_command_line(command)
+      lines = command.to_s.lines.map(&:strip)
+      lines.each do |line|
+        next if line.empty?
+        next if line.start_with?('#')
+
+        return line
+      end
+      lines.first.to_s
+    end
+
     def format_command_output(output)
       result = []
       return result unless output
@@ -240,18 +247,9 @@ module Kdeploy
       result
     end
 
-    def step_already_shown?(step, type, shown)
-      key = [step[:command], type].hash
-      shown[key]
-    end
-
-    def mark_step_as_shown(step, type, shown)
-      key = [step[:command], type].hash
-      shown[key] = true
-    end
-
     def format_sync_step(step)
       duration_str = format_duration(step[:duration])
+      status_str = format_step_status(step)
       sync_path = step[:command].sub('sync: ', '')
       # Truncate long paths for cleaner output
       display_path = sync_path.length > 50 ? "...#{sync_path[-47..]}" : sync_path
@@ -266,7 +264,15 @@ module Kdeploy
       stats << @pastel.yellow("#{deleted} deleted") if deleted.positive?
       stats_str = stats.any? ? " (#{stats.join(', ')})" : " (#{total} files)"
 
-      @pastel.dim('    📁 ') + @pastel.cyan(display_path) + @pastel.dim(stats_str) + duration_str
+      @pastel.dim('    📁 ') + @pastel.cyan(display_path) + @pastel.dim(stats_str) + duration_str + " #{status_str}"
+    end
+
+    def format_step_status(step)
+      if step.is_a?(Hash) && step.key?(:error) && step[:error] && !step[:error].to_s.empty?
+        @pastel.red('✗ failed')
+      else
+        @pastel.green('✓ ok')
+      end
     end
   end
 end

data/lib/kdeploy/runner.rb

@@ -41,10 +41,6 @@ module Kdeploy
       # 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
-
       # Collect results from futures
       futures.each_with_index do |future, index|
         host_name = @host_names[index] # Get host name from the stored list
@@ -86,14 +82,6 @@ module Kdeploy
           # 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
-
-        pastel = @output.respond_to?(:pastel) ? @output.pastel : Pastel.new
-        @output.write_line(pastel.dim("    [Progress: #{completed}/#{total} hosts completed]"))
-        @output.flush if @output.respond_to?(:flush)
       end
 
       @results
@@ -125,41 +113,47 @@ module Kdeploy
       result = { status: :success, output: [] }
 
       begin
-        execute_grouped_commands(task, command_executor, name, result, task_name)
+        execute_commands(task, command_executor, name, result, task_name)
       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.class}: #{e.message}", output: [] }
+        # Keep any already collected step output for troubleshooting.
+        result[:status] = :failed
+        result[:error] = "#{e.class}: #{e.message}"
       end
 
       # Return the result so it can be collected from the future
       [name, result]
     end
 
-    def execute_grouped_commands(task, command_executor, name, result, task_name)
+    def execute_commands(task, command_executor, name, result, task_name)
       commands = task[:block].call
-      grouped_commands = CommandGrouper.group(commands)
 
-      grouped_commands.each_value do |command_group|
-        execute_command_group(command_group, command_executor, name, result, task_name)
+      commands.each do |command|
+        step_result = execute_command(command_executor, command, name)
+        result[:output] << step_result
+      rescue StandardError => e
+        step = step_description(command)
+        result[:status] = :failed
+        result[:error] = "task=#{task_name} host=#{name} step=#{step} error=#{e.class}: #{e.message}"
+        result[:output] << {
+          type: command[:type],
+          command: step_command_string(command),
+          duration: 0.0,
+          error: "#{e.class}: #{e.message}",
+          output: error_output_for_step(e)
+        }
+        break
       end
     end
 
-    def execute_command_group(command_group, command_executor, name, result, task_name)
-      first_cmd = command_group.first
-      task_desc = CommandGrouper.task_description(first_cmd)
-      show_task_header(task_desc)
+    def error_output_for_step(error)
+      return nil unless error.is_a?(Kdeploy::SSHError)
 
-      command_group.each_with_index do |command, index|
-        # Show progress for multiple commands
-        if command_group.length > 1
-          pastel = @output.respond_to?(:pastel) ? @output.pastel : Pastel.new
-          @output.write_line(pastel.dim("    [Step #{index + 1}/#{command_group.length}]"))
-        end
-
-        step_result = execute_command_with_context(command_executor, command, name, task_name)
-        result[:output] << step_result
-      end
+      {
+        stdout: error.stdout,
+        stderr: error.stderr,
+        exit_status: error.exit_status,
+        command: error.command
+      }
     end
 
     def execute_command(command_executor, command, host_name)
@@ -177,11 +171,19 @@ module Kdeploy
       end
     end
 
-    def execute_command_with_context(command_executor, command, host_name, task_name)
-      execute_command(command_executor, command, host_name)
-    rescue StandardError => e
-      step = step_description(command)
-      raise StandardError, "task=#{task_name} host=#{host_name} step=#{step} error=#{e.class}: #{e.message}"
+    def step_command_string(command)
+      case command[:type]
+      when :run
+        command[:command].to_s
+      when :upload
+        "upload: #{command[:source]} -> #{command[:destination]}"
+      when :upload_template
+        "upload_template: #{command[:source]} -> #{command[:destination]}"
+      when :sync
+        "sync: #{command[:source]} -> #{command[:destination]}"
+      else
+        command[:type].to_s
+      end
     end
 
     def step_description(command)
@@ -199,10 +201,5 @@ module Kdeploy
         command[:type].to_s
       end
     end
-
-    def show_task_header(task_desc)
-      # 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.33' unless const_defined?(:VERSION)
+  VERSION = '1.2.38' unless const_defined?(:VERSION)
 end

data/lib/kdeploy.rb

@@ -8,7 +8,6 @@ require_relative 'kdeploy/banner'
 require_relative 'kdeploy/file_filter'
 require_relative 'kdeploy/dsl'
 require_relative 'kdeploy/executor'
-require_relative 'kdeploy/command_grouper'
 require_relative 'kdeploy/command_executor'
 require_relative 'kdeploy/output_formatter'
 require_relative 'kdeploy/help_formatter'

data/r.md

@@ -0,0 +1 @@
+# Your product documentation

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kdeploy
 version: !ruby/object:Gem::Version
-  version: 1.2.33
+  version: 1.2.38
 platform: ruby
 authors:
 - Kk
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-01-25 00:00:00.000000000 Z
+date: 2026-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bcrypt_pbkdf
@@ -169,7 +169,6 @@ files:
 - lib/kdeploy/banner.rb
 - lib/kdeploy/cli.rb
 - lib/kdeploy/command_executor.rb
-- lib/kdeploy/command_grouper.rb
 - lib/kdeploy/completions/kdeploy.bash
 - lib/kdeploy/completions/kdeploy.zsh
 - lib/kdeploy/configuration.rb

data/lib/kdeploy/command_grouper.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module Kdeploy
-  # Groups commands by type and generates task descriptions
-  class CommandGrouper
-    def self.group(commands)
-      commands.group_by do |cmd|
-        group_key_for(cmd)
-      end
-    end
-
-    def self.group_key_for(cmd)
-      case cmd[:type]
-      when :upload, :upload_template, :sync
-        "#{cmd[:type]}_#{cmd[:source]}"
-      when :run
-        "#{cmd[:type]}_#{cmd[:command].to_s.lines.first.strip}"
-      else
-        cmd[:type].to_s
-      end
-    end
-
-    def self.task_description(command)
-      case command[:type]
-      when :upload
-        "upload #{command[:source]}"
-      when :upload_template
-        "template #{command[:source]}"
-      when :sync
-        "sync #{command[:source]}"
-      when :run
-        command[:command].to_s.lines.first.strip
-      else
-        command[:type].to_s
-      end
-    end
-  end
-end