ruby-progress 1.3.2 → 1.3.5

data/lib/ruby-progress/cli/job_cli.rb

@@ -1,159 +1,198 @@
 # frozen_string_literal: true
 
-# CLI: prg job
-
-# Provides the `prg job send` helper to enqueue commands into a daemon's
-# job directory. This file contains a minimal implementation used by tests.
+# CLI: prg job [subcommand]
+# Send control messages to backgrounded progress indicators.
 
 require 'optparse'
 require 'json'
-require 'securerandom'
 require 'fileutils'
 require_relative '../daemon'
 
-# Job CLI helpers
+# JobCLI - sends control messages to backgrounded progress indicators
 #
-# Exposed as `prg job send`.
+# Usage:
+#   prg job stop --daemon-name mytask [--message "Done!"] [--checkmark]
+#   prg job advance --daemon-name mytask [--amount 10]
+#   prg job status --daemon-name mytask
 module JobCLI
-  # JobCLI
-  #
-  # Small CLI module that exposes `prg job send` for enqueuing jobs into the
-  # daemon job directory. This is intentionally minimal: it writes a single
-  # JSON file atomically and optionally waits for a result file created by
-  # the daemon's job processor.
-  # Simple CLI for submitting jobs to a running daemon job directory.
-  # Usage: prg job send --pid-file /tmp/... --command "echo hi" [--wait]
-  class Options
-    def self.parse(argv)
-      options = { wait: false }
-      opt = OptionParser.new do |o|
-        o.banner = 'Usage: prg job send [options]'
-        o.on('--pid-file PATH', 'Path to daemon pid file') do |v|
-          options[:pid_file] = v
-        end
-        o.on('--daemon-name NAME', 'Daemon name (maps to /tmp/ruby-progress/NAME.pid)') do |v|
-          options[:daemon_name] = v
-        end
-        o.on('--command CMD', 'Command to run') do |v|
-          options[:command] = v
-        end
-        o.on('--stdin', 'Read command from stdin (overrides --command)') do
-          options[:stdin] = true
-        end
-        o.on('--advance', 'Send an advance action (no value)') do
-          options[:action] = 'advance'
-        end
-        o.on('--percent N', Integer, 'Send a percent action with value N') do |v|
-          options[:action] = 'percent'
-          options[:value] = v
-        end
-        o.on('--complete', 'Send a complete action (no value)') do
-          options[:action] = 'complete'
-        end
-        o.on('--cancel', 'Send a cancel action (no value)') do
-          options[:action] = 'cancel'
-        end
-        o.on('--action ACTION', 'Send a custom action name') do |v|
-          options[:action] = v
-        end
-        o.on('--value VAL', 'Value for the action (string or number)') do |v|
-          options[:value] = v
-        end
-        o.on('--wait', 'Wait for result file and print it') do
-          options[:wait] = true
-        end
-        o.on('--timeout SECONDS', Integer, 'Timeout seconds for wait') do |v|
-          options[:timeout] = v
-        end
-      end
+  def self.run(argv = ARGV)
+    if argv.empty?
+      print_help
+      exit 1
+    end
 
-      rest = opt.parse(argv)
-      options[:command] ||= rest.join(' ') unless rest.empty?
-      options
+    subcommand = argv.shift
+
+    case subcommand
+    when 'stop'
+      stop(argv)
+    when 'advance'
+      advance(argv)
+    when 'status'
+      status(argv)
+    when 'send'
+      # Backward compatibility: 'send' is now 'stop'
+      warn "Warning: 'prg job send' is deprecated. Use 'prg job stop' instead."
+      stop(argv)
+    when '--help', '-h'
+      print_help
+    else
+      warn "Error: Unknown subcommand '#{subcommand}'"
+      print_help
+      exit 1
     end
   end
 
