terminalwire 0.1.1 → 0.1.2

data/lib/terminalwire/rails.rb

@@ -0,0 +1,69 @@
+require 'jwt'
+require 'pathname'
+require 'forwardable'
+
+module Terminalwire::Rails
+  class Session
+    # JWT file name for the session file.
+    FILENAME = "session.jwt"
+
+    # Empty dictionary the user can stash all their session data into.
+    EMPTY_SESSION = {}.freeze
+
+    extend Forwardable
+
+    # Delegate `dig` and `fetch` to the `read` method
+    def_delegators :read,
+      :dig, :fetch, :[]
+
+    def initialize(context:, path: nil, secret_key: self.class.secret_key)
+      @context = context
+      @path = path || context.storage_path
+      @config_file_path = @path.join(FILENAME)
+      @secret_key = secret_key
+
+      ensure_file
+    end
+
+    def read
+      jwt_token = @context.file.read(@config_file_path)
+      decoded_data = JWT.decode(jwt_token, @secret_key, true, algorithm: 'HS256')
+      decoded_data[0]  # JWT payload is the first element in the array
+    rescue JWT::DecodeError => e
+      raise "Invalid or tampered file: #{e.message}"
+    end
+
+    def reset
+      @context.file.delete @config_file_path
+    end
+
+    def edit
+      config = read
+      yield config
+      write(config)
+    end
+
+    def []=(key, value)
+      edit { |config| config[key] = value }
+    end
+
+    def write(config)
+      token = JWT.encode(config, @secret_key, 'HS256')
+      @context.file.write(@config_file_path, token)
+    end
+
+    private
+
+    def ensure_file
+      return true if @context.file.exist? @config_file_path
+      # Create the path if it doesn't exist on the client.
+      @context.file.mkdir(@path) unless @context.file.exist?(@path)
+      # Write an empty configuration on initialization
+      write(EMPTY_SESSION)
+    end
+
+    def self.secret_key
+      Rails.application.secret_key_base
+    end
+  end
+end

data/lib/terminalwire/server.rb

@@ -1,144 +1,101 @@
 module Terminalwire
   module Server
     module Resource
-      class IO < Terminalwire::Resource::Base
+      class Base < Terminalwire::Resource::Base
+        private
+
+        def command(command, **parameters)
+          @adapter.write(
+            event: "resource",
+            name: @name,
+            action: "command",
+            command: command,
+            parameters: parameters
+          )
+          @adapter.recv&.fetch(:response)
+        end
+      end
+
+      class STDOUT < Base
         def puts(data)
-          command("puts", data: data)
+          command("print_line", data: data)
         end
 
         def print(data)
           command("print", data: data)
         end
 
-        def gets
-          command("gets")
-        end
-
         def flush
-          # @connection.flush
-        end
-
-        private
-
-        def command(command, data: nil)
-          @connection.write(event: "device", id: @id, action: "command", command: command, data: data)
-          @connection.recv&.fetch(:response)
+          # Do nothing
         end
       end
 
-      class STDOUT < IO
+      class STDERR < STDOUT
       end
 
-      class STDIN < IO
+      class STDIN < Base
         def getpass
-          command("getpass")
+          command("read_password")
         end
-      end
 
-      class STDERR < IO
+        def gets
+          command("read_line")
+        end
       end
 
-      class File < Terminalwire::Resource::Base
+      class File < Base
         def read(path)
-          command("read", path.to_s)
+          command("read", path: path.to_s)
         end
 
         def write(path, content)
-          command("write", { 'path' => path.to_s, 'content' => content })
+          command("write", path: path.to_s, content:)
         end
 
         def append(path, content)
-          command("append", { 'path' => path.to_s, 'content' => content })
+          command("append", path: path.to_s, content:)
         end
 
         def mkdir(path)
-          command("mkdir", { 'path' => path.to_s })
+          command("mkdir", path: path.to_s)
         end
 
-        def exist?(path)
-          command("exist", { 'path' => path.to_s })
+        def delete(path)
+          command("delete", path: path.to_s)
         end
 
-        private
-
-        def command(action, data)
-          @connection.write(event: "device", id: @id, action: "command", command: action, data: data)
-          response = @connection.recv
-          response.fetch(:response)
+        def exist?(path)
+          command("exist", path: path.to_s)
         end
       end
 
-      class Browser < Terminalwire::Resource::Base
+      class Browser < Base
         def launch(url)
