htb 0.1.0

data/lib/htb/cli/challenges.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module HTB
+  module CLI
+    class Challenges < Thor
+      def self.exit_on_failure?
+        true
+      end
+
+      desc "list", "List all challenges"
+      option :retired, type: :boolean, desc: "Show retired challenges"
+      def list
+        client = CLI.client
+
+        data = CLI.spinner("Fetching challenges...") do
+          if options[:retired]
+            client.challenges.retired
+          else
+            client.challenges.list
+          end
+        end
+
+        if data && data["challenges"]
+          rows = data["challenges"].map do |c|
+            [
+              c["id"],
+              c["name"],
+              c["category_name"] || c["category"] || "N/A",
+              c["difficulty"] || "N/A",
+              c["solves"] || 0,
+              c["points"] || 0
+            ]
+          end
+
+          puts CLI.pastel.bold("\nChallenges:")
+          CLI.print_table(
+            ["ID", "Name", "Category", "Difficulty", "Solves", "Points"],
+            rows
+          )
+          puts "\nTotal: #{rows.size} challenges"
+        else
+          CLI.print_info("No challenges found")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "info CHALLENGE_ID", "Show challenge details"
+      def info(challenge_id)
+        client = CLI.client
+        data = CLI.spinner("Fetching challenge...") { client.challenges.info(challenge_id) }
+
+        if data && data["challenge"]
+          c = data["challenge"]
+          puts CLI.pastel.bold("\n=== #{c['name']} ===")
+          CLI.print_table(
+            ["Field", "Value"],
+            [
+              ["ID", c["id"]],
+              ["Name", c["name"]],
+              ["Category", c["category_name"] || c["category"]],
+              ["Difficulty", c["difficulty"]],
+              ["Points", c["points"]],
+              ["Solves", c["solves"]],
+              ["Rating", "#{c['stars']}/5.0"],
+              ["Released", c["release_date"]],
+              ["Retired", c["retired"] ? "Yes" : "No"]
+            ]
+          )
+
+          if c["description"]
+            puts CLI.pastel.bold("\nDescription:")
+            puts "  #{c['description']}"
+          end
+
+          if c["maker"]
+            puts CLI.pastel.bold("\nCreator:")
+            puts "  #{c['maker']['name']}"
+          end
+        else
+          CLI.print_error("Challenge not found")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "start CHALLENGE_ID", "Start a challenge"
+      def start(challenge_id)
+        client = CLI.client
+        result = CLI.spinner("Starting challenge...") { client.challenges.start(challenge_id) }
+
+        if result && result["success"]
+          CLI.print_success("Challenge started!")
+          if result["ip"] || result["port"]
+            puts "  Connection: #{result['ip']}:#{result['port']}"
+          end
+        else
+          CLI.print_info(result["message"] || "Start request sent")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "stop CHALLENGE_ID", "Stop a challenge"
+      def stop(challenge_id)
+        client = CLI.client
+        result = CLI.spinner("Stopping challenge...") { client.challenges.stop(challenge_id) }
+
+        if result && result["success"]
+          CLI.print_success("Challenge stopped!")
+        else
+          CLI.print_info(result["message"] || "Stop request sent")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "spawn CHALLENGE_ID", "Spawn a challenge instance"
+      def spawn(challenge_id)
+        client = CLI.client
+        result = CLI.spinner("Spawning challenge...") { client.challenges.spawn(challenge_id) }
+
+        if result
+          CLI.print_success("Challenge instance spawning!")
+          CLI.print_info(result["message"]) if result["message"]
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "own CHALLENGE_ID --flag FLAG", "Submit a flag"
+      option :flag, required: true, desc: "The flag to submit"
+      option :difficulty, type: :numeric, default: 50, desc: "Difficulty rating"
+      def own(challenge_id)
+        client = CLI.client
+        result = CLI.spinner("Submitting flag...") do
+          client.challenges.own(
+            challenge_id: challenge_id.to_i,
+            flag: options[:flag],
+            difficulty: options[:difficulty]
+          )
+        end
+
+        if result && result["success"]
+          CLI.print_success("Flag accepted! #{result['message']}")
+        else
+          CLI.print_error(result["message"] || "Flag rejected")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "categories", "List challenge categories"
+      def categories
+        client = CLI.client
+        data = CLI.spinner("Fetching categories...") { client.challenges.categories }
+
+        if data && data["info"]
+          puts CLI.pastel.bold("\nChallenge Categories:")
+          data["info"].each do |cat|
+            puts "  #{CLI.pastel.cyan(cat['name'])} (#{cat['challenges_count']} challenges)"
+          end
+        else
+          CLI.print_info("No categories found")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "active", "Show active challenge"
+      def active
+        client = CLI.client
+        data = CLI.spinner("Fetching active challenge...") { client.challenges.active }
+
+        if data && data["info"]
+          info = data["info"]
+          puts CLI.pastel.bold("\n=== Active Challenge ===")
+          CLI.print_table(
+            ["Field", "Value"],
+            [
+              ["Name", info["name"]],
+              ["Category", info["category_name"] || info["category"]],
+              ["IP", info["ip"] || "N/A"],
+              ["Port", info["port"] || "N/A"]
+            ]
+          )
+        else
+          CLI.print_info("No active challenge")
+        end
+      rescue HTB::Error => e
+        CLI.print_info("No active challenge")
+      end
+    end
+  end
+end