-  def self.send(argv = ARGV)
-    opts = Options.parse(argv)
-
-    # Resolve pid file
-    pid_file = if opts[:pid_file]
-                 opts[:pid_file]
-               elsif opts[:daemon_name]
-                 "/tmp/ruby-progress/#{opts[:daemon_name]}.pid"
-               else
-                 RubyProgress::Daemon.default_pid_file
-               end
-
-    job_dir = RubyProgress::Daemon.job_dir_for_pid(pid_file)
-    FileUtils.mkdir_p(job_dir)
-
-    cmd = if opts[:stdin]
-            $stdin.read
-          else
-            opts[:command]
-          end
-
-    is_action = !opts[:action].nil? && opts[:action] != false
-
-    if is_action
-      if cmd && !cmd.strip.empty?
-        warn 'Cannot specify both --command/--stdin and an action flag'
-        exit 1
-      end
+  def self.print_help
+    puts 'Usage: prg job [subcommand] [options]'
+    puts
+    puts 'Subcommands:'
+    puts '  stop     Stop a running progress indicator'
+    puts '  advance  Advance a fill progress bar'
+    puts '  status   Check status of a running indicator'
+    puts
+    puts 'Common Options:'
+    puts '  --daemon-name NAME   Name of the daemon to control'
+    puts '  --pid-file PATH      Path to daemon PID file'
+    puts
+    puts 'Examples:'
+    puts '  prg job stop --daemon-name mytask --message "Complete!"'
+    puts '  prg job advance --daemon-name mybar --amount 10'
+    puts '  prg job status --daemon-name mytask'
+  end
+
+  def self.resolve_pid_file(opts)
+    if opts[:pid_file]
+      opts[:pid_file]
+    elsif opts[:daemon_name]
+      "/tmp/ruby-progress/#{opts[:daemon_name]}.pid"
     else
-      unless cmd && !cmd.strip.empty?
-        warn 'No command specified. Use --command, --stdin, or pass an action flag.'
-        exit 1
-      end
+      RubyProgress::Daemon.default_pid_file
+    end
+  end
+
+  def self.stop(argv)
+    opts = parse_stop_options(argv)
+    pid_file = resolve_pid_file(opts)
+
+    unless File.exist?(pid_file)
+      warn "PID file #{pid_file} not found. Is the daemon running?"
+      exit 1
     end
 
-    job_id = SecureRandom.uuid
-    tmp = File.join(job_dir, "#{job_id}.json.tmp")
-    final = File.join(job_dir, "#{job_id}.json")
-
-    payload = build_payload(opts, job_id, cmd)
-
-    File.write(tmp, JSON.dump(payload))
-    FileUtils.mv(tmp, final)
-
-    if opts[:wait]
-      timeout = opts[:timeout] || 10
-      start = Time.now
-      result_path = "#{final}.processing.result"
-      loop do
-        if File.exist?(result_path)
-          puts File.read(result_path)
-          break
-        end
-        if Time.now - start > timeout
-          warn 'Timed out waiting for result'
-          exit 2
-        end
-        sleep 0.1
+    RubyProgress::Daemon.stop_daemon_by_pid_file(
+      pid_file,
+      message: opts[:message],
+      checkmark: opts[:checkmark] || false,
+      error: opts[:error] || false
+    )
+
+    # Don't output confirmation - the daemon itself shows the completion message
+  end
+
+  def self.advance(argv)
+    opts = parse_advance_options(argv)
+    pid_file = resolve_pid_file(opts)
+
+    unless File.exist?(pid_file)
+      warn "PID file #{pid_file} not found. Is the daemon running?"
+      exit 1
+    end
+
+    # Write advance command to control message file
+    cmf = RubyProgress::Daemon.control_message_file(pid_file)
+    control_data = {
+      action: 'advance',
+      amount: opts[:amount] || 1,
+      total: opts[:total]
+    }.compact
+
+    File.write(cmf, JSON.generate(control_data))
+
+    # Send signal to daemon to check for messages
+    pid = File.read(pid_file).strip.to_i
+    begin
+      Process.kill('USR2', pid)
+    rescue Errno::ESRCH
+      # Process doesn't exist
+    end
+
+    # Silent operation for script-friendly usage
+  end
+
+  def self.status(argv)
+    opts = parse_status_options(argv)
+    pid_file = resolve_pid_file(opts)
+
+    RubyProgress::Daemon.show_status(pid_file)
+  end
+
+  def self.parse_stop_options(argv)
+    options = {}
+    opt = OptionParser.new do |o|
+      o.banner = 'Usage: prg job stop [options]'
+      o.on('--pid-file PATH', 'Path to daemon PID file') do |v|
+        options[:pid_file] = v
+      end
+      o.on('--daemon-name NAME', 'Daemon name (maps to /tmp/ruby-progress/NAME.pid)') do |v|
+        options[:daemon_name] = v
+      end
+      o.on('--message MSG', 'Optional completion message to display') do |v|
+        options[:message] = v
+      end
+      o.on('--checkmark', 'Display a checkmark on completion') do
+        options[:checkmark] = true
+      end
+      o.on('--error', 'Mark completion as error state') do
+        options[:error] = true
       end