-          command("launch", data: url)
-        end
-
-        private
-
-        def command(command, data: nil)
-          @connection.write(event: "device", id: @id, action: "command", command: command, data: data)
-          @connection.recv.fetch(:response)
-        end
-      end
-    end
-
-    class ResourceMapper
-      include Logging
-
-      def initialize(connection, resources = self.class.resources)
-        @id = -1
-        @resources = resources
-        @devices = Hash.new { |h,k| h[Integer(k)] }
-        @connection = connection
-      end
-
-      def connect_device(type)
-        id = next_id
-        logger.debug "Server: Requesting client to connect device #{type} with ID #{id}"
-        @connection.write(event: "device", action: "connect", id: id, type: type)
-        response = @connection.recv
-        case response
-        in { status: "success" }
-          logger.debug "Server: Resource #{type} connected with ID #{id}."
-          @devices[id] = @resources.find(type).new(id, @connection)
-        else
-          logger.debug "Server: Failed to connect device #{type} with ID #{id}."
-        end
-      end
-
-      private
-
-      def next_id
-        @id += 1
-      end
-
-      def self.resources
-        ResourceRegistry.new.tap do |resources|
-          resources << Server::Resource::STDOUT
-          resources << Server::Resource::STDIN
-          resources << Server::Resource::STDERR
-          resources << Server::Resource::Browser
-          resources << Server::Resource::File
+          command("launch", url: url)
         end
       end
     end
 
-    class Session
+    class Context
       extend Forwardable
 
-      attr_reader :stdout, :stdin, :stderr, :browser, :file
+      attr_reader :stdout, :stdin, :stderr, :browser, :file, :storage_path
 
       def_delegators :@stdout, :puts, :print
       def_delegators :@stdin, :gets, :getpass
 
-      def initialize(connection:)
-        @connection = connection
-        @devices = ResourceMapper.new(@connection)
-        @stdout = @devices.connect_device("stdout")
-        @stdin = @devices.connect_device("stdin")
-        @stderr = @devices.connect_device("stderr")
-        @browser = @devices.connect_device("browser")
-        @file = @devices.connect_device("file")
+      def initialize(adapter:, entitlement:)
+        @adapter = adapter
+
+        # TODO: Encapsulate entitlement in a class instead of a hash.
+        @entitlement = entitlement
+        @storage_path = Pathname.new(entitlement.fetch(:storage_path))
+
+        @stdout = Server::Resource::STDOUT.new("stdout", @adapter)
+        @stdin = Server::Resource::STDIN.new("stdin", @adapter)
+        @stderr = Server::Resource::STDERR.new("stderr", @adapter)
+        @browser = Server::Resource::Browser.new("browser", @adapter)
+        @file = Server::Resource::File.new("file", @adapter)
 
         if block_given?
           begin
@@ -149,18 +106,12 @@ module Terminalwire
         end
       end
 
-      def exec(&shell)
-        instance_eval(&shell)
-      ensure
-        exit
-      end
-
       def exit(status = 0)
-        @connection.write(event: "exit", status: status)
+        @adapter.write(event: "exit", status: status)
       end
 
       def close
-        @connection.close
+        @adapter.close
       end
     end
 
@@ -182,7 +133,7 @@ module Terminalwire
       end
 
       def listen
-        logger.info "Socket: Sistening..."
+        logger.info "Socket: Listening..."
         loop do
           client_socket = @server_socket.accept
           logger.debug "Socket: Client #{client_socket.inspect} connected"
@@ -194,37 +145,79 @@ module Terminalwire
 
       def handle_client(socket)
         transport = Transport::Socket.new(socket)
-        connection = Connection.new(transport)
+        adapter = Adapter.new(transport)
 
         Thread.new do
-          handler = Handler.new(connection)
+          handler = Handler.new(adapter)
           handler.run
         end
       end
     end
 
+    class WebSocket
+      include Logging
+
+      def call(env)
+        Async::WebSocket::Adapters::Rack.open(env, protocols: ['ws']) do |connection|
+          run(Adapter.new(Terminalwire::Transport::WebSocket.new(connection)))
+        end or [200, { "Content-Type" => "text/plain" }, ["Connect via WebSockets"]]
+      end
+
+      private
+
+      def run(adapter)
+        while message = adapter.recv
+          puts message
+        end
+      end
+    end
+
+    class Thor < WebSocket
+      include Logging
+
+      def initialize(cli_class)
+        @cli_class = cli_class
+
+        unless @cli_class.included_modules.include?(Terminalwire::Thor)
+          raise 'Add `include Terminalwire::Thor` to the #{@cli_class.inspect} class.'
+        end
+      end
+
+      def run(adapter)
+        logger.info "ThorServer: Running #{@cli_class.inspect}"
+        while message = adapter.recv
+          case message
+          in { event: "initialization", protocol:, program: { arguments: }, entitlement: }
+            Terminalwire::Server::Context.new(adapter:, entitlement:) do |context|
+              @cli_class.start(arguments, context:)
+            end
+          end
+        end
+      end
+    end
+
     class Handler
       include Logging
 
-      def initialize(connection)
-        @connection = connection
+      def initialize(adapter)
+        @adapter = adapter
       end
 
       def run
         logger.info "Server Handler: Running"
         loop do
-          message = @connection.recv
+          message = @adapter.recv
           case message
