terminalwire 0.2.4 → 0.3.0.alpha1

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

data/lib/terminalwire/thor.rb

@@ -1,55 +0,0 @@
-require 'thor'
-
-module Terminalwire
-  module Thor
-    class Shell < ::Thor::Shell::Basic
-      extend Forwardable
-
-      # Encapsulates all of the IO resources for a Terminalwire adapter.
-      attr_reader :context, :session
-
-      def_delegators :context,
-        :stdin, :stdout, :stderr
-
-      def initialize(context, *, **, &)
-        @context = context
-        @session = Terminalwire::Rails::Session.new(context:)
-        super(*,**,&)
-      end
-    end
-
-    def self.included(base)
-      base.extend ClassMethods
-
-      # I have to do this in a block to deal with some of Thor's DSL
-      base.class_eval do
-        extend Forwardable
-
-        protected
-
-        no_commands do
-          def_delegators :shell,
-            :context, :session
-          def_delegators :context,
-            :stdout, :stdin, :stderr, :browser
-          def_delegators :stdout,
-            :puts, :print
-          def_delegators :stdin,
-            :gets, :getpass
-
-          # Feels more naturual to call `client.files` etc. from
-          # the serve since it's more apparent that it's a client.
-          alias :client :context
-        end
-      end
-    end
-
-    module ClassMethods
-      def start(given_args = ARGV, config = {})
-        context = config.delete(:context)
-        config[:shell] = Shell.new(context) if context
-        super(given_args, config)
-      end
-    end
-  end
-end

data/lib/terminalwire/transport.rb

@@ -1,58 +0,0 @@
-require 'uri'
-require 'async/websocket/client'
-
-module Terminalwire
-  module Transport
-    class Base
-      def self.connect(url)
-        raise NotImplementedError, "Subclass must implement .connect"
-      end
-
-      def self.listen(url)
-        raise NotImplementedError, "Subclass must implement .listen"
-      end
-
-      def read
-        raise NotImplementedError, "Subclass must implement #read"
-      end
-
-      def write(data)
-        raise NotImplementedError, "Subclass must implement #write"
-      end
-
-      def close
-        raise NotImplementedError, "Subclass must implement #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

data/lib/terminalwire/version.rb

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

data/lib/terminalwire.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "terminalwire/version"
-
-require 'forwardable'
-require 'uri'
-require 'zeitwerk'
-
-require 'async'
-require 'async/http/endpoint'
-require 'async/websocket/client'
-require 'async/websocket/adapters/rack'
-require 'uri-builder'
-
-module Terminalwire
-  class Error < StandardError; end
-
-  # Zeitwerk loader for the Terminalwire gem.
-  Loader = Zeitwerk::Loader.for_gem.tap do |loader|
-    loader.ignore("#{__dir__}/generators")
-    loader.setup
-  end
-
-  # Used by Terminalwire client to connect to Terminalire.com for license
-  # validations, etc.
-  TERMINALWIRE_URL = "https://terminalwire.com".freeze
-  def self.url = URI.build(TERMINALWIRE_URL)
-
-  module Resource
-    class Base
-      attr_reader :name, :adapter
-
-      def initialize(name, adapter)
-        @name = name.to_s
-        @adapter = adapter
-      end
-
-      def connect; end
-      def disconnect; end
-
-      def fail(response, **data)
-        respond(status: "failure", response:, **data)
-      end
-
-      def succeed(response, **data)
-        respond(status: "success", response:, **data)
-      end
-
-      private
-
-      def respond(**response)
-        adapter.write(event: "resource", name: @name, **response)
-      end
-    end
-  end
-end

data/sig/terminalwire.rbs

@@ -1,4 +0,0 @@
-module Terminalwire
-  VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-end