terminalwire 0.2.5 → 0.3.0.alpha2

data/lib/terminalwire/client/resource.rb

@@ -1,204 +0,0 @@
-require "fileutils"
-require "io/console"
-
-module Terminalwire::Client::Resource
-  # Dispatches messages from the Client::Handler to the appropriate resource.
-  class Handler
-    include Enumerable
-
-    def initialize
-      @resources = {}
-      yield self if block_given?
-    end
-
-    def each(&block)
-      @resources.values.each(&block)
-    end
-
-    def add(resource)
-      # Detect if the resource is already registered and throw an error
-      if @resources.key?(resource.name)
-        raise "Resource #{resource.name} already registered"
-      else
-        @resources[resource.name] = resource
-      end
-    end
-    alias :<< :add
-
-    def dispatch(**message)
-      case message
-      in { event:, action:, name:, command:, parameters: }
-        resource = @resources.fetch(name)
-        resource.command(command, **parameters)
-      end
-    end
-  end
-
-  # Dispatcher, security, and response macros for resources.
-  class Base < Terminalwire::Resource::Base
-    def initialize(*, entitlement:, **)
-      super(*, **)
-      @entitlement = entitlement
-      connect
-    end
-
-    def command(command, **parameters)
-      begin
-        if permit(command, **parameters)
-          succeed self.public_send(command, **parameters)
-        else
-          fail "Client denied #{command}", command:, parameters:
-        end
-      rescue => e
-        fail e.message, command:, parameters:
-        raise
-      end
-    end
-
-    protected
-
-    def permit(...)
-      false
-    end
-  end
-
-  class EnvironmentVariable < Base
-    # Accepts a list of environment variables to permit.
-    def read(name:)
-      ENV[name]
-    end
-
-    # def write(name:, value:)
-    #   ENV[name] = value
-    # end
-
-    protected
-
-    def permit(command, name:, **)
-      @entitlement.environment_variables.permitted? name
-    end
-  end
-
-  class STDOUT < Base
-    def connect
-      @io = $stdout
-    end
-
-    def print(data:)
-      @io.print(data)
-    end
-
-    def print_line(data:)
-      @io.puts(data)
-    end
-
-    protected
-
-    def permit(...)
-      true
-    end
-  end
-
-  class STDERR < STDOUT
-    def connect
-      @io = $stderr
-    end
-  end
-
-  class STDIN < Base
-    def connect
-      @io = $stdin
-    end
-
-    def read_line
-      @io.gets
-    end
-
-    def read_password
-      @io.getpass
-    end
-
-    protected
-
-    def permit(...)
-      true
-    end
-  end
-
-  class File < Base
-    File = ::File
-
-    def read(path:)
-      File.read File.expand_path(path)
-    end
-
-    def write(path:, content:, mode: nil)
-      File.open(File.expand_path(path), "w", mode) { |f| f.write(content) }
-    end
-
-    def append(path:, content:, mode: nil)
-      File.open(File.expand_path(path), "a", mode) { |f| f.write(content) }
-    end
-
-    def delete(path:)
-      File.delete File.expand_path(path)
-    end
-
-    def exist(path:)
-      File.exist? File.expand_path(path)
-    end
-
-    def change_mode(path:, mode:)
-      File.chmod mode, File.expand_path(path)
-    end
-
-    protected
-
-    def permit(command, path:, mode: nil, **)
-      @entitlement.paths.permitted? path, mode:
-    end
-  end
-
-  class Directory < Base
-    File = ::File
-
-    def list(path:)
-      Dir.glob path
-    end
-
-    def create(path:)
-      FileUtils.mkdir_p File.expand_path(path)
-    rescue Errno::EEXIST
-      # Do nothing
-    end
-
-    def exist(path:)
-      Dir.exist? path
-    end
-
-    def delete(path:)
-      Dir.delete path
-    end
-
-    protected
-
-    def permit(command, path:, **)
-      @entitlement.paths.permitted? path
-    end
-  end
-
-  class Browser < Base
-    def launch(url:)
-      Launchy.open(URI(url))
-      # TODO: This is a hack to get the `respond` method to work.
-      # Maybe explicitly call a `suceed` and `fail` method?
-      nil
-    end
-
-    protected
-
-    def permit(command, url:, **)
-      @entitlement.schemes.permitted? url
-    end
-  end
-end

data/lib/terminalwire/client/server_license_verification.rb

