htb 0.1.0

data/lib/htb/cli/users.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module HTB
+  module CLI
+    class Users < Thor
+      def self.exit_on_failure?
+        true
+      end
+
+      desc "me", "Show your profile"
+      def me
+        client = CLI.client
+        data = CLI.spinner("Fetching profile...") { client.users.me }
+
+        if data && data["info"]
+          info = data["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"],
+              ["Ranking", info["ranking"] || "N/A"],
+              ["Points", info["points"] || 0],
+              ["User Owns", info["user_owns"] || 0],
+              ["Root Owns", info["root_owns"] || 0],
+              ["Challenge Owns", info["challenge_owns"] || 0],
+              ["Respect", info["respects"] || 0],
+              ["Country", info["country_name"] || "N/A"]
+            ]
+          )
+        else
+          CLI.print_error("Could not fetch profile")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "info USER_ID", "Show user profile by ID"
+      def info(user_id)
+        client = CLI.client
+        data = CLI.spinner("Fetching user...") { client.users.profile(user_id) }
+
+        if data && data["profile"]
+          info = data["profile"]
+          puts CLI.pastel.bold("\n=== #{info['name']} ===")
+          CLI.print_table(
+            ["Field", "Value"],
+            [
+              ["ID", info["id"] || "N/A"],
+              ["Rank", info["rank"] || "N/A"],
+              ["Ranking", info["ranking"] || "N/A"],
+              ["Points", info["points"] || 0],
+              ["User Owns", info["user_owns"] || 0],
+              ["Root Owns", info["root_owns"] || 0],
+              ["Respect", info["respects"] || 0],
+              ["Country", info["country_name"] || "N/A"]
+            ]
+          )
+        else
+          CLI.print_error("User not found")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "activity USER_ID", "Show user activity"
+      def activity(user_id)
+        client = CLI.client
+        data = CLI.spinner("Fetching activity...") { client.users.activity(user_id) }
+
+        if data && data["profile"] && data["profile"]["activity"]
+          activities = data["profile"]["activity"]
+          puts CLI.pastel.bold("\n=== Recent Activity ===")
+
+          activities.first(10).each do |act|
+            type = act["type"] || "unknown"
+            name = act["name"] || "N/A"
+            date = act["date"] || "N/A"
+            puts "  #{CLI.pastel.cyan(type)}: #{name} (#{date})"
+          end
+        else
+          CLI.print_info("No activity found")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "bloods USER_ID", "Show user's first bloods"
+      def bloods(user_id)
+        client = CLI.client
+        data = CLI.spinner("Fetching bloods...") { client.users.bloods(user_id) }
+
+        if data && data["profile"]
+          bloods = data["profile"]
+          puts CLI.pastel.bold("\n=== First Bloods ===")
+
+          if bloods["bloods"] && !bloods["bloods"].empty?
+            rows = bloods["bloods"].map do |b|
+              [b["name"], b["type"], b["date"]]
+            end
+            CLI.print_table(["Name", "Type", "Date"], rows)
+          else
+            CLI.print_info("No first bloods")
+          end
+        else
+          CLI.print_info("No bloods found")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "badges USER_ID", "Show user's badges"
+      def badges(user_id)
+        client = CLI.client
+        data = CLI.spinner("Fetching badges...") { client.users.badges(user_id) }
+
+        if data && data["badges"]
+          puts CLI.pastel.bold("\n=== Badges ===")
+          data["badges"].each do |badge|
+            puts "  #{CLI.pastel.yellow('★')} #{badge['name']}"
+          end
+        else
+          CLI.print_info("No badges found")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "subscriptions", "Show your subscriptions"
+      def subscriptions
+        client = CLI.client
+        data = CLI.spinner("Fetching subscriptions...") { client.users.subscriptions }
+
+        if data
+          puts CLI.pastel.bold("\n=== Subscriptions ===")
+          puts "  Plan: #{data['plan'] || 'Free'}"
+          puts "  VIP: #{data['vip'] ? 'Yes' : 'No'}"
+          puts "  Expires: #{data['expires_at'] || 'N/A'}"
+        else
+          CLI.print_info("No subscription info")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+    end
+  end
+end