data/lib/htb/cli/machines.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module HTB
+  module CLI
+    class Machines < Thor
+      def self.exit_on_failure?
+        true
+      end
+
+      desc "list", "List all active machines"
+      option :retired, type: :boolean, desc: "Show retired machines instead"
+      option :sp, type: :boolean, desc: "Show Starting Point machines"
+      def list
+        client = CLI.client
+
+        machines = CLI.spinner("Fetching machines...") do
+          if options[:retired]
+            client.machines.retired
+          elsif options[:sp]
+            client.machines.starting_point
+          else
+            client.machines.list
+          end
+        end
+
+        if machines && machines["info"]
+          rows = machines["info"].map do |m|
+            difficulty = m["difficultyText"] || m["difficulty"] || "N/A"
+            os = m["os"] || "N/A"
+            [
+              m["id"],
+              m["name"],
+              os,
+              difficulty,
+              m["user_owns_count"] || 0,
+              m["root_owns_count"] || 0,
+              m["release"] || "N/A"
+            ]
+          end
+
+          puts CLI.pastel.bold("\nMachines:")
+          CLI.print_table(
+            ["ID", "Name", "OS", "Difficulty", "User Owns", "Root Owns", "Released"],
+            rows
+          )
+          puts "\nTotal: #{rows.size} machines"
+        else
+          CLI.print_info("No machines found")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "info MACHINE", "Show machine details (by ID or name)"
+      def info(machine)
+        client = CLI.client
+        data = CLI.spinner("Fetching machine info...") { client.machines.profile(machine) }
+
+        if data && data["info"]
+          m = data["info"]
+          puts CLI.pastel.bold("\n=== #{m['name']} ===")
+          CLI.print_table(
+            ["Field", "Value"],
+            [
+              ["ID", m["id"]],
+              ["Name", m["name"]],
+              ["OS", m["os"]],
+              ["Difficulty", m["difficultyText"] || m["difficulty"]],
+              ["Points", m["points"]],
+              ["User Owns", m["user_owns_count"]],
+              ["Root Owns", m["root_owns_count"]],
+              ["Rating", "#{m['stars']}/5.0"],
+              ["Released", m["release"]],
+              ["Retired", m["retired"] ? "Yes" : "No"],
+              ["Free", m["free"] ? "Yes" : "No"]
+            ]
+          )
+
+          if m["ip"]
+            puts CLI.pastel.bold("\nConnection:")
+            puts "  IP: #{CLI.pastel.green(m['ip'])}"
+          end
+
+          if m["maker"]
+            puts CLI.pastel.bold("\nCreator:")
+            puts "  #{m['maker']['name']}"
+          end
+        else
+          CLI.print_error("Machine not found")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "active", "Show currently active machine"
+      def active
+        client = CLI.client
+        data = CLI.spinner("Fetching active machine...") { client.machines.active }
+
+        if data && data["info"]
+          m = data["info"]
+          puts CLI.pastel.bold("\n=== Active Machine ===")
+          CLI.print_table(
+            ["Field", "Value"],
+            [
+              ["Name", m["name"]],
+              ["IP", m["ip"] || "N/A"],
+              ["OS", m["os"]],
+              ["Difficulty", m["difficultyText"] || m["difficulty"]]
+            ]
+          )
+        else
+          CLI.print_info("No active machine")
+        end
+      rescue HTB::Error => e
+        CLI.print_info("No active machine")
+      end
+
+      desc "play MACHINE_ID", "Start playing a machine (free VPN)"
+      def play(machine_id)
+        client = CLI.client
+        result = CLI.spinner("Starting machine...") { client.machines.play(machine_id) }
+
+        if result && result["success"]
+          CLI.print_success("Machine started successfully!")
+        else
+          CLI.print_error(result["message"] || "Failed to start machine")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "stop", "Stop current machine"
+      def stop
+        client = CLI.client
+        result = CLI.spinner("Stopping machine...") { client.machines.stop }
+
+        if result && result["success"]
+          CLI.print_success("Machine stopped!")
+        else
+          CLI.print_error(result["message"] || "Failed to stop machine")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "own MACHINE_ID --flag FLAG", "Submit a flag for ownership"
+      option :flag, required: true, desc: "The flag to submit"
+      option :type, type: :string, enum: %w[user root auto], default: "auto", desc: "Flag type: user, root, or auto (default)"
+      option :difficulty, type: :numeric, default: 50, desc: "Difficulty rating (10-100)"
+      def own(machine_id)
+        client = CLI.client
+        flag_type = options[:type]
+
+        result = CLI.spinner("Submitting #{flag_type} flag...") do
+          case flag_type
+          when "user"
+            client.machines.own_user(machine_id.to_i, flag: options[:flag], difficulty: options[:difficulty])
+          when "root"
+            client.machines.own_root(machine_id.to_i, flag: options[:flag], difficulty: options[:difficulty])
+          else
+            client.machines.own(machine_id: machine_id.to_i, flag: options[:flag], difficulty: options[:difficulty])
+          end
+        end
+
+        if result && result["success"]
+          CLI.print_success("Flag accepted! #{result['message']}")
+        else
+          CLI.print_error(result["message"] || "Flag rejected")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "search QUERY", "Search for machines"
+      def search(query)
+        client = CLI.client
+        results = CLI.spinner("Searching...") { client.machines.search(query) }
+
+        if results && results["machines"]
+          rows = results["machines"].map do |m|
+            [m["id"], m["name"], m["os"], m["difficulty"]]
+          end
+          CLI.print_table(["ID", "Name", "OS", "Difficulty"], rows)
+        else
+          CLI.print_info("No results found")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "recommended", "Show recommended machines"
+      def recommended
+        client = CLI.client
+        data = CLI.spinner("Fetching recommendations...") { client.machines.recommended }
+
+        if data && data["info"]
+          rows = data["info"].map do |m|
+            [m["id"], m["name"], m["os"], m["difficultyText"] || m["difficulty"]]
+          end
+          puts CLI.pastel.bold("\nRecommended Machines:")
+          CLI.print_table(["ID", "Name", "OS", "Difficulty"], rows)
+        else
+          CLI.print_info("No recommendations available")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+    end
+  end
+end