-    else
-      puts job_id
     end
+
+    opt.parse(argv)
+    options
   end
 
-  # Build the JSON payload for a job based on parsed options.
-  def self.build_payload(opts, job_id, cmd)
-    payload = { 'id' => job_id }
+  def self.parse_advance_options(argv)
+    options = {}
+    opt = OptionParser.new do |o|
+      o.banner = 'Usage: prg job advance [options]'
+      o.on('--pid-file PATH', 'Path to daemon PID file') do |v|
+        options[:pid_file] = v
+      end
+      o.on('--daemon-name NAME', 'Daemon name (maps to /tmp/ruby-progress/NAME.pid)') do |v|
+        options[:daemon_name] = v
+      end
+      o.on('--amount N', Integer, 'Amount to advance (default: 1)') do |v|
+        options[:amount] = v
+      end
+      o.on('--total N', Integer, 'Update total if needed') do |v|
+        options[:total] = v
+      end
+    end
 
-    is_action = !opts[:action].nil? && opts[:action] != false
+    opt.parse(argv)
+    options
+  end
 
-    if is_action
-      payload['action'] = opts[:action]
-      if opts.key?(:value)
-        val = opts[:value]
-        payload['value'] = val.to_i if val.is_a?(String) && val =~ /^\d+$/
-        payload['value'] ||= val
+  def self.parse_status_options(argv)
+    options = {}
+    opt = OptionParser.new do |o|
+      o.banner = 'Usage: prg job status [options]'
+      o.on('--pid-file PATH', 'Path to daemon PID file') do |v|
+        options[:pid_file] = v
+      end
+      o.on('--daemon-name NAME', 'Daemon name (maps to /tmp/ruby-progress/NAME.pid)') do |v|
+        options[:daemon_name] = v
       end
-    else
-      payload['command'] = cmd
     end
 
-    payload
+    opt.parse(argv)
+    options
+  end
+
+  # Backward compatibility
+  def self.send(argv = ARGV)
+    warn "Warning: 'JobCLI.send' is deprecated. Use 'JobCLI.stop' instead."
+    stop(argv)
   end
 end

data/lib/ruby-progress/cli/ripple_cli.rb

@@ -8,6 +8,14 @@ require_relative '../output_capture'
 
 # Enhanced Ripple CLI with unified flags (extracted from bin/prg)
 module RippleCLI
+  def self.resolve_pid_file(options, name_key = :daemon_name)
+    return options[:pid_file] if options[:pid_file]
+
+    return "/tmp/ruby-progress/#{options[name_key]}.pid" if options[name_key]
+
+    RubyProgress::Daemon.default_pid_file
+  end
+
   def self.run
     trap('INT') do
       RubyProgress::Utils.show_cursor
@@ -18,11 +26,11 @@ module RippleCLI
 
     # Daemon/status/stop handling (process these without requiring text)
     if options[:status]
-      pid_file = options[:pid_file] || RubyProgress::Daemon.default_pid_file
+      pid_file = resolve_pid_file(options, :status_name)
       RubyProgress::Daemon.show_status(pid_file)
       exit
     elsif options[:stop]