data/lib/htb/cli/vm.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module HTB
+  module CLI
+    class VM < Thor
+      def self.exit_on_failure?
+        true
+      end
+
+      desc "spawn MACHINE_ID", "Spawn a machine (VIP/Starting Point)"
+      def spawn(machine_id)
+        client = CLI.client
+        result = CLI.spinner("Spawning machine #{machine_id}...") do
+          client.vm.spawn(machine_id.to_i)
+        end
+
+        if result
+          if result["success"] == 1 || result["success"] == "1"
+            CLI.print_success("Machine is being spawned!")
+            CLI.print_info(result["message"]) if result["message"]
+          elsif result["message"]
+            CLI.print_info(result["message"])
+          else
+            CLI.print_success("Spawn request sent")
+          end
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "terminate MACHINE_ID", "Terminate a running machine"
+      def terminate(machine_id)
+        client = CLI.client
+        result = CLI.spinner("Terminating machine #{machine_id}...") do
+          client.vm.terminate(machine_id.to_i)
+        end
+
+        if result && (result["success"] == 1 || result["success"] == "1")
+          CLI.print_success("Machine terminated!")
+        else
+          CLI.print_info(result["message"] || "Terminate request sent")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "reset MACHINE_ID", "Reset a machine"
+      def reset(machine_id)
+        client = CLI.client
+        result = CLI.spinner("Resetting machine #{machine_id}...") do
+          client.vm.reset(machine_id.to_i)
+        end
+
+        if result && (result["success"] == 1 || result["success"] == "1")
+          CLI.print_success("Machine reset requested!")
+        else
+          CLI.print_info(result["message"] || "Reset request sent")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "extend MACHINE_ID", "Extend machine time"
+      def extend(machine_id)
+        client = CLI.client
+        result = CLI.spinner("Extending machine time...") do
+          client.vm.extend(machine_id.to_i)
+        end
+
+        if result && (result["success"] == 1 || result["success"] == "1")
+          CLI.print_success("Machine time extended!")
+        else
+          CLI.print_info(result["message"] || "Extension request sent")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "status", "Show VM status"
+      def status
+        client = CLI.client
+        data = CLI.spinner("Fetching VM status...") { client.vm.status }
+
+        if data && data["info"]
+          info = data["info"]
+          puts CLI.pastel.bold("\n=== VM Status ===")
+          CLI.print_table(
+            ["Field", "Value"],
+            [
+              ["Machine", info["name"] || "N/A"],
+              ["IP", info["ip"] || "N/A"],
+              ["Lab", info["lab"] || "N/A"],
+              ["Type", info["type"] || "N/A"]
+            ]
+          )
+        else
+          CLI.print_info("No active VM")
+        end
+      rescue HTB::Error => e
+        CLI.print_info("No active VM")
+      end
+
+      desc "active", "Show active VM"
+      def active
+        client = CLI.client
+        data = CLI.spinner("Fetching active VM...") { client.vm.active }
+
+        if data && data["info"]
+          info = data["info"]
+          puts CLI.pastel.bold("\n=== Active VM ===")
+          CLI.print_table(
+            ["Field", "Value"],
+            [
+              ["Machine", info["name"] || "N/A"],
+              ["ID", info["id"] || "N/A"],
+              ["IP", CLI.pastel.green(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
+    end
+  end
+end

data/lib/htb/cli/vpn.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module HTB
+  module CLI
+    class VPN < Thor
+      def self.exit_on_failure?
+        true
+      end
+
+      desc "status", "Show VPN connection status"
+      def status
+        client = CLI.client
+        data = CLI.spinner("Fetching VPN status...") { client.vpn.status }
+
+        if data
+          puts CLI.pastel.bold("\n=== VPN Status ===")
+          if data["data"]
+            d = data["data"]
+            CLI.print_table(
+              ["Field", "Value"],
+              [
+                ["Connected", d["connection"] ? CLI.pastel.green("Yes") : CLI.pastel.red("No")],
+                ["Server", d["server"] || "N/A"],
+                ["IP", d["ip"] || "N/A"],
+                ["Location", d["location"] || "N/A"]
+              ]
+            )
+          else
+            CLI.print_info("Not connected")
+          end
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "servers", "List VPN servers"
+      def servers
+        client = CLI.client
+        data = CLI.spinner("Fetching servers...") { client.vpn.servers }
+
+        if data && data["data"]
+          rows = data["data"].map do |s|
+            [
+              s["id"],
+              s["friendly_name"] || s["name"],
+              s["location"] || "N/A",
+              s["current_clients"] || 0,
+              s["status"] || "N/A"
+            ]
+          end
+
+          puts CLI.pastel.bold("\nVPN Servers:")
+          CLI.print_table(["ID", "Name", "Location", "Clients", "Status"], rows)
+        else
+          CLI.print_info("No servers found")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "switch SERVER_ID", "Switch to a different VPN server"
+      def switch(server_id)
+        client = CLI.client
+        result = CLI.spinner("Switching server...") { client.vpn.switch(server_id) }
+
+        if result && result["success"]
+          CLI.print_success("Switched to server #{server_id}")
+        else
+          CLI.print_info(result["message"] || "Switch request sent")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "regenerate", "Regenerate VPN config"
+      def regenerate
+        client = CLI.client
+        result = CLI.spinner("Regenerating VPN config...") { client.vpn.regenerate }
+
+        if result && result["success"]
+          CLI.print_success("VPN config regenerated!")
+        else
+          CLI.print_info(result["message"] || "Regeneration request sent")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "labs", "List available labs"
+      def labs
+        client = CLI.client
+        data = CLI.spinner("Fetching labs...") { client.vpn.labs }
+
+        if data && data["data"]
+          rows = data["data"].map do |l|
+            [l["id"], l["name"], l["description"] || "N/A"]
+          end
+
+          puts CLI.pastel.bold("\nLabs:")
+          CLI.print_table(["ID", "Name", "Description"], rows)
+        else
+          CLI.print_info("No labs found")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "prolabs", "List Pro Labs"
+      def prolabs
+        client = CLI.client
+        data = CLI.spinner("Fetching Pro Labs...") { client.vpn.prolabs }
+
+        if data && data["data"]
+          rows = data["data"].map do |p|
+            [
+              p["id"],
+              p["name"],
+              p["difficulty"] || "N/A",
+              p["machines_count"] || 0,
+              p["flags"] || 0
+            ]
+          end
+
+          puts CLI.pastel.bold("\nPro Labs:")
+          CLI.print_table(["ID", "Name", "Difficulty", "Machines", "Flags"], rows)
+        else
+          CLI.print_info("No Pro Labs found")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "endgames", "List Endgames"
+      def endgames
+        client = CLI.client
+        data = CLI.spinner("Fetching Endgames...") { client.vpn.endgames }
+
+        if data && data["data"]
+          rows = data["data"].map do |e|
+            [
+              e["id"],
+              e["name"],
+              e["difficulty"] || "N/A",
+              e["flags"] || 0
+            ]
+          end
+
+          puts CLI.pastel.bold("\nEndgames:")
+          CLI.print_table(["ID", "Name", "Difficulty", "Flags"], rows)
+        else
+          CLI.print_info("No Endgames found")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+
+      desc "fortresses", "List Fortresses"
+      def fortresses
+        client = CLI.client
+        data = CLI.spinner("Fetching Fortresses...") { client.vpn.fortresses }
+
+        if data && data["data"]
+          rows = data["data"].map do |f|
+            [
+              f["id"],
+              f["name"],
+              f["company"] || "N/A",
+              f["flags"] || 0
+            ]
+          end
+
+          puts CLI.pastel.bold("\nFortresses:")
+          CLI.print_table(["ID", "Name", "Company", "Flags"], rows)
+        else
+          CLI.print_info("No Fortresses found")
+        end
+      rescue HTB::Error => e
+        CLI.print_error(e.message)
+      end
+    end
+  end
+end

data/lib/htb/cli.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "thor"
+require "tty-table"
+require "tty-spinner"
+require "tty-prompt"
+require "pastel"
+
+require_relative "cli/main"
+require_relative "cli/machines"
+require_relative "cli/vm"
+require_relative "cli/users"
+require_relative "cli/challenges"
+require_relative "cli/vpn"
+
+module HTB
+  module CLI
+    TOKEN_URL = "https://app.hackthebox.com/profile/settings"
+
+    class << self
+      def pastel
+        @pastel ||= Pastel.new
+      end
+
+      def prompt
+        @prompt ||= TTY::Prompt.new
+      end
+
+      def client
+        token = HTB::Config.api_token
+
+        unless token
+          puts pastel.yellow("No API token configured.")
+          puts ""
+          puts "To get your API token:"
+          puts "  1. Go to #{pastel.cyan(TOKEN_URL)}"
+          puts "  2. Scroll down to 'App Tokens'"
+          puts "  3. Create a new token or copy an existing one"
+          puts ""
+
+          if prompt.yes?("Would you like to enter your API token now?")
+            token = prompt.mask("Paste your API token:")
+
+            if token && !token.strip.empty?
+              token = token.strip
+              # Validate the token by making a test request
+              print "Validating token... "
+              begin
+                test_client = HTB::Client.new(api_token: token)
+                test_client.users.me
+                puts pastel.green("valid!")
+
+                HTB::Config.api_token = token
+                puts pastel.green("Token saved to #{HTB::Config.config_file}")
+                puts ""
+              rescue HTB::AuthenticationError
+                puts pastel.red("invalid!")
+                puts pastel.red("The token appears to be invalid. Please check and try again.")
+                exit 1
+              rescue StandardError => e
+                puts pastel.red("error!")
+                puts pastel.red("Could not validate token: #{e.message}")
+                exit 1
+              end
+            else
+              puts pastel.red("No token provided.")
+              exit 1
+            end
+          else
+            puts ""
+            puts "You can set your token later with:"
+            puts "  #{pastel.cyan('htb login')}"
+            puts ""
+            puts "Or set the environment variable:"
+            puts "  #{pastel.cyan('export HTB_API_TOKEN=your_token')}"
+            exit 1
+          end
+        end
+
+        @client ||= HTB::Client.new(api_token: token)
+      end
+
+      def reset_client!
+        @client = nil
+      end
+
+      def spinner(message)
+        spinner = TTY::Spinner.new("[:spinner] #{message}", format: :dots)
+        spinner.auto_spin
+        result = yield
+        spinner.success(pastel.green("done"))
+        result
+      rescue StandardError => e
+        spinner.error(pastel.red("failed"))
+        raise e
+      end
+
+      def print_table(headers, rows)
+        table = TTY::Table.new(header: headers, rows: rows)
+        puts table.render(:unicode, padding: [0, 1])
+      end
+
+      def print_error(message)
+        puts pastel.red("Error: #{message}")
+      end
+
+      def print_success(message)
+        puts pastel.green(message)
+      end
+
+      def print_info(message)
+        puts pastel.cyan(message)
+      end
+    end
+  end
+end

data/lib/htb/client.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module HTB
+  class Client
+    attr_reader :api_token
+
+    def initialize(api_token: nil)
+      @api_token = api_token || HTB.api_token
+      raise AuthenticationError, "API token is required" unless @api_token
+    end
+
+    def connection
+      @connection ||= Faraday.new(url: BASE_URI) do |conn|
+        conn.request :json
+        conn.response :json, content_type: /\bjson$/
+        conn.headers["Authorization"] = "Bearer #{api_token}"
+        conn.headers["Accept"] = "application/json, text/plain, */*"
+        conn.headers["Content-Type"] = "application/json"
+        conn.headers["User-Agent"] = "htb-ruby/#{VERSION}"
+        conn.adapter Faraday.default_adapter
+      end
+    end
+
+    def get(path, params = {})
+      handle_response(connection.get("/api/#{API_VERSION}#{path}", params))
+    end
+
+    def post(path, body = {})
+      handle_response(connection.post("/api/#{API_VERSION}#{path}", body))
+    end
+
+    def put(path, body = {})
+      handle_response(connection.put("/api/#{API_VERSION}#{path}", body))
+    end
+
+    def delete(path, params = {})
+      handle_response(connection.delete("/api/#{API_VERSION}#{path}", params))
+    end
+
+    # Module accessors
+    def machines
+      @machines ||= Machines.new(self)
+    end
+
+    def users
+      @users ||= Users.new(self)
+    end
+
+    def vm
+      @vm ||= VM.new(self)
+    end
+
+    def challenges
+      @challenges ||= Challenges.new(self)
+    end
+
+    def vpn
+      @vpn ||= VPN.new(self)
+    end
+
+    private
+
+    def handle_response(response)
+      case response.status
+      when 200..299
+        response.body
+      when 401
+        raise AuthenticationError, "Invalid or expired API token"
+      when 404
+        raise NotFoundError, "Resource not found: #{response.body}"
+      when 429
+        raise RateLimitError, "Rate limit exceeded"
+      else
+        raise Error, "API error (#{response.status}): #{response.body}"
+      end
+    end
+  end
+end

data/lib/htb/config.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module HTB
+  class Config
+    CONFIG_FILE = File.expand_path("~/.htbrc")
+
+    class << self
+      def load
+        return {} unless File.exist?(CONFIG_FILE)
+
+        content = File.read(CONFIG_FILE)
+        YAML.safe_load(content, symbolize_names: true) || {}
+      rescue StandardError
+        {}
+      end
+
+      def save(config)
+        FileUtils.mkdir_p(File.dirname(CONFIG_FILE))
+        File.write(CONFIG_FILE, YAML.dump(config.transform_keys(&:to_s)))
+        File.chmod(0600, CONFIG_FILE) # Secure permissions
+      end
+
+      def api_token
+        # Priority: ENV > config file
+        ENV["HTB_API_TOKEN"] || load[:api_token]
+      end
+
+      def api_token=(token)
+        config = load
+        config[:api_token] = token
+        save(config)
+      end
+
+      def configured?
+        !api_token.nil? && !api_token.empty?
+      end
+
+      def clear!
+        File.delete(CONFIG_FILE) if File.exist?(CONFIG_FILE)
+      end
+
+      def config_file
+        CONFIG_FILE
+      end
+    end
+  end
+end