sillydev 1.0.0

data/lib/sillydev/transport.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "openssl"
+require "uri"
+
+module SillyDev
+  # What the client asks the transport to send.
+  Request = Struct.new(:verb, :url, :headers, :body, keyword_init: true) do
+    def header(name)
+      headers.find { |key, _| key.casecmp?(name) }&.last
+    end
+  end
+
+  # What the transport hands back. Header names are lower case.
+  Response = Struct.new(:status, :headers, :body, keyword_init: true) do
+    def header(name)
+      headers[name.downcase]
+    end
+
+    def success?
+      status >= 200 && status < 300
+    end
+  end
+
+  # Raised by a transport when the connection could not be made, so nothing reached the panel and
+  # the request is safe to send again.
+  class ConnectFailed < StandardError; end
+
+  # The default transport: Net::HTTP from the standard library, one connection per request.
+  #
+  # Any object with a #call(request) that returns a Response can take its place, through
+  # Client.new(transport: ...). Tests use that to answer without a network.
+  class NetHTTPTransport
+    CONNECT_ERRORS = [
+      SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ENETUNREACH, Net::OpenTimeout
+    ].freeze
+
+    def initialize(timeout: 60, open_timeout: 10)
+      @timeout = timeout
+      @open_timeout = open_timeout
+    end
+
+    def call(request)
+      uri = URI(request.url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = @open_timeout
+      http.read_timeout = @timeout
+      http.write_timeout = @timeout
+      begin
+        http.start
+      rescue *CONNECT_ERRORS => e
+        raise ConnectFailed, e.message
+      end
+      begin
+        req = Net::HTTPGenericRequest.new(request.verb, !request.body.nil?, request.verb != "HEAD", uri.request_uri)
+        request.headers.each { |key, value| req[key] = value }
+        req.body = request.body unless request.body.nil?
+        res = http.request(req)
+        headers = {}
+        res.each_header { |key, value| headers[key.downcase] = value }
+        body = res.body.to_s
+        body = body.dup.force_encoding(Encoding::UTF_8) if body.encoding == Encoding::BINARY
+        Response.new(status: res.code.to_i, headers: headers, body: body)
+      ensure
+        http.finish if http.started?
+      end
+    end
+  end
+end

data/lib/sillydev/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SillyDev
+  VERSION = "1.0.0"
+end

data/lib/sillydev/websocket.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require "digest/sha1"
+require "io/wait"
+require "openssl"
+require "securerandom"
+require "socket"
+require "uri"
+
+module SillyDev
+  # A small websocket client (RFC 6455) on the standard library, enough for a server's console:
+  # text frames, ping and pong, and closing. Used by SillyDev::Console.
+  class WebSocket
+    GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+    MAX_MESSAGE = 16 * 1024 * 1024
+
+    # Raised when the connection fails or closes. #code and #reason come from the close frame.
+    class Closed < StandardError
+      attr_reader :code, :reason
+
+      def initialize(message, code: nil, reason: nil)
+        super(message)
+        @code = code
+        @reason = reason
+      end
+    end
+
+    # Encoding and decoding frames.
+    module Frame
+      module_function
+
+      # One frame. Clients mask what they send; servers do not.
+      def encode(opcode, payload, mask: true)
+        payload = payload.to_s.b
+        head = [0x80 | opcode].pack("C")
+        length = payload.bytesize
+        mask_bit = mask ? 0x80 : 0
+        head << if length < 126
+                  [mask_bit | length].pack("C")
+                elsif length < 65_536
+                  [mask_bit | 126, length].pack("Cn")
+                else
+                  [mask_bit | 127, length].pack("CQ>")
+                end
+        return head + payload unless mask
+
+        key = SecureRandom.random_bytes(4)
+        head + key + apply_mask(payload, key)
+      end
+
+      def apply_mask(payload, key)
+        bytes = payload.bytes
+        keys = key.bytes
+        bytes.each_index { |i| bytes[i] ^= keys[i % 4] }
+        bytes.pack("C*")
+      end
+
+      # Reads one frame with read.call(n), which returns exactly n bytes: [fin, opcode, payload].
+      def decode(read)
+        first, second = read.call(2).unpack("CC")
+        length = second & 0x7f
+        length = read.call(2).unpack1("n") if length == 126
+        length = read.call(8).unpack1("Q>") if length == 127
+        raise Closed, "A frame was too large." if length > MAX_MESSAGE
+
+        key = second.nobits?(0x80) ? nil : read.call(4)
+        payload = length.zero? ? "".b : read.call(length)
+        payload = apply_mask(payload, key) if key
+        [first.anybits?(0x80), first & 0x0f, payload]
+      end
+    end
+
+    attr_reader :close_code, :close_reason
+
+    # Opens a websocket to a ws:// or wss:// URL, waiting at most timeout seconds for the upgrade.
+    def self.connect(url, origin: nil, headers: {}, timeout: 10)
+      new(url, origin: origin, headers: headers, timeout: timeout)
+    end
+
+    def initialize(url, origin:, headers:, timeout:)
+      @uri = URI(url)
+      @write_lock = Mutex.new
+      @closed = false
+      deadline = monotonic + timeout
+      @socket = open_socket(timeout)
+      handshake(origin, headers, deadline)
+    rescue Closed
+      @socket&.close
+      raise
+    rescue SystemCallError, SocketError, IOError, OpenSSL::SSL::SSLError => e
+      @socket&.close
+      raise Closed, "Could not connect: #{e.message}"
+    end
+
+    def closed?
+      @closed
+    end
+
+    # Sends one text message.
+    def send_text(text)
+      write_frame(0x1, text.to_s.encode(Encoding::UTF_8))
+    end
+
+    # Waits for the next text message and returns it, answering pings meanwhile. Raises Closed
+    # when the connection ends, including when #close is called from another thread.
+    def read
+      message = nil
+      loop do
+        fin, opcode, payload = Frame.decode(->(n) { read_exactly(n, nil) })
+        case opcode
+        when 0x0
+          raise Closed, "An unexpected continuation frame." if message.nil?
+
+          message << payload
+        when 0x1, 0x2
+          message = payload.dup
+        when 0x8
+          handle_close(payload)
+        when 0x9
+          write_frame(0xA, payload)
+          next
+        else
+          next
+        end
+        raise Closed, "A message was too large." if message.bytesize > MAX_MESSAGE
+        return message.force_encoding(Encoding::UTF_8) if fin
+      end
+    end
+
+    # Sends a close frame and closes the connection.
+    def close(code = 1000)
+      return if @closed
+
+      begin
+        write_frame(0x8, [code].pack("n"))
+      rescue StandardError
+        nil
+      end
+      @closed = true
+      @socket.close
+    rescue StandardError
+      nil
+    end
+
+    private
+
+    class TimeoutRead < StandardError; end
+    private_constant :TimeoutRead
+
+    def monotonic
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def secure?
+      %w[wss https].include?(@uri.scheme)
+    end
+
+    def open_socket(timeout)
+      port = @uri.port || (secure? ? 443 : 80)
+      tcp = Socket.tcp(@uri.host, port, connect_timeout: timeout)
+      tcp.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+      return tcp unless secure?
+
+      context = OpenSSL::SSL::SSLContext.new
+      context.set_params(verify_mode: OpenSSL::SSL::VERIFY_PEER)
+      ssl = OpenSSL::SSL::SSLSocket.new(tcp, context)
+      ssl.hostname = @uri.host
+      ssl.sync_close = true
+      ssl.connect_nonblock(exception: false) until ssl_connected?(ssl, timeout)
+      ssl.post_connection_check(@uri.host)
+      ssl
+    end
+
+    def ssl_connected?(ssl, timeout)
+      case ssl.connect_nonblock(exception: false)
+      when :wait_readable then raise Closed, "The TLS handshake timed out." unless ssl.to_io.wait_readable(timeout)
+      when :wait_writable then raise Closed, "The TLS handshake timed out." unless ssl.to_io.wait_writable(timeout)
+      else return true
+      end
+      false
+    end
+
+    def handshake(origin, headers, deadline)
+      key = [SecureRandom.random_bytes(16)].pack("m0")
+      path = @uri.request_uri
+      host = @uri.port && ![80, 443].include?(@uri.port) ? "#{@uri.host}:#{@uri.port}" : @uri.host
+      lines = [
+        "GET #{path} HTTP/1.1", "Host: #{host}", "Upgrade: websocket", "Connection: Upgrade",
+        "Sec-WebSocket-Key: #{key}", "Sec-WebSocket-Version: 13"
+      ]
+      lines << "Origin: #{origin}" if origin
+      headers.each { |name, value| lines << "#{name}: #{value}" }
+      @socket.write("#{lines.join("\r\n")}\r\n\r\n")
+
+      response = +""
+      response << read_exactly(1, deadline) until response.end_with?("\r\n\r\n")
+      status = response[%r{\AHTTP/1\.1 (\d{3})}, 1].to_i
+      raise Closed.new("The node refused the websocket (HTTP #{status}).", code: status) unless status == 101
+
+      accept = response[/^sec-websocket-accept:\s*(\S+)/i, 1]
+      expected = [Digest::SHA1.digest(key + GUID)].pack("m0")
+      raise Closed, "The node answered the upgrade wrongly." unless accept == expected
+    rescue TimeoutRead
+      raise Closed, "The websocket upgrade timed out."
+    end
+
+    def handle_close(payload)
+      code = payload.bytesize >= 2 ? payload.unpack1("n") : nil
+      reason = payload.bytesize > 2 ? payload.byteslice(2..).force_encoding(Encoding::UTF_8) : nil
+      @close_code = code
+      @close_reason = reason
+      close(code || 1000) unless @closed
+      raise Closed.new("The websocket closed (code #{code || 'none'}).", code: code, reason: reason)
+    end
+
+    def write_frame(opcode, payload)
+      raise Closed, "The websocket is closed." if @closed && opcode != 0x8
+
+      @write_lock.synchronize { @socket.write(Frame.encode(opcode, payload, mask: true)) }
+    rescue SystemCallError, IOError, OpenSSL::SSL::SSLError => e
+      raise Closed, "Could not send: #{e.message}"
+    end
+
+    def read_exactly(count, deadline)
+      buffer = +"".b
+      while buffer.bytesize < count
+        chunk = @socket.read_nonblock(count - buffer.bytesize, exception: false)
+        case chunk
+        when :wait_readable, :wait_writable
+          wait = deadline ? deadline - monotonic : nil
+          raise TimeoutRead if wait && wait <= 0
+
+          io = @socket.to_io
+          ready = chunk == :wait_readable ? io.wait_readable(wait) : io.wait_writable(wait)
+          raise TimeoutRead unless ready
+        when nil
+          @closed = true
+          raise Closed.new("The connection was closed.", code: @close_code || 1006)
+        else
+          buffer << chunk
+        end
+      end
+      buffer
+    rescue SystemCallError, IOError, OpenSSL::SSL::SSLError => e
+      raise Closed.new("The connection failed: #{e.message}", code: 1006)
+    end
+  end
+end

data/lib/sillydev.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# The Ruby client for the Silly Development panel API.
+#
+#   require "sillydev"
+#
+#   client = SillyDev::Client.new # reads SILLYDEV_API_KEY
+#   client.panel.servers.list.each { |server| puts server["name"] }
+#   client.panel.servers.restart("1a7ce997")
+#
+# See https://sillydev.co.uk/docs/panel for the API itself.
+module SillyDev
+end
+
+require_relative "sillydev/version"
+require_relative "sillydev/errors"
+require_relative "sillydev/envelope"
+require_relative "sillydev/transport"
+require_relative "sillydev/client"
+require_relative "sillydev/resources"

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: sillydev
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Silly Development
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Start, stop and restart your servers, send console commands, manage files,
+  backups, schedules and databases, and deploy from Git on Silly Development, from
+  Ruby.
+executables:
+- sillydev
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- exe/sillydev
+- lib/sillydev.rb
+- lib/sillydev/cli.rb
+- lib/sillydev/client.rb
+- lib/sillydev/console.rb
+- lib/sillydev/envelope.rb
+- lib/sillydev/errors.rb
+- lib/sillydev/mcp_server.rb
+- lib/sillydev/monitoring.rb
+- lib/sillydev/monitoring/aggregator.rb
+- lib/sillydev/monitoring/client.rb
+- lib/sillydev/monitoring/discordrb.rb
+- lib/sillydev/monitoring/http.rb
+- lib/sillydev/monitoring/rack.rb
+- lib/sillydev/monitoring/rails.rb
+- lib/sillydev/monitoring/runtime.rb
+- lib/sillydev/monitoring/serialize.rb
+- lib/sillydev/resources.rb
+- lib/sillydev/transport.rb
+- lib/sillydev/version.rb
+- lib/sillydev/websocket.rb
+homepage: https://sillydev.co.uk/docs/panel
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://sillydev.co.uk
+  documentation_uri: https://sillydev.co.uk/docs/panel
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Ruby client for the Silly Development panel API
+test_files: []