-      pid_file = options[:pid_file] || RubyProgress::Daemon.default_pid_file
+      pid_file = resolve_pid_file(options, :stop_name)
       stop_msg = options[:stop_error] || options[:stop_success]
       is_error = !options[:stop_error].nil?
       RubyProgress::Daemon.stop_daemon_by_pid_file(
@@ -33,13 +41,8 @@ module RippleCLI
       )
       exit
     elsif options[:daemon]
-      # For daemon mode, detach so shell has no tracked job unless the user
-      # requested a non-detaching background child via --no-detach.
-      if options[:no_detach]
-        PrgCLI.backgroundize
-      else
-        PrgCLI.daemonize
-      end
+      # Background without detaching so ripple remains visible in current terminal
+      PrgCLI.backgroundize
 
       # For daemon mode, default message if none provided
       text = options[:message] || ARGV.join(' ')
@@ -71,7 +74,12 @@ module RippleCLI
     if $stdout.tty?
       # Interactive TTY: use PTY-based capture so the animation can run while the
       # command executes. We only print captured stdout if options[:output] == :stdout.
-      oc = RubyProgress::OutputCapture.new(command: options[:command], lines: options[:output_lines] || 3, position: options[:output_position] || :above)
+      oc = RubyProgress::OutputCapture.new(
+        command: options[:command],
+        lines: options[:output_lines] || 3,
+        position: options[:output_position] || :above,
+        stream: options[:output] == :stdout || options[:stdout_live]
+      )
       oc.start
 
       # Create rippler. Attach output capture only when the user requested
@@ -120,7 +128,7 @@ module RippleCLI
   end
 
   def self.run_daemon_mode(text, options)
-    pid_file = options[:pid_file] || RubyProgress::Daemon.default_pid_file
+    pid_file = resolve_pid_file(options, :daemon_name)
     FileUtils.mkdir_p(File.dirname(pid_file))
     File.write(pid_file, Process.pid.to_s)
     begin
@@ -134,9 +142,6 @@ module RippleCLI
       Signal.trap('TERM') { stop_requested = true }
       Signal.trap('HUP')  { stop_requested = true }
 
-      job_dir = RubyProgress::Daemon.job_dir_for_pid(pid_file)
-      job_thread = Thread.new { process_daemon_jobs_for_rippler(job_dir, rippler, options) }
-
       rippler.advance until stop_requested
     ensure
       RubyProgress::Utils.clear_line
@@ -179,51 +184,9 @@ module RippleCLI
       end
 
       # stop job thread and cleanup
-      job_thread&.kill
       FileUtils.rm_f(pid_file)
     end
   end
 
-  def self.process_daemon_jobs_for_rippler(job_dir, rippler, options)
-    RubyProgress::Daemon.process_jobs(job_dir) do |job|
-      jid = job['id'] || SecureRandom.uuid
-      log_path = begin
-        File.join(File.dirname(job_dir), "#{jid}.log")
-      rescue StandardError
-        nil
-      end
-
-      oc = RubyProgress::OutputCapture.new(
-        command: job['command'],
-        lines: options[:output_lines] || 3,
-        position: options[:output_position] || :above,
-        log_path: log_path
-      )
-      oc.start
-
-      rippler.instance_variable_set(:@output_capture, oc)
-      oc.wait
-      captured = oc.lines.join("\n")
-      exit_status = oc.exit_status
-      rippler.instance_variable_set(:@output_capture, nil)
-
-      success = exit_status.to_i.zero?
-      if job['message']
-        RubyProgress::Utils.display_completion(
-          job['message'],
-          success: success,
-          show_checkmark: job['checkmark'] || false,
-          output_stream: :stdout,
-          icons: { success: options[:success_icon], error: options[:error_icon] }
-        )
-      end
-
-      { 'exit_status' => exit_status, 'output' => captured, 'log_path' => log_path }
-    rescue StandardError
-      # ignore per-job errors; process_jobs will write result
-      nil
-    end
-  end
-
   # Options parsing moved to ripple_options.rb
 end

