textflight-client 1.0.1

data/README.md

@@ -0,0 +1,160 @@
+## TextFlight Client
+
+A command-line client for the TextFlight.
+
+TextFlight is a space-based text adventure MMO.
+
+* https://leagueh.xyz/tf/
+* https://leagueh.xyz/git/textflight/
+
+```
+# TextFlight character
+jmoody
+faction: nibiru
+```
+
+One of the first computer games I played was Zork I on an Apple IIc.  The first
+program of any significance that I wrote was a text-based adventure in C# based
+on my experiences as student worker at the Physical Sciences library at UMass
+Amherst.  I played way too much BatMUD in the early nineties and early 2000s.
+
+### Requirements
+
+I develop and test on macOS.  The GitHub Actions run rspec tests on Ubuntu.
+
+I install dependencies with Homebrew.
+
+* Ruby >= 2.7.0
+* sqlite3
+* readline
+* socat (essential for debugging)
+
+### Developing
+
+To run integration tests and debug, a TextFlight server needs to be running
+locally.  There are two options: building the server yourself or using the
+docker container.  Find the instructions for building the server yourself at the
+bottom of this document.
+
+#### Docker
+
+The client has a Docker container that starts the server with SSL enabled.
+
+```
+$ bundle exec rake server
+docker-compose up --build --remove-orphans
+...
+ssl_1  | 2020-12-09 06:48:58,318 INFO:Loaded quest 'Refueling'.
+ssl_1  | 2020-12-09 06:48:58,318 INFO:Loaded quest 'Base Building'.
+ssl_1  | 2020-12-09 06:48:58,319 INFO:Loaded quest 'Starting Colonies'.
+```
+
+
+The certificate is self-signed, so the client should not try to verify the
+Certificate Authority.
+
+```
+# Connect to the native client: socat
+$ socat readline ssl:localhost:10000,verify=0
+
+^ also a rake task: bundle exec rake socat
+
+# Connect with bin/client.rb
+# --dev flag turns off certificate validation.
+$ bundle exec bin/client.rb --dev
+```
+
+### Test
+
+```
+$ bundle install
+$ bundle exec spec/lib
+```
+
+Integration tests require standing up the TextFlight server locally (see the
+Developing section above).
+
+```
+$ bundle install
+$ bundle  exec spec/integration
+```
+
+### TODO
+
+- [ ] stand up thor to improve cli
+- [ ] improve 'set' command
+  - engines {off | on}
+  - mining {off | on}
+  - prepare to launch
+  - prepare to land
+- [ ] improve the prompt
+- [ ] run 'nav' automatically after jump
+- [ ] handle the craft response
+- [ ] improve craft command (craft all [recipe])
+- [ ] improve the load command (mv all <index> to <structure>)
+
+### Server
+
+#### Build It Yourself
+
+```
+$ git clone https://leagueh.xyz/git/textflight/.git/
+```
+
+The server requires Python 3.x; I use 3.9.0.  I use pyenv to manage Python
+versions. Other than that, I don't know anything about Python (my Algorithms
+class at Smith in 2001 was in Python...) or how to configure Python on macOS.
+There is a little documentation in the textflight/README.md
+
+```
+# Run the server like this:
+$ cd textflight
+$ pip3 install bcrypt
+$ src/main.py
+...
+2020-12-04 23:17:25,110 INFO:Loaded quest 'Base Building'.
+2020-12-04 23:17:25,110 INFO:Loaded quest 'Starting Colonies'.
+
+# In another terminal, connect to the server like this:
+$ socat readline tcp:leagueh.xyz:10000
+```
+
+#### OpenSSL
+
+If you want to use openssl, install with `brew openssl` and use
+`/usr/local/opt/openssl/bin/openssl` instead of Apple's LibreSSL.
+
+
+```
+1. In the server directory, generate a self-sign cert.
+
+$ cd textflight
+$ mkdir -p certs
+# change the -subj
+$ /usr/local/opt/openssl/bin/openssl \
+  req -x509 \
+  -newkey rsa:4096 \
+  -keyout certs/key.pem \
+  -out certs/cert.pem \
+  -days 365 \
+  -nodes \
+  -subj "/C=DE/ST=BW/L=Konstanz/O=nibiru/OU=Org/CN=localhost"
+
+2. Install a textflight.conf and update the conf to use SSL
+$ cp textflight.conf.example textflight.conf
+SSL = true
+SSLCert = certs/cert.pem
+SSLKey = certs/key.pem
+
+3. Start the server.
+$ src/main.py
+
+4. Connect the client.  Without verify=0, the client will refuse
+   to connect with an error "unknown ca" (certificate authority).
+# Test connection with socat
+$ socat readline ssl:localhost:10000,verify=0
+
+# Or with this client
+$ bin/client.rb --dev
+```
+

data/Rakefile