-          in { event: "initialize", arguments:, program_name: }
-            Session.new(connection: @connection) do |session|
-              MyCLI.start(arguments, session: session)
+          in { event: "initialization", protocol:, program: { arguments: }, entitlement: }
+            Context.new(adapter: @adapter) do |context|
+              MyCLI.start(arguments, context:)
             end
           end
         end
       rescue EOFError, Errno::ECONNRESET
         logger.info "Server Handler: Client disconnected"
       ensure
-        @connection.close
+        @adapter.close
       end
     end
 
@@ -236,4 +229,4 @@ module Terminalwire
       Server::Socket.new(UNIXServer.new(...))
     end
   end
-end
+end

data/lib/terminalwire/thor.rb

@@ -1,16 +1,20 @@
+require 'thor'
+
 module Terminalwire
   module Thor
     class Shell < ::Thor::Shell::Basic
       extend Forwardable
 
-      # Encapsulates all of the IO devices for a Terminalwire connection.
-      attr_reader :session
+      # Encapsulates all of the IO resources for a Terminalwire adapter.
+      attr_reader :context, :session
 
-      def_delegators :@session, :stdin, :stdout, :stderr
+      def_delegators :context,
+        :stdin, :stdout, :stderr
 
-      def initialize(session)
-        @session = session
-        super()
+      def initialize(context, *, **, &)
+        @context = context
+        @session = Terminalwire::Rails::Session.new(context:)
+        super(*,**,&)
       end
     end
 
@@ -24,20 +28,24 @@ module Terminalwire
         protected
 
         no_commands do
-          def_delegators :shell, :session
-          def_delegators :session, :stdout, :stdin, :stderr, :browser
-          def_delegators :stdout, :puts, :print
-          def_delegators :stdin, :gets
+          def_delegators :shell,
+            :context, :session
+          def_delegators :context,
+            :stdout, :stdin, :stderr, :browser
+          def_delegators :stdout,
+            :puts, :print
+          def_delegators :stdin,
+            :gets
         end
       end
     end
 
     module ClassMethods
       def start(given_args = ARGV, config = {})
-        session = config.delete(:session)
-        config[:shell] = Shell.new(session) if session
+        context = config.delete(:context)
+        config[:shell] = Shell.new(context) if context
         super(given_args, config)
       end
     end
   end
-end
+end

data/lib/terminalwire/transport.rb

@@ -1,8 +1,16 @@
+require 'uri'
+require 'socket'
+require 'async/websocket/client'
+
 module Terminalwire
   module Transport
     class Base
-      def initialize
-        raise NotImplementedError, "This is an abstract base class"
+      def self.connect(url)
+        raise NotImplementedError, "Subclass must implement .connect"
+      end
+
+      def self.listen(url)
+        raise NotImplementedError, "Subclass must implement .listen"
       end
 
       def read
@@ -18,25 +26,49 @@ module Terminalwire
       end
     end
 
-    class WebSocket
-      def initialize(websocket)
-        @websocket = websocket
+    class TCP < Base
+      def self.connect(url)
+        uri = URI(url)
+        new(TCPSocket.new(uri.host, uri.port))
+      end
+
+      def self.listen(url)
+        uri = URI(url)
+        new(TCPServer.new(uri.host, uri.port))
+      end
+
+      def initialize(socket)
+        @socket = socket
       end
 
       def read
-        @websocket.read&.buffer
+        length = @socket.read(4)
+        return nil if length.nil?
+        length = length.unpack('L>')[0]
+        @socket.read(length)
       end
 
       def write(data)
-        @websocket.write(data)
+        length = [data.bytesize].pack('L>')
+        @socket.write(length + data)
       end
 
       def close
-        @websocket.close
+        @socket.close
       end
     end
 
-    class Socket < Base
+    class Unix < Base
+      def self.connect(url)
+        uri = URI(url)
+        new(UNIXSocket.new(uri.path))
+      end
+
+      def self.listen(url)
+        uri = URI(url)
+        new(UNIXServer.new(uri.path))
+      end
+
       def initialize(socket)
         @socket = socket
       end
@@ -57,5 +89,35 @@ module Terminalwire
         @socket.close
       end
     end
+
+    class WebSocket < Base
+      def self.connect(url)
+        uri = URI(url)
+        endpoint = Async::HTTP::Endpoint.parse(uri)
+        adapter = Async::WebSocket::Client.connect(endpoint)
+        new(adapter)
+      end
+
+      def self.listen(url)
+        # This would need to be implemented with a WebSocket server library
+        raise NotImplementedError, "WebSocket server not implemented"
+      end
+
+      def initialize(websocket)
+        @websocket = websocket
+      end
+
+      def read
+        @websocket.read&.buffer
+      end
+
+      def write(data)
+        @websocket.write(data)
+      end
+
+      def close
+        @websocket.close
+      end
+    end
   end
-end
+end

data/lib/terminalwire/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Terminalwire
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end