data/lib/htb/cli/main.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module HTB
+  module CLI
+    class Main < Thor
+      def self.exit_on_failure?
+        true
+      end
+
+      desc "machines SUBCOMMAND", "Manage machines"
+      subcommand "machines", Machines
+
+      desc "vm SUBCOMMAND", "Manage VMs (spawn, terminate, reset)"
+      subcommand "vm", VM
+
+      desc "users SUBCOMMAND", "User profiles and info"
+      subcommand "users", Users
+
+      desc "challenges SUBCOMMAND", "Manage challenges"
+      subcommand "challenges", Challenges
+
+      desc "vpn SUBCOMMAND", "VPN and lab management"
+      subcommand "vpn", VPN
+
+      desc "spawn MACHINE_ID", "Spawn a machine (shortcut for vm spawn)"
+      def spawn(machine_id)
+        invoke "vm:spawn", [machine_id]
+      end
+
+      desc "terminate MACHINE_ID", "Terminate a machine (shortcut for vm terminate)"
+      def terminate(machine_id)
+        invoke "vm:terminate", [machine_id]
+      end
+
+      desc "status", "Show current VM and VPN status"
+      def status
+        client = CLI.client
+
+        puts CLI.pastel.bold("\n=== VM Status ===")
+        begin
+          vm_status = CLI.spinner("Fetching VM status...") { client.vm.active }
+          if vm_status && vm_status["info"]
+            info = vm_status["info"]
+            CLI.print_table(
+              ["Field", "Value"],
+              [
+                ["Machine", info["name"] || "N/A"],
+                ["IP", info["ip"] || "N/A"],
+                ["Type", info["type"] || "N/A"],
+                ["Expires", info["expires_at"] || "N/A"]
+              ]
+            )
+          else
+            CLI.print_info("No active VM")
+          end
+        rescue HTB::Error => e
+          CLI.print_info("No active VM")
+        end
+
+        puts CLI.pastel.bold("\n=== VPN Status ===")
+        begin
+          vpn_status = CLI.spinner("Fetching VPN status...") { client.vpn.status }
+          if vpn_status && vpn_status["data"]
+            data = vpn_status["data"]
+            CLI.print_table(
+              ["Field", "Value"],
+              [
+                ["Connected", data["connection"] ? "Yes" : "No"],
+                ["Server", data["server"] || "N/A"],
+                ["IP", data["ip"] || "N/A"]
+              ]
+            )
+          else
+            CLI.print_info("VPN status unavailable")
+          end
+        rescue HTB::Error => e
+          CLI.print_error(e.message)
+        end
+      end
+
+      desc "me", "Show current user info"
+      def me
+        client = CLI.client
+        user = CLI.spinner("Fetching profile...") { client.users.me }
+
+        if user && user["info"]
+          info = user["info"]
+          puts CLI.pastel.bold("\n=== Your Profile ===")
+          CLI.print_table(
+            ["Field", "Value"],
+            [
+              ["Username", info["name"] || "N/A"],
+              ["ID", info["id"] || "N/A"],
+              ["Rank", info["rank"] || "N/A"],
+              ["Points", info["points"] || "N/A"],
+              ["User Owns", info["user_owns"] || 0],
+              ["Root Owns", info["root_owns"] || 0],
+              ["Respect", info["respects"] || 0]
+            ]
+          )
+        else
+          CLI.print_error("Could not fetch profile")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "version", "Show version"
+      def version
+        puts "htb #{HTB::VERSION}"
+      end
+
+      desc "login", "Configure API token"
+      def login
+        puts CLI.pastel.bold("HTB Login")
+        puts ""
+        puts "To get your API token:"
+        puts "  1. Go to #{CLI.pastel.cyan(TOKEN_URL)}"
+        puts "  2. Scroll down to 'App Tokens'"
+        puts "  3. Create a new token or copy an existing one"
+        puts ""
+
+        token = CLI.prompt.mask("Paste your API token:")
+
+        if token && !token.strip.empty?
+          token = token.strip
+          print "Validating token... "
+          begin
+            test_client = HTB::Client.new(api_token: token)
+            user = test_client.users.me
+            puts CLI.pastel.green("valid!")
+
+            HTB::Config.api_token = token
+            CLI.reset_client!
+
+            puts ""
+            CLI.print_success("Token saved to #{HTB::Config.config_file}")
+
+            if user && user["info"]
+              puts ""
+              puts "Welcome, #{CLI.pastel.bold(user['info']['name'])}!"
+              puts "Rank: #{user['info']['rank']}"
+            end
+          rescue HTB::AuthenticationError
+            puts CLI.pastel.red("invalid!")
+            CLI.print_error("The token appears to be invalid. Please check and try again.")
+            exit 1
+          rescue StandardError => e
+            puts CLI.pastel.red("error!")
+            CLI.print_error("Could not validate token: #{e.message}")
+            exit 1
+          end
+        else
+          CLI.print_error("No token provided.")
+          exit 1
+        end
+      end
+
+      desc "logout", "Remove saved API token"
+      def logout
+        if HTB::Config.api_token
+          if CLI.prompt.yes?("Remove saved API token from #{HTB::Config.config_file}?")
+            HTB::Config.clear!
+            CLI.reset_client!
+            CLI.print_success("Logged out. Token removed.")
+          else
+            CLI.print_info("Cancelled.")
+          end
+        else
+          CLI.print_info("No saved token found.")
+        end
+      end
+
+      desc "config", "Show current configuration"
+      def config
+        puts CLI.pastel.bold("\n=== HTB Configuration ===")
+        puts ""
+        puts "Config file: #{HTB::Config.config_file}"
+
+        if File.exist?(HTB::Config.config_file)
+          puts "File exists: #{CLI.pastel.green('Yes')}"
+        else
+          puts "File exists: #{CLI.pastel.yellow('No')}"
+        end
+
+        token = HTB::Config.api_token
+        if token
+          # Show masked token
+          masked = token.length > 20 ? "#{token[0..10]}...#{token[-10..]}" : "***"
+          source = ENV["HTB_API_TOKEN"] ? "environment variable" : "config file"
+          puts "Token: #{CLI.pastel.green(masked)} (from #{source})"
+        else
+          puts "Token: #{CLI.pastel.red('Not configured')}"
+          puts ""
+          puts "Run #{CLI.pastel.cyan('htb login')} to configure."
+        end
+      end
+
+      map %w[-v --version] => :version
+    end
+  end
+end