@@ -1,74 +0,0 @@
-require "async/http/internet"
-require "base64"
-require "uri"
-require "fileutils"
-
-module Terminalwire::Client
-  # Checkes the server for a license verification at `https://terminalwire.com/licenses/verifications/`
-  # and displays the message to the user, if necessary.
-  class ServerLicenseVerification
-    include Terminalwire::Logging
-
-    def initialize(url:)
-      @url = URI(url)
-      @internet = Async::HTTP::Internet.new
-      @cache_store = Terminalwire::Cache::File::Store.new(path: Terminalwire::Client.root_path.join("cache/licenses/verifications"))
-    end
-
-    def key
-      Base64.urlsafe_encode64 @url
-    end
-
-    def cache = @cache_store.entry key
-
-    def payload
-      if cache.miss?
-        logger.debug "Stale verification. Requesting new verification."
-        request do |response|
-          # Set the expiry on the file cache for the header.
-          if max_age = response.headers["cache-control"].max_age
-            logger.debug "Caching for #{max_age}"
-            cache.expires = Time.now + max_age
-          end
-
-          # Process based on the response code.
-          case response.status
-          in 200
-            logger.debug "License for #{@url} found."
-            data = self.class.unpack response.read
-            cache.value = data
-            return data
-          in 404
-            logger.debug "License for #{@url} not found."
-            return self.class.unpack response.read
-          end
-        end
-      else
-        return cache.value
-      end
-    end
-
-    def message
-      payload.dig(:shell, :output)
-    end
-
-    protected
-
-    def verification_url
-      Terminalwire.url
-        .path("/licenses/verifications", key)
-    end
-
-    def request(&)
-      logger.debug "Requesting license verification from #{verification_url}."
-      response = @internet.get verification_url, {
-        "Accept" => "application/x-msgpack",
-        "User-Agent" => "Terminalwire/#{Terminalwire::VERSION} Ruby/#{RUBY_VERSION} (#{RUBY_PLATFORM})",
-      }, &
-    end
-
-    def self.unpack(pack)
-      MessagePack.unpack(pack, symbolize_keys: true)
-    end
-  end
-end

data/lib/terminalwire/client.rb

@@ -1,30 +0,0 @@
-require 'fileutils'
-require 'launchy'
-require 'io/console'
-require 'pathname'
-
-module Terminalwire
-  module Client
-    ROOT_PATH = "~/.terminalwire".freeze
-    def self.root_path = Pathname.new(ENV.fetch("TERMINALWIRE_HOME", ROOT_PATH))
-
-    def self.websocket(url:, arguments: ARGV, &configuration)
-      ENV["TERMINALWIRE_HOME"] ||= root_path.to_s
-
-      url = URI(url)
-
-      Async do |task|
-        endpoint = Async::HTTP::Endpoint.parse(
-          url,
-          alpn_protocols: Async::HTTP::Protocol::HTTP11.names
-        )
-
-        Async::WebSocket::Client.connect(endpoint) do |adapter|
-          transport = Terminalwire::Transport::WebSocket.new(adapter)
-          adapter = Terminalwire::Adapter::Socket.new(transport)
-          Terminalwire::Client::Handler.new(adapter, arguments:, endpoint:, &configuration).connect
-        end
-      end
-    end
-  end
-end

data/lib/terminalwire/logging.rb

@@ -1,8 +0,0 @@
-require 'logger'
-
-module Terminalwire
-  module Logging
-    DEVICE = Logger.new($stdout, level: ENV.fetch("TERMINALWIRE_LOG_LEVEL", "info"))
-    def logger = DEVICE
-  end
-end

data/lib/terminalwire/rails.rb