data/lib/ruby-progress/cli/ripple_options.rb

@@ -91,6 +91,10 @@ module RippleCLI
             options[:output] = :stdout
           end
 
+          opts.on('--stdout-live', 'Stream captured output to STDOUT as it arrives (non-blocking)') do
+            options[:stdout_live] = true
+          end
+
           opts.on('--quiet', 'Suppress all output') do
             options[:output] = :quiet
           end
@@ -102,8 +106,9 @@ module RippleCLI
             options[:daemon] = true
           end
 
-          opts.on('--no-detach', 'When used with --daemon: run background child but do not fully detach from the terminal') do
-            options[:no_detach] = true
+          opts.on('--daemon-as NAME', 'Run in daemon mode with custom name (creates /tmp/ruby-progress/NAME.pid)') do |name|
+            options[:daemon] = true
+            options[:daemon_name] = name
           end
 
           opts.on('--pid-file FILE', 'Write process ID to file (default: /tmp/ruby-progress/progress.pid)') do |file|
@@ -114,10 +119,20 @@ module RippleCLI
             options[:stop] = true
           end
 
+          opts.on('--stop-id NAME', 'Stop daemon by name (automatically implies --stop)') do |name|
+            options[:stop] = true
+            options[:stop_name] = name
+          end
+
           opts.on('--status', 'Show daemon status (running/not running)') do
             options[:status] = true
           end
 
+          opts.on('--status-id NAME', 'Show daemon status by name') do |name|
+            options[:status] = true
+            options[:status_name] = name
+          end
+
           opts.on('--stop-success MESSAGE', 'When stopping, show this success message') do |msg|
             options[:stop_success] = msg
           end
@@ -131,7 +146,7 @@ module RippleCLI
           opts.separator ''
           opts.separator 'Daemon notes:'
           opts.separator '  - Do not append &; prg detaches itself and returns immediately.'
-          opts.separator '  - Use --status/--stop with optional --pid-file to control it.'
+          opts.separator '  - Use --daemon-as NAME for named daemons, or --stop-id/--status-id for named control.'
 
           opts.separator ''
           opts.separator 'General:'

data/lib/ruby-progress/cli/twirl_cli.rb

@@ -26,7 +26,9 @@ module TwirlCLI
       )
       exit
     elsif options[:daemon]
-      PrgCLI.daemonize
+      # Background without detaching so spinner remains visible in current terminal
+      PrgCLI.backgroundize
+
       TwirlRunner.run_daemon_mode(options)
     elsif options[:command]
       TwirlRunner.run_with_command(options)

data/lib/ruby-progress/cli/twirl_options.rb

@@ -81,6 +81,10 @@ module TwirlCLI
           options[:stdout] = true
         end
 
+        opts.on('--stdout-live', 'Stream captured output to STDOUT as it arrives (non-blocking)') do
+          options[:stdout_live] = true
+        end
+
         opts.separator ''
         opts.separator 'Daemon Mode:'
 
@@ -88,10 +92,6 @@ module TwirlCLI
           options[:daemon] = true
         end
 
-        opts.on('--no-detach', 'When used with --daemon/--daemon-as: run background child but do not fully detach from the terminal') do
-          options[:no_detach] = true
-        end
-
         opts.on('--daemon-as NAME', 'Run in daemon mode with custom name (creates /tmp/ruby-progress/NAME.pid)') do |name|
           options[:daemon] = true
           options[:daemon_name] = name

data/lib/ruby-progress/cli/twirl_runner.rb

@@ -23,11 +23,12 @@ module TwirlRunner
       RubyProgress::Utils.hide_cursor
       spinner_thread = Thread.new { loop { spinner.animate } }
 
-      if $stdout.tty? && options[:stdout]
+      if $stdout.tty? && (options[:stdout] || options[:stdout_live])
         oc = RubyProgress::OutputCapture.new(
           command: options[:command],
           lines: options[:output_lines] || 3,
-          position: options[:output_position] || :above
+          position: options[:output_position] || :above,
+          stream: options[:stdout] || options[:stdout_live]
         )
         oc.start
 
