nanokvm 0.1.0

data/lib/nanokvm/cli.rb

@@ -0,0 +1,793 @@
+# frozen_string_literal: true
+
+require "thor"
+require "terminal-table"
+require "yaml"
+require "fileutils"
+require "net/http"
+require "json"
+
+module NanoKVM
+  class CLI < Thor
+    CONFIG_DIR = File.expand_path("~/.config/nanokvm")
+    CONFIG_FILE = File.join(CONFIG_DIR, "config.yml")
+
+    def self.exit_on_failure?
+      true
+    end
+
+    # Global options
+    class_option :debug, type: :boolean, desc: "Enable debug output"
+    class_option :secret_key, type: :string, desc: "Secret key for password encryption (default: nanokvm-sipeed-2024)"
+    class_option :host, type: :string, desc: "NanoKVM host (IP or hostname)"
+    class_option :username, type: :string, desc: "Username (default: admin)"
+    class_option :password, type: :string, desc: "Password (default: admin)"
+
+    desc "configure", "Configure default settings"
+    option :token, type: :string, desc: "Default token (optional)"
+    def configure
+      unless Dir.exist?(CONFIG_DIR)
+        FileUtils.mkdir_p(CONFIG_DIR)
+      end
+
+      # Load existing config
+      config = if File.exist?(CONFIG_FILE)
+                File.open(CONFIG_FILE) { |f| YAML.safe_load(f, symbolize_names: true) } rescue {}
+              else
+                {}
+              end
+
+      # Update with provided options
+      config[:host] = options[:host] if options[:host]
+      config[:username] = options[:username] if options[:username]
+      config[:password] = options[:password] if options[:password]
+      config[:token] = options[:token] if options[:token]
+      config[:secret_key] = options[:secret_key] if options[:secret_key]
+
+      # Save config
+      File.open(CONFIG_FILE, "w") { |f| f.write(config.to_yaml) }
+
+      # Update current configuration
+      NanoKVM.configure do |c|
+        c.default_host = config[:host]
+        c.default_username = config[:username]
+        c.default_password = config[:password]
+      end
+
+      puts "Configuration saved"
+    end
+
+    desc "info", "Get device information"
+    def info
+      display_as_table("NanoKVM Information", :get_device_info)
+    end
+
+    desc "power", "Press power button"
+    option :duration, type: :numeric, default: 800, desc: "Button press duration in ms (800=short, 8000=long)"
+    def power
+      client = authenticated_client
+      client.power_button(options[:duration])
+      puts "Power button pressed for #{options[:duration]}ms"
+    end
+
+    desc "reset", "Press reset button"
+    def reset
+      client = authenticated_client
+      client.reset_button
+      puts "Reset button pressed"
+    end
+
+    desc "leds", "Get LED status"
+    def leds
+      display_as_table("NanoKVM LEDs", :get_gpio_state)
+    end
+
+    desc "images", "List available images"
+    def images
+      client = create_client
+      ensure_authenticated(client)
+
+      begin
+        # Get available images
+        available = client.get_available_images["data"]["files"] rescue []
+        
+        # Get mounted image for comparison
+        mounted = begin
+          client.get_mounted_image["data"]["file"]
+        rescue
+          nil
+        end
+
+        rows = []
+        if available.nil?
+          puts "No images available"
+          return
+        end
+        
+        available.each do |image|
+          rows << [image, image == mounted ? "MOUNTED" : ""]
+        end
+
+        if rows.empty?
+          puts "No images available"
+          return
+        end
+
+        table = ::Terminal::Table.new(
+          title: "Available Images",
+          headings: ["Image Path", "Status"],
+          rows: rows
+        )
+
+        puts table
+      rescue NanoKVM::ApiError => e
+        puts "Error listing images: #{e.message}"
+        puts "This feature may not be available on your NanoKVM device/firmware."
+      end
+    end
+
+    desc "mount IMAGE_PATH", "Mount an image"
+    def mount(image_path)
+      client = authenticated_client
+      client.mount_image(image_path)
+      puts "Image #{image_path} mounted successfully"
+    end
+
+    desc "type TEXT", "Send text to the target"
+    def type(text)
+      client = authenticated_client
+      client.send_text(text)
+      puts "Text sent successfully"
+    end
+
+    desc "virtual", "Show virtual device status"
+    def virtual
+      display_as_table("Virtual Devices", :get_virtual_device_status)
+    end
+
+    desc "toggle DEVICE", "Toggle virtual device (network or disk)"
+    def toggle(device)
+      unless ["network", "disk"].include?(device)
+        puts "Error: Device must be 'network' or 'disk'"
+        return
+      end
+
+      client = authenticated_client
+      result = client.toggle_virtual_device(device)
+      state = result["data"]["on"]
+      
+      puts "#{device.capitalize} is now #{state ? 'ENABLED' : 'DISABLED'}"
+    end
+
+    desc "account", "Get account information"
+    def account
+      display_as_table("NanoKVM Account Information", :get_account_info)
+    end
+
+    desc "network", "Get network information"
+    def network
+      display_as_table("NanoKVM Network Information", :get_network_info)
+    end
+
+    desc "version", "Get application version"
+    def version
+      display_as_table("NanoKVM Application Version", :get_app_version)
+    end
+
+    desc "reboot", "Reboot the NanoKVM system"
+    def reboot
+      client = authenticated_client
+      puts "Rebooting NanoKVM system..."
+      client.system_reboot
+      puts "Reboot command sent successfully."
+      puts "Note: The device will be unavailable during the reboot process."
+    end
+
+    desc "reset-hdmi", "Reset HDMI subsystem"
+    def reset_hdmi
+      client = authenticated_client
+      puts "Resetting HDMI subsystem..."
+      client.reset_hdmi
+      puts "HDMI reset command sent successfully."
+    end
+
+    desc "reset-hid", "Reset HID (keyboard/mouse) subsystem"
+    def reset_hid
+      client = authenticated_client
+      puts "Resetting HID subsystem..."
+      client.reset_hid
+      puts "HID reset command sent successfully."
+    end
+
+    desc "is-password-updated", "Check if password has been updated from default"
+    def is_password_updated
+      client = authenticated_client
+      begin
+        response = client.is_password_updated["data"]
+        updated = response["updated"] == true
+        puts "Password status: #{updated ? 'Updated from default' : 'Still using default password'}"
+      rescue NanoKVM::ApiError => e
+        puts "Error checking password status: #{e.message}"
+        puts "This feature may not be available on your NanoKVM device/firmware."
+      end
+    end
+
+    desc "tailscale", "Check Tailscale extension status"
+    def tailscale
+      display_as_table("NanoKVM Tailscale Status", :get_tailscale_status)
+    end
+
+    desc "download-enabled", "Check if downloading images is enabled"
+    def download_enabled
+      client = authenticated_client
+      begin
+        response = client.is_download_image_enabled["data"]
+        enabled = response["enabled"] == true
+        puts "Image download: #{enabled ? 'ENABLED' : 'DISABLED'}"
+      rescue NanoKVM::ApiError => e
+        puts "Error checking image download status: #{e.message}"
+        puts "This feature may not be available on your NanoKVM device/firmware."
+      end
+    end
+
+    desc "download-status", "Check status of image download"
+    option :monitor, type: :boolean, desc: "Monitor until download completes"
+    option :interval, type: :numeric, default: 3, desc: "Refresh interval in seconds when monitoring"
+    option :timeout, type: :numeric, desc: "Stop monitoring after this many seconds"
+    def download_status
+      client = authenticated_client
+      begin
+        if options[:monitor]
+          show_download_progress(client, options[:interval], options[:timeout])
+        else
+          display_download_status(client)
+        end
+      rescue NanoKVM::ApiError => e
+        puts "Error checking image download status: #{e.message}"
+        puts "This feature may not be available on your NanoKVM device/firmware."
+      rescue Interrupt
+        puts "\nMonitoring stopped"
+      end
+    end
+
+    desc "download-image URL", "Download an image from URL"
+    def download_image(url)
+      client = authenticated_client
+      begin
+        puts "Starting download of #{url}..."
+        client.download_image(url)
+        puts "Download initiated successfully."
+        puts "Use 'nanokvm download-status' to check progress."
+      rescue NanoKVM::ApiError => e
+        puts "Error starting image download: #{e.message}"
+        puts "This feature may not be available on your NanoKVM device/firmware."
+      end
+    end
+
+    desc "hardware", "Get hardware information"
+    def hardware
+      display_as_table("NanoKVM Hardware Information", :get_hardware_info)
+    end
+    
+    desc "memory-limit", "Get or set memory limit"
+    option :enabled, type: :boolean, desc: "Enable or disable memory limit"
+    option :limit, type: :numeric, desc: "Memory limit in MB"
+    def memory_limit
+      client = authenticated_client
+      
+      if options[:enabled].nil? && options[:limit].nil?
+        # Get current setting
+        display_as_table("Memory Limit Settings", :get_memory_limit)
+      else
+        # Set new values
+        unless options[:enabled] && options[:limit]
+          puts "Error: Both --enabled and --limit are required to set memory limit"
+          return
+        end
+        
+        begin
+          client.set_memory_limit(options[:enabled], options[:limit])
+          puts "Memory limit updated successfully"
+        rescue NanoKVM::ApiError => e
+          puts "Error setting memory limit: #{e.message}"
+          puts "This feature may not be available on your NanoKVM device/firmware."
+        end
+      end
+    end
+    
+    desc "oled", "Get or set OLED settings"
+    option :sleep, type: :numeric, desc: "Sleep timeout in seconds"
+    def oled
+      client = authenticated_client
+      
+      if options[:sleep].nil?
+        # Get current setting
+        display_as_table("OLED Settings", :get_oled_info)
+      else
+        # Set new sleep timeout
+        begin
+          client.set_oled_sleep(options[:sleep])
+          puts "OLED sleep timeout updated to #{options[:sleep]} seconds"
+        rescue NanoKVM::ApiError => e
+          puts "Error setting OLED sleep timeout: #{e.message}"
+          puts "This feature may not be available on your NanoKVM device/firmware."
+        end
+      end
+    end
+    
+    desc "ssh-status", "Get SSH server status"
+    def ssh_status
+      display_as_table("SSH Server Status", :get_ssh_status)
+    end
+    
+    desc "cdrom", "Get CD-ROM information"
+    def cdrom
+      display_as_table("CD-ROM Information", :get_cdrom_info)
+    end
+    
+    desc "hid-mode", "Get or set HID mode"
+    option :mode, type: :string, desc: "HID mode (usb or ps2)"
+    def hid_mode
+      client = authenticated_client
+      
+      if options[:mode].nil?
+        # Get current setting
+        display_as_table("HID Mode", :get_hid_mode)
+      else
+        # Set new mode
+        unless ["usb", "ps2"].include?(options[:mode].downcase)
+          puts "Error: Mode must be 'usb' or 'ps2'"
+          return
+        end
+        
+        begin
+          client.set_hid_mode(options[:mode].downcase)
+          puts "HID mode updated to #{options[:mode]}"
+          puts "Note: This change requires a reboot to take effect"
+        rescue NanoKVM::ApiError => e
+          puts "Error setting HID mode: #{e.message}"
+          puts "This feature may not be available on your NanoKVM device/firmware."
+        end
+      end
+    end
+
+    desc "script", "Get script information"
+    def script
+      display_as_table("Script Information", :get_script_info)
+    end
+    
+    desc "mdns", "Get mDNS status"
+    def mdns
+      display_as_table("mDNS Status", :get_mdns_status)
+    end
+    
+    desc "wol-mac", "Get Wake-on-LAN MAC address"
+    def wol_mac
+      display_as_table("Wake-on-LAN MAC Address", :get_wol_mac)
+    end
+    
+    desc "preview", "Get or set preview state"
+    option :enable, type: :boolean, desc: "Enable or disable preview"
+    def preview
+      client = authenticated_client
+      
+      if options[:enable].nil?
+        # Get current setting
+        display_as_table("Preview State", :get_preview_state)
+      else
+        # Set new state
+        begin
+          client.set_preview_state(options[:enable])
+          puts "Preview #{options[:enable] ? 'enabled' : 'disabled'}"
+        rescue NanoKVM::ApiError => e
+          puts "Error setting preview state: #{e.message}"
+          puts "This feature may not be available on your NanoKVM device/firmware."
+        end
+      end
+    end
+
+    desc "test", "Test connection to NanoKVM"
+    def test
+      puts "Testing connection to NanoKVM..."
+      
+      client = create_client
+      client.debug = true
+      
+      begin
+        puts "Connecting to #{client.host}..."
+        # Try a simple HTTP GET to see if the server is up
+        uri = URI.parse("http://#{client.host}")
+        response = Net::HTTP.get_response(uri)
+        puts "Server responded with status: #{response.code}"
+        
+        if response.code == "200"
+          puts "Connection successful, attempting authentication..."
+          ensure_authenticated(client)
+          puts "Authentication successful!"
+        else
+          puts "Server responded, but with an unexpected status code"
+        end
+      rescue => e
+        puts "Connection failed: #{e.message}"
+      end
+    end
+
+    desc "interfaces", "Get status of HID, ETH, and HDMI interfaces"
+    def interfaces
+      display_as_table("Interface Status", :get_interface_status)
+    end
+
+    private
+
+    def load_config
+      return {} unless File.exist?(CONFIG_FILE)
+      
+      YAML.safe_load(File.read(CONFIG_FILE), symbolize_names: true) rescue {}
+    end
+
+    def create_client
+      # Load saved config
+      config = load_config
+
+      # Command-line options override saved config
+      host = options[:host] || config[:host] || NanoKVM.configuration.default_host
+      username = options[:username] || config[:username] || NanoKVM.configuration.default_username
+      password = options[:password] || config[:password] || NanoKVM.configuration.default_password
+      token = config[:token]
+      debug = options[:debug]
+      secret_key = options[:secret_key] || config[:secret_key]
+
+      unless host
+        puts "Error: Host is required. Use --host or configure a default host with 'nanokvm configure'"
+        exit 1
+      end
+
+      NanoKVM::Client.new(
+        host: host,
+        username: username,
+        password: password,
+        token: token,
+        debug: debug,
+        secret_key: secret_key
+      )
+    end
+
+    def ensure_authenticated(client)
+      # Try using existing token
+      return if client.token
+
+      begin
+        client.login
+      rescue => e
+        puts "Authentication failed: #{e.message}"
+        puts "\nTroubleshooting tips:"
+        puts "1. Check your username and password"
+        puts "2. If you recently changed your password, run 'nanokvm configure'"
+        puts "3. Try different encryption key with --secret-key option"
+        puts "4. Check if your device has connectivity issues"
+        exit 1
+      end
+    end
+    
+    # Helper method to get an authenticated client
+    def authenticated_client
+      client = create_client
+      ensure_authenticated(client)
+      client
+    end
+    
+    # Helper method to display API data as a table
+    def display_as_table(title, data_method, *args)
+      client = authenticated_client
+      
+      begin
+        data = client.send(data_method, *args)["data"]
+        
+        rows = []
+        data.each do |key, value|
+          value_str = case value
+                     when Hash, Array
+                       value.to_json
+                     else
+                       value.to_s
+                     end
+          rows << [key, value_str]
+        end
+
+        table = ::Terminal::Table.new(
+          title: title,
+          rows: rows
+        )
+
+        puts table
+      rescue NanoKVM::ApiError => e
+        puts "Error getting #{title.downcase}: #{e.message}"
+        puts "This feature may not be available on your NanoKVM device/firmware."
+      end
+    end
+
+    # Store previous download info for estimation
+    @previous_download_info = nil
+
+    # Get file size from URL using a HEAD request
+    def get_file_size_from_url(url)
+      begin
+        uri = URI.parse(url)
+        response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+          http.request_head(uri.path)
+        end
+        
+        if response['content-length']
+          return response['content-length'].to_i
+        end
+      rescue => e
+        puts "Warning: Failed to get file size from URL: #{e.message}" if @debug
+      end
+      nil
+    end
+
+    def display_download_status(client)
+      status = client.get_download_image_status["data"]
+      
+      rows = []
+      status.each do |key, value|
+        value_str = if value.is_a?(Hash)
+                     value.to_json
+                   else
+                     value.to_s
+                   end
+        rows << [key, value_str]
+      end
+
+      # Add time estimate if download in progress
+      if status["status"] == "in_progress"
+        # Extract progress from percentage string if needed
+        progress = if status["percentage"].to_s.include?("%")
+                     status["percentage"].to_s.gsub("%", "").strip.to_f
+                   else
+                     status["progress"].to_f
+                   end
+
+        # Try to get total file size if available or fetch from URL
+        total_size = status["size"].to_i
+        if total_size == 0 && status["file"].to_s.start_with?("http")
+          total_size = get_file_size_from_url(status["file"])
+        end
+        
+        # Check if we have size information
+        if total_size.to_i > 0
+          downloaded = (total_size * (progress / 100.0)).to_i
+          
+          # Add download size info
+          rows << ["downloaded", "#{downloaded} bytes (#{(downloaded / 1024.0 / 1024.0).round(2)} MB)"]
+          rows << ["total_size", "#{total_size} bytes (#{(total_size / 1024.0 / 1024.0).round(2)} MB)"]
+          
+          # If we have enough information to calculate
+          if downloaded > 0 && progress > 0
+            start_time = status["start_time"].to_i rescue 0
+            
+            if start_time > 0
+              elapsed_time = Time.now.to_i - start_time
+            else
+              # Use a default value if start_time is not available
+              elapsed_time = 60  # Assume 1 minute has passed for a basic estimate
+            end
+            
+            if elapsed_time > 0
+              download_rate = downloaded / elapsed_time  # bytes per second
+              remaining_bytes = total_size - downloaded
+              remaining_seconds = (download_rate > 0) ? (remaining_bytes / download_rate) : 0
+              
+              # Format time remaining
+              if remaining_seconds < 60
+                time_estimate = "#{remaining_seconds.to_i}s"
+              elsif remaining_seconds < 3600
+                time_estimate = "#{(remaining_seconds/60).to_i}m #{(remaining_seconds%60).to_i}s"
+              else
+                time_estimate = "#{(remaining_seconds/3600).to_i}h #{(remaining_seconds%3600/60).to_i}m"
+              end
+              
+              rows << ["estimated_time_remaining", time_estimate]
+              rows << ["download_speed", "#{download_rate.round(2)} bytes/s (#{(download_rate / 1024).round(2)} KB/s)"]
+            end
+          end
+        elsif @previous_download_info && progress > @previous_download_info[:progress]
+          # Calculate speed based solely on percentage change
+          current_time = Time.now.to_i
+          prev_time = @previous_download_info[:time]
+          prev_progress = @previous_download_info[:progress]
+          time_diff = current_time - prev_time
+          progress_diff = progress - prev_progress
+          
+          if time_diff > 0 && progress_diff > 0
+            # Estimate remaining time based on progress rate
+            progress_per_second = progress_diff / time_diff.to_f
+            remaining_progress = 100.0 - progress
+            remaining_seconds = (progress_per_second > 0) ? (remaining_progress / progress_per_second).to_i : 0
+            
+            # Format time remaining
+            if remaining_seconds < 60
+              time_estimate = "#{remaining_seconds}s"
+            elsif remaining_seconds < 3600
+              time_estimate = "#{(remaining_seconds/60).to_i}m #{(remaining_seconds%60).to_i}s"
+            else
+              time_estimate = "#{(remaining_seconds/3600).to_i}h #{(remaining_seconds%3600/60).to_i}m"
+            end
+            
+            rows << ["estimated_time_remaining", time_estimate]
+            rows << ["download_rate", "#{progress_diff.round(2)}% per #{time_diff}s"]
+          end
+        end
+        
+        # Store current info for next calculation
+        @previous_download_info = {
+          time: Time.now.to_i,
+          progress: progress
+        }
+        
+        # Only store downloaded bytes if we have size information to calculate it correctly
+        if total_size.to_i > 0
+          @previous_download_info[:downloaded] = (total_size * (progress / 100.0)).to_i
+        end
+      else
+        # Reset tracking if not in progress
+        @previous_download_info = nil
+      end
+
+      table = ::Terminal::Table.new(
+        title: "Image Download Status",
+        rows: rows
+      )
+
+      puts table
+    end
+    
+    def show_download_progress(client, interval = 3, timeout = nil)
+      monitor_start_time = Time.now.to_i
+      last_progress = nil
+      download_info = {}
+      line_count = 0
+      
+      loop do
+        # Check timeout if specified
+        current_time = Time.now.to_i
+        if timeout && (current_time - monitor_start_time >= timeout)
+          puts "\nMonitoring stopped after #{timeout} seconds timeout"
+          break
+        end
+        
+        # Clear previous output
+        if line_count > 0
+          print "\033[#{line_count}A\033[J" # Move cursor up and clear to end of screen
+        end
+        
+        status = client.get_download_image_status["data"]
+        current_time = Time.now.to_i
+        
+        # Extract progress from percentage string if needed
+        progress = if status["percentage"].to_s.include?("%")
+                     status["percentage"].to_s.gsub("%", "").strip.to_f
+                   else
+                     status["progress"].to_f
+                   end
+        
+        # Try to get total file size
+        total_size = status["size"].to_i
+        if total_size == 0 && status["file"].to_s.start_with?("http")
+          total_size = get_file_size_from_url(status["file"])
+        end
+        
+        # Update progress and info
+        if status["status"] == "in_progress"
+          # Setup the download info
+          download_info[:file] = status["file"]
+          download_info[:status] = status["status"]
+          download_info[:progress] = progress
+          
+          # Calculate additional download information
+          if total_size.to_i > 0
+            downloaded = (total_size * (progress / 100.0)).to_i
+            download_info[:downloaded] = "#{downloaded} bytes (#{(downloaded / 1024.0 / 1024.0).round(2)} MB)"
+            download_info[:total_size] = "#{total_size} bytes (#{(total_size / 1024.0 / 1024.0).round(2)} MB)"
+            
+            if @previous_download_info && @previous_download_info[:downloaded]
+              prev_time = @previous_download_info[:time]
+              prev_downloaded = @previous_download_info[:downloaded] || 0
+              time_diff = current_time - prev_time
+              bytes_diff = downloaded - prev_downloaded
+              
+              if time_diff > 0 && bytes_diff > 0
+                download_rate = bytes_diff / time_diff.to_f  # bytes per second
+                download_info[:speed] = "#{(download_rate / 1024).round(2)} KB/s"
+                
+                remaining_bytes = total_size - downloaded
+                remaining_seconds = (download_rate > 0) ? (remaining_bytes / download_rate).to_i : 0
+                download_info[:time_remaining] = format_time_remaining(remaining_seconds)
+              end
+            end
+            
+            # Store current info for next calculation
+            @previous_download_info = {
+              time: current_time,
+              downloaded: downloaded,
+              progress: progress
+            }
+          elsif @previous_download_info && progress > @previous_download_info[:progress]
+            # Calculate based on percentage change
+            prev_time = @previous_download_info[:time]
+            prev_progress = @previous_download_info[:progress]
+            time_diff = current_time - prev_time
+            progress_diff = progress - prev_progress
+            
+            if time_diff > 0 && progress_diff > 0
+              progress_per_second = progress_diff / time_diff.to_f
+              download_info[:speed] = "#{progress_diff.round(2)}% per second"
+              remaining_progress = 100.0 - progress
+              remaining_seconds = (progress_per_second > 0) ? (remaining_progress / progress_per_second).to_i : 0
+              download_info[:time_remaining] = format_time_remaining(remaining_seconds)
+            end
+            
+            @previous_download_info = {
+              time: current_time,
+              progress: progress
+            }
+          else
+            @previous_download_info = {
+              time: current_time,
+              progress: progress
+            }
+          end
+          
+          # Display a nice progress bar
+          progress_width = 50
+          completed = (progress_width * progress / 100).to_i
+          bar = "[" + "#" * completed + " " * (progress_width - completed) + "]"
+          
+          # Prepare output lines
+          output = []
+          output << "File: #{download_info[:file]}"
+          output << "Progress: #{bar} #{progress.round(2)}%"
+          output << "Status: #{download_info[:status]}"
+          output << "Downloaded: #{download_info[:downloaded]}" if download_info[:downloaded]
+          output << "Total size: #{download_info[:total_size]}" if download_info[:total_size]
+          output << "Speed: #{download_info[:speed]}" if download_info[:speed]
+          output << "ETA: #{download_info[:time_remaining]}" if download_info[:time_remaining]
+          
+          if timeout
+            elapsed = current_time - monitor_start_time
+            remaining = timeout - elapsed
+            output << "Timeout in: #{remaining}s"
+          end
+          
+          output << "\nPress Ctrl+C to stop monitoring"
+          
+          # Print output and count lines for next update
+          puts output
+          line_count = output.size
+          
+          # If download is complete, break the loop
+          if status["status"] != "in_progress"
+            break
+          end
+        else
+          puts "Download #{status['status']}"
+          break
+        end
+        
+        sleep interval
+      end
+      
+      puts "\nDownload #{client.get_download_image_status["data"]["status"]}"
+    end
+    
+    def format_time_remaining(seconds)
+      if seconds < 60
+        "#{seconds}s"
+      elsif seconds < 3600
+        "#{(seconds/60).to_i}m #{(seconds%60).to_i}s"
+      else
+        "#{(seconds/3600).to_i}h #{(seconds%3600/60).to_i}m"
+      end
+    end
+  end
+end