@@ -1,69 +0,0 @@
-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 = Pathname.new(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.directory.create @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/context.rb

@@ -1,80 +0,0 @@
-require "fileutils"
-
-module Terminalwire::Server
-  # Contains all of the resources that are accessible to the server on the client-side.
-  # It's the primary interface for the server to interact with the client and is integrated
-  # into other libraries like Thor, etc.
-  class Context
-    extend Forwardable
-
-    attr_reader \
-      :stdout, :stdin, :stderr,
-      :browser,
-      :file, :directory,
-      :environment_variable,
-      :authority,
-      :root_path,
-      :authority_path,
-      :storage_path
-
-    def_delegators :@stdout, :puts, :print
-    def_delegators :@stdin, :gets, :getpass
-
-    def initialize(adapter:, entitlement:)
-      @adapter = adapter
-      @entitlement = entitlement
-
-      # Initialize resources
-      @stdout = Resource::STDOUT.new("stdout", @adapter)
-      @stdin = Resource::STDIN.new("stdin", @adapter)
-      @stderr = Resource::STDERR.new("stderr", @adapter)
-      @browser = Resource::Browser.new("browser", @adapter)
-      @file = Resource::File.new("file", @adapter)
-      @directory = Resource::Directory.new("directory", @adapter)
-      @environment_variable = Resource::EnvironmentVariable.new("environment_variable", @adapter)
-
-      # Authority is provided by the client.
-      @authority = @entitlement.fetch(:authority)
-      # The Terminalwire home path is provided by the client and set
-      # as an environment variable.
-      @root_path = Pathname.new(
-        @environment_variable.read("TERMINALWIRE_HOME")
-      )
-      # Now derive the rest of the paths from the Terminalwire home path.
-      @authority_path = @root_path.join("authorities", @authority)
-      @storage_path = @authority_path.join("storage")
-
-      if block_given?
-        begin
-          yield self
-        ensure
-          exit
-        end
-      end
-    end
-
-    # Wraps the environment variables in a hash-like object that can be accessed
-    # from client#ENV. This makes it look and feel just like the ENV object in Ruby.
-    class Env
-      def initialize(context:)
-        @context = context
-      end
-
-      def [](name)
-        @context.environment_variable.read(name)
-      end
-    end
-
-    def ENV
-      @ENV ||= Env.new(context: self)
-    end
-
-    def exit(status = 0)
-      @adapter.write(event: "exit", status: status)
-    end
-
-    def close
-      @adapter.close
-    end
-  end
-end

data/lib/terminalwire/server/resource.rb

@@ -1,120 +0,0 @@
-module Terminalwire::Server
-  # Representation of the resources avilable to the server on the client-side. These
-  # classes encapsulate the API alls to the client and provide a more Ruby-like interface.
-  module Resource
-    class Base < Terminalwire::Resource::Base
-      private
-
-      def command(command, **parameters)
-        @adapter.write(
-          event: "resource",
-          name: @name,
-          action: "command",
-          command: command,
-          parameters: parameters
-        )
-
-        response = @adapter.read
-        case response.fetch(:status)
-        when "success"
-          response.fetch(:response)
-        when "failure"
-          raise Terminalwire::Error, response.inspect
-        end
-      end
-    end
-
-    class EnvironmentVariable < Base
-      # Accepts a list of environment variables to permit.
-      def read(name)
-        command("read", name:)
-      end
-
-      # def write(name:, value:)
-      #   command("write", name:, value:)
-      # end
-    end
-
-    class STDOUT < Base
-      def puts(data)
-        command("print_line", data: data)
-      end
-
-      def print(data)
-        command("print", data: data)
-      end
-
-      def flush
-        # Do nothing
-      end
-    end
-
-    class STDERR < STDOUT
-    end
-
-    class STDIN < Base
-      def getpass
-        command("read_password")
-      end
-
-      def gets
-        command("read_line")
-      end
-    end
-
-    class File < Base
-      def read(path)
-        command("read", path: path.to_s)
-      end
-
-      def write(path, content)
-        command("write", path: path.to_s, content:)
-      end
-
-      def append(path, content)
-        command("append", path: path.to_s, content:)
-      end
-
-      def delete(path)
-        command("delete", path: path.to_s)
-      end
-      alias :rm :delete
-
-      def exist?(path)
-        command("exist", path: path.to_s)
-      end
-
-      def change_mode(path, mode)
-        command("change_mode", path: path.to_s, mode:)
-      end
-      alias :chmod :change_mode
-    end
-
-    class Directory < Base
-      def list(path)
-        command("list", path: path.to_s)
-      end
-      alias :ls :list
-
-      def create(path)
-        command("create", path: path.to_s)
-      end
-      alias :mkdir :create
-
-      def exist?(path)
-        command("exist", path: path.to_s)
-      end
-
-      def delete(path)
-        command("delete", path: path.to_s)
-      end
-      alias :rm :delete
-    end
-
-    class Browser < Base
-      def launch(url)
-        command("launch", url: url)
-      end
-    end
-  end
-end

data/lib/terminalwire/server.rb

@@ -1,63 +0,0 @@
-require "thor"
-
-module Terminalwire
-  module Server
-    class WebSocket
-      include Logging
-
-      def call(env)
-        Async::WebSocket::Adapters::Rack.open(env, protocols: ['ws']) do |connection|
-          handle(Adapter::Socket.new(Terminalwire::Transport::WebSocket.new(connection)))
-        end or [200, { "Content-Type" => "text/plain" }, ["Connect via WebSockets"]]
-      end
-
-      def handle(adapter)
-        while message = adapter.read
-          puts message
-        end
-      end
-    end
-
-    class Thor < WebSocket
-      Rails = ::Rails
-
-      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 error_message
-        "An error occurred. Please try again."
-      end
-
-      def handle(adapter)
-        logger.info "ThorServer: Running #{@cli_class.inspect}"
-        while message = adapter.read
-          case message
-          in { event: "initialization", protocol:, program: { arguments: }, entitlement: }
-            context = Terminalwire::Server::Context.new(adapter:, entitlement:)
-
-            begin
-              @cli_class.start(arguments, context:)
-              context.exit
-            rescue StandardError => e
-              if Rails.application.config.consider_all_requests_local
-                # Show the full error message with stack trace in development
-                context.stderr.puts "#{e.inspect}\n#{e.backtrace.join("\n")}"
-              else
-                # Show a generic message in production
-                context.stderr.puts error_message
-              end
-              context.exit 1
-            end
-          end
-        end
-      end
-    end
-  end
-end