@@ -103,40 +104,6 @@ module TwirlRunner
     begin
       RubyProgress::Utils.hide_cursor
 
-      # Start job processor thread for twirl
-      job_dir = RubyProgress::Daemon.job_dir_for_pid(pid_file)
-      job_thread = Thread.new do
-        RubyProgress::Daemon.process_jobs(job_dir) do |job|
-          oc = RubyProgress::OutputCapture.new(
-            command: job['command'],
-            lines: options[:output_lines] || 3,
-            position: options[:output_position] || :above
-          )
-          oc.start
-
-          spinner.instance_variable_set(:@output_capture, oc)
-          oc.wait
-          captured = oc.lines.join("\n")
-          exit_status = oc.exit_status
-          spinner.instance_variable_set(:@output_capture, nil)
-
-          success = exit_status.to_i.zero?
-          if job['message']
-            RubyProgress::Utils.display_completion(
-              job['message'],
-              success: success,
-              show_checkmark: job['checkmark'] || false,
-              output_stream: :stdout,
-              icons: { success: options[:success_icon], error: options[:error_icon] }
-            )
-          end
-
-          { 'exit_status' => exit_status, 'output' => captured }
-        rescue StandardError
-          # ignore
-        end
-      end
-
       spinner.animate until stop_requested
     ensure
       RubyProgress::Utils.clear_line
@@ -170,7 +137,6 @@ module TwirlRunner
         end
       end
 
-      job_thread&.kill
       FileUtils.rm_f(pid_file)
     end
   end

data/lib/ruby-progress/cli/worm_cli.rb

@@ -33,13 +33,8 @@ module WormCLI
       )
       exit
     elsif options[:daemon]
-      # Detach (or background without detaching) before starting daemon logic
-      # so the invoking shell/script continues immediately.
-      if options[:no_detach]
-        PrgCLI.backgroundize
-      else
-        PrgCLI.daemonize
-      end
+      # Background without detaching so worm remains visible in current terminal
+      PrgCLI.backgroundize
 
       run_daemon_mode(options)
     else
@@ -61,48 +56,6 @@ module WormCLI
     progress = RubyProgress::Worm.new(options)
 
     begin
-      # Start job processor thread for worm
-      job_dir = RubyProgress::Daemon.job_dir_for_pid(pid_file)
-      job_thread = Thread.new do
-        RubyProgress::Daemon.process_jobs(job_dir) do |job|
-          jid = job['id'] || SecureRandom.uuid
-          log_path = begin
-            File.join(File.dirname(job_dir), "#{jid}.log")
-          rescue StandardError
-            nil
-          end
-
-          oc = RubyProgress::OutputCapture.new(
-            command: job['command'],
-            lines: options[:output_lines] || 3,
-            position: options[:output_position] || :above,
-            log_path: log_path
-          )
-          oc.start
-
-          progress.instance_variable_set(:@output_capture, oc)
-          oc.wait
-          captured = oc.lines.join("\n")
-          exit_status = oc.exit_status
-          progress.instance_variable_set(:@output_capture, nil)
-
-          success = exit_status.to_i.zero?
-          if job['message']
-            RubyProgress::Utils.display_completion(
-              job['message'],
-              success: success,
-              show_checkmark: job['checkmark'] || false,
-              output_stream: :stdout,
-              icons: { success: options[:success_icon], error: options[:error_icon] }
-            )
-          end
-
-          { 'exit_status' => exit_status, 'output' => captured, 'log_path' => log_path }
-        rescue StandardError
-          # ignore per-job errors
-        end
-      end
-
       progress.run_daemon_mode(
         success_message: options[:success],
         show_checkmark: options[:checkmark],
@@ -110,7 +63,6 @@ module WormCLI
         icons: { success: options[:success_icon], error: options[:error_icon] }
       )
     ensure
-      job_thread&.kill
       FileUtils.rm_f(pid_file)
     end
   end