@@ -0,0 +1,29 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require 'bundler/audit/task'
+
+Bundler::Audit::Task.new
+
+RSpec::Core::RakeTask.new(:spec) do |task|
+  Rake::Task["bundle:audit"].invoke
+  task.pattern = "spec/lib/**{,/*/**}/*_spec.rb"
+end
+
+RSpec::Core::RakeTask.new(:unit) do |task|
+  Rake::Task["bundle:audit"].invoke
+  task.pattern = "spec/lib/**{,/*/**}/*_spec.rb"
+end
+
+RSpec::Core::RakeTask.new(:integration) do |task|
+  Rake::Task["bundle:audit"].invoke
+  task.pattern = "spec/integration/**{,/*/**}/*_spec.rb"
+end
+
+task :server do
+  sh "docker-compose up --build --remove-orphans --detach"
+end
+
+task :socat do
+  sh "socat readline ssl:localhost:10000,verify=0"
+end
+

data/bin/client.rb

@@ -0,0 +1,291 @@
+#!/usr/bin/env ruby
+
+module TextFlight
+  require "openssl"
+  require "socket"
+  require "readline"
+  require "pry"
+
+  class CLI
+
+    def self.write_command(socket:, command:)
+      timeout = 5.0
+      ready = IO.select(nil, [socket], nil, timeout)
+
+      if !ready
+        message = "Timed out waiting for socket to be ready for writes after #{timeout} seconds"
+        socket.close
+        raise message
+      end
+
+      begin
+        socket.puts(command)
+      rescue StandardError, IOError => e
+        message = <<~EOM
+          Caught error while writing to socket
+
+          #{e.message}
+
+          after reading #{buffer.bytesize} from socket:
+
+          #{buffer}
+        EOM
+        socket.close
+        raise(e.class, message)
+      end
+    end
+
+    def self.read_response(socket:)
+      timeout = 5.0
+      ready = IO.select([socket], nil, nil, timeout)
+
+      if !ready
+        message = "Timed out waiting for socket to response after #{timeout} seconds"
+        socket.close
+        raise message
+      end
+
+      buffer = ""
+      max_tries = 3
+      tries = 1
+      begin
+        loop do
+          response = socket.read_nonblock(4096, exception: false)
+
+          if response == :wait_readable
+            if tries < max_tries
+              TFClient.debug(
+                "received :wait_readable on try: #{tries} of #{max_tries}; retrying"
+              )
+              tries = tries + 1
+              sleep(0.2)
+              next
+            else
+              TFClient.debug(
+                "received :wait_readable on try: #{tries} of #{max_tries}; breaking"
+              )
+              # could be we have to exit here
+              break
+            end
+          elsif response == nil
+            TFClient.error(
+              "received 'nil' on try: #{tries} of #{max_tries}; exiting"
+            )
+            raise("Server returned nil, possibly because of rate limiting")
+          end
+
+          TFClient.debug(
+            "received #{response.bytesize} bytes; pushing onto buffer"
+          )
+          tries = 1
+          response.delete_prefix!("> ")
+          response.delete_suffix!("> ")
+          response = TFClient::StringUtils.remove_terminal_control_chars(string: response)
+          response = TFClient::StringUtils.remove_color_control_chars(string: response)
+          buffer = buffer + response
+
+          sleep(0.2)
+        end
+      rescue StandardError, IOError => e
+        message = <<~EOM
+          Caught error while reading from socket:
+
+          #{e.message}
+
+          after reading #{buffer.bytesize} bytes from socket:
+
+          #{buffer}
+        EOM
+        socket.close
+        raise(e.class, message)
+      end
+
+      buffer
+    end
+
+    def self.parse_response(response:)
+      response.each do |line|
+        puts "#{line}"
+      end
+    end
+
+    def self.register(socket:, user:, pass:)
+      TFClient.debug("=== REGISTER ===")
+      TFClient.info("registering user: #{user} pass: #{pass[0..3]}***")
+      sleep(0.5)
+      self.write_command(socket: socket, command: "register #{user} #{pass}")
+
+      response = self.read_response(socket: socket)
+      puts response
+    end
+
+    def self.login(socket:, user:, pass:)
+      TFClient.debug("=== LOGIN ===")
+      TFClient.info("logging in user: #{user} pass: #{pass[0..3]}***")
+      sleep(0.5)
+      self.write_command(socket: socket, command: "login #{user} #{pass}")
+
+      response = self.read_response(socket: socket)
+      lines = response.lines(chomp: true)
+      if lines[0] && lines[0].chomp == "Incorrect username or password."
+        TFClient.error("#{response[0].chomp}")
+        socket.close
+        exit(1)
+      end
+    end
+
+    def self.enable_client_mode(socket:)
+      TFClient.debug("=== ENABLE CLIENT MODE ===")
+      sleep(0.5)
+      self.write_command(socket: socket, command: "language client")
+      response = self.read_response(socket: socket)
+      puts response
+    end
+
+    def self.status(socket:)
+      sleep(0.5)
+      TextFlight::CLI.write_command(socket: socket, command: "status")
+      sleep(0.5)
+      response = TextFlight::CLI.read_response(socket: socket)
+      TFClient::ResponseParser.new(command: "status",
+                                   textflight_command: "status",
+                                   response: response).parse
+    end
+
+    def self.nav(socket: @socket)
+      sleep(0.5)
+      TextFlight::CLI.write_command(socket: socket, command: "nav")
+      sleep(0.5)
+      response = TextFlight::CLI.read_response(socket: socket)
+      TFClient::ResponseParser.new(command: "nav",
+                                   textflight_command: "nav",
+                                   response: response).parse
+    end
+
+    attr_reader :socket, :user, :pass, :host, :port, :tcp, :state, :dev
+    attr_reader :local_db
+
+    def initialize(host:, port:, tcp:, user:, pass:, dev:)
+      db_path = TFClient::DotDir.local_database_file(dev: dev)
+      @local_db = TFClient::Models::Local::Database.new(path: db_path)
+      @state = { }
+      @user = user
+      @pass = pass
+      @host = host
+      @port = port
+      @tcp = tcp
+      @socket = connect(host: @host, port: @port, tcp: @tcp, dev: dev)
+      TextFlight::CLI.read_response(socket: @socket)
+
+      if dev
+        TextFlight::CLI.register(socket: @socket, user: @user, pass: @pass)
+      end
+
+      TextFlight::CLI.login(socket: @socket, user: @user, pass: @pass)
+      TextFlight::CLI.enable_client_mode(socket: @socket)
+
+      update_prompt!
+      read_eval_print
+    end
+
+    def connect(host:, port:, tcp:, dev:)
+      puts "try to connect to #{host}:#{port} with #{tcp ? "tcp" : "ssl"}"
+      if tcp
+        socket = TCPSocket.new(host, port)
+      else
+        ssl_context = OpenSSL::SSL::SSLContext.new
+        if dev
+          ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+        tcp_socket = TCPSocket.new(host, port)
+        socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, ssl_context)
+        socket.sync_close = true
+        socket.connect
+      end
+      socket
+    end
+
+    def update_prompt!
+      TextFlight::CLI.write_command(socket: @socket, command: "status")
+      response = TextFlight::CLI.read_response(socket: @socket)
+      status = TFClient::ResponseParser.new(command: "status-for-prompt",
+                                            textflight_command: "status",
+                                            response: response).parse
+
+      @prompt = TFClient::TFPrompt.new(operator:@user,
+                                       status_report: status.status_report)
+
+      system_id = status.status_report.hash[:sys_id]
+      system = @local_db.system_for_id(id: system_id)
+      if system.count == 0
+        TextFlight::CLI.write_command(socket: socket, command: "nav")
+        response = TextFlight::CLI.read_response(socket: @socket)
+        nav = TFClient::ResponseParser.new(command: "nav-for-prompt",
+                                           textflight_command: "nav",
+                                           response: response).parse
+        system = @local_db.create_system(id: system_id, nav: nav)
+        @prompt.x = system[:x]
+        @prompt.y = system[:y]
+      else
+        @prompt.x = system.first[:x]
+        @prompt.y = system.first[:y]
+      end
+    end
+
+    def read_eval_print
+      begin
+        loop do
+          command = Readline.readline("#{@prompt.to_s}", true)
+          if command.strip == ""
+            update_prompt!
+            next
+          end
+          parsed_command = TFClient::CommandParser.new(command: command).parse
+
+          if parsed_command == "exit"
+            TextFlight::CLI.write_command(socket: socket, command: parsed_command)
+            socket.close
+            puts "Goodbye."
+            exit(0)
+          end
+
+          TextFlight::CLI.write_command(socket: socket, command: parsed_command)
+
+          # dock, set, jump reply with STATUSREPORT
+          response = TextFlight::CLI.read_response(socket: @socket)
+          TFClient::ResponseParser.new(command: command,
+                                       textflight_command: parsed_command,
+                                       response: response).parse
+
+          update_prompt!
+        end
+      rescue IOError => e
+        puts e.message
+        # e.backtrace
+        @socket.close
+      end
+    end
+  end
+end
+
+require "dotenv/load" # load from .env
+require "textflight-client"
+
+env = ARGV.include?("--dev") ? "DEV" : "TF"
+tcp = ARGV.include?("--tcp")
+host = ENV["#{env}_HOST"] || "localhost"
+port = ENV["#{env}_PORT"] || "10000"
+
+if ARGV[0][/--/]
+  user = ENV["#{env}_USER"] || "abc"
+else
+  user = ARGV[0]
+end
+pass = ENV["#{env}_PASS"] || "1234"
+
+TextFlight::CLI.new(host: host,
+                    port: port,
+                    tcp: tcp,
+                    user: user,
+                    pass: pass,
+                    dev: env == "DEV")