roku_builder 3.3.3 → 3.3.4

data/lib/roku_builder/controller_commands.rb

@@ -0,0 +1,112 @@
+module RokuBuilder
+
+  # Commands that the controller uses to interface with the rest of the gem.
+  class ControllerCommands
+
+    # Provides a hash of all of the options needed to run simple commands via
+    # the simple_command method
+    # @return [Hash] options to run simple commands
+    def self.simple_commands
+      {
+        sideload: { klass: Loader, method: :sideload, config_key: :sideload_config,
+          failure: FAILED_SIDELOAD },
+        deeplink: { klass: Linker, method: :link, config_key: :deeplink_config,
+          failure: FAILED_DEEPLINKING },
+        delete: { klass: Loader, method: :unload },
+        monitor: { klass: Monitor, method: :monitor,
+          config_key: :monitor_config },
+        navigate: { klass: Navigator, method: :nav, config_key: :navigate_config,
+          failure: FAILED_NAVIGATING },
+        screen: { klass: Navigator, method: :screen, config_key: :screen_config,
+          failure: FAILED_NAVIGATING },
+        screens: { klass: Navigator, method: :screens },
+        text: { klass: Navigator, method: :type, config_key: :text_config },
+        test: { klass: Tester, method: :run_tests, config_key: :test_config },
+        screencapture: { klass: Inspector, method: :screencapture, config_key: :screencapture_config,
+          failure: FAILED_SCREENCAPTURE }
+      }
+    end
+    # Validate Config
+    # @return [Integer] Success or Failure Code
+    def self.validate()
+      SUCCESS
+    end
+    # Run Package
+    # @param options [Hash] user options
+    # @param configs [Hash] parsed configs
+    # @param logger [Logger] system logger
+    # @return [Integer] Success or Failure Code
+    def self.package(options:, configs:, logger:)
+      keyer = Keyer.new(**configs[:device_config])
+      loader = Loader.new(**configs[:device_config])
+      packager = Packager.new(**configs[:device_config])
+      inspector = Inspector.new(**configs[:device_config])
+      logger.warn "Packaging working directory" if options[:working]
+      # Sideload #
+      build_version = loader.sideload(**configs[:sideload_config])
+      return FAILED_SIGNING unless build_version
+      # Key #
+      success = keyer.rekey(**configs[:key])
+      logger.info "Key did not change" unless success
+      # Package #
+      options[:build_version] = build_version
+      configs = ConfigManager.update_configs(configs: configs, options: options)
+      success = packager.package(**configs[:package_config])
+      logger.info "Signing Successful: #{configs[:package_config][:out_file]}" if success
+      return FAILED_SIGNING unless success
+      # Inspect #
+      if options[:inspect]
+        info = inspector.inspect(configs[:inspect_config])
+        logger.unknown "App Name: #{info[:app_name]}"
+        logger.unknown "Dev ID: #{info[:dev_id]}"
+        logger.unknown "Creation Date: #{info[:creation_date]}"
+        logger.unknown "dev.zip: #{info[:dev_zip]}"
+      end
+      SUCCESS
+    end
+    # Run Build
+    # @param options [Hash] user options
+    # @param configs [Hash] parsed configs
+    # @param logger [Logger] system logger
+    # @return [Integer] Success or Failure Code
+    def self.build(options:, configs:, logger:)
+      ### Build ###
+      loader = Loader.new(**configs[:device_config])
+      build_version = ManifestManager.build_version(**configs[:manifest_config])
+      options[:build_version] = build_version
+      configs = ConfigManager.update_configs(configs: configs, options: options)
+      outfile = loader.build(**configs[:build_config])
+      logger.info "Build: #{outfile}"
+      SUCCESS
+    end
+    # Run update
+    # @param configs [Hash] parsed configs
+    # @param logger [Logger] system logger
+    # @return [Integer] Success or Failure Code
+    def self.update(configs:, logger:)
+      ### Update ###
+      old_version = ManifestManager.build_version(**configs[:manifest_config])
+      new_version = ManifestManager.update_build(**configs[:manifest_config])
+      logger.info "Update build version from:\n#{old_version}\nto:\n#{new_version}"
+      SUCCESS
+    end
+
+    # Run a simple command
+    # @param klass [Class] class of object to create
+    # @param method [Symbol] methog to run on klass
+    # @param config_key [Symbol] config to send from configs if not nil
+    # @param configs [Hash] parsed roku config
+    # @param failure [Integer] failure code to return on failure if not nil
+    # @return [Integer] Success of failure code
+    def self.simple_command(klass:, method:, config_key: nil, configs:, failure: nil)
+      instance = klass.new(**configs[:device_config])
+      if config_key
+        success = instance.send(method, configs[config_key])
+      else
+        success = instance.send(method)
+      end
+      return failure unless failure.nil? or success
+      SUCCESS
+    end
+  end
+end

data/lib/roku_builder/error_handler.rb

@@ -0,0 +1,116 @@
+module RokuBuilder
+
+  # Contains methods to handle errors from different sources.
+  class ErrorHandler
+    # Handle codes returned from validating options
+    # @param options_code [Integer] the error code returned by validate_options
+    # @param logger [Logger] system logger
+    def self.handle_options_codes(options_code:, logger:)
+      case options_code
+      when EXTRA_COMMANDS
+        logger.fatal "Only one command is allowed"
+        abort
+      when NO_COMMANDS
+        logger.fatal "At least one command is required"
+        abort
+      when EXTRA_SOURCES
+        logger.fatal "Only use one of --ref, --working, --current or --stage"
+        abort
+      when NO_SOURCE
+        logger.fatal "Must use at least one of --ref, --working, --current or --stage"
+        abort
+      when BAD_CURRENT
+        logger.fatal "Can only sideload or build 'current' directory"
+        abort
+      when BAD_DEEPLINK
+        logger.fatal "Must supply deeplinking options when deeplinking"
+        abort
+      when BAD_IN_FILE
+        logger.fatal "Can only supply in file for building"
+        abort
+      end
+    end
+
+    # Handle codes returned from configuring
+    # @param configure_code [Integer] the error code returned by configure
+    # @param logger [Logger] system logger
+    def self.handle_configure_codes(configure_code:, logger:)
+      case configure_code
+      when CONFIG_OVERWRITE
+        logger.fatal 'Config already exists. To create default please remove config first.'
+        abort
+      when SUCCESS
+        logger.info 'Configure successful'
+        abort
+      end
+    end
+
+    # Handle codes returned from load_config
+    # @param options [Hash] the options hash
+    # @param load_code [Integer] the error code returned by configure
+    # @param logger [Logger] system logger
+    def self.handle_load_codes(options:, load_code:, logger:)
+      case load_code
+      when DEPRICATED_CONFIG
+        logger.warn 'Depricated config. See Above'
+      when MISSING_CONFIG
+        logger.fatal "Missing config file: #{options[:config]}"
+        abort
+      when INVALID_CONFIG
+        logger.fatal 'Invalid config. See Above'
+        abort
+      when MISSING_MANIFEST
+        logger.fatal 'Manifest file missing'
+        abort
+      when UNKNOWN_DEVICE
+        logger.fatal "Unkown device id"
+        abort
+      when UNKNOWN_PROJECT
+        logger.fatal "Unknown project id"
+        abort
+      when UNKNOWN_STAGE
+        logger.fatal "Unknown stage"
+        abort
+      end
+    end
+
+    # Handle codes returned from checking devices
+    # @param device_code [Integer] the error code returned by check_devices
+    # @param logger [Logger] system logger
+    def self.handle_device_codes(device_code:, logger:)
+      case device_code
+      when CHANGED_DEVICE
+        logger.info "The default device was not online so a secondary device is being used"
+      when BAD_DEVICE
+        logger.fatal "The selected device was not online"
+        abort
+      when NO_DEVICES
+        logger.fatal "No configured devices were found"
+        abort
+      end
+    end
+
+    # Handle codes returned from handeling commands devices
+    # @param command_code [Integer] the error code returned by handle_options
+    # @param logger [Logger] system logger
+    def self.handle_command_codes(command_code:, logger:)
+      case command_code
+      when FAILED_SIDELOAD
+        logger.fatal "Failed Sideloading App"
+        abort
+      when FAILED_SIGNING
+        logger.fatal "Failed Signing App"
+        abort
+      when FAILED_DEEPLINKING
+        logger.fatal "Failed Deeplinking To App"
+        abort
+      when FAILED_NAVIGATING
+        logger.fatal "Command not sent"
+        abort
+      when FAILED_SCREENCAPTURE
+        logger.fatal "Failed to Capture Screen"
+        abort
+      end
+    end
+  end
+end

data/lib/roku_builder/inspector.rb

@@ -15,12 +15,7 @@ module RokuBuilder
 
       # upload new key with password
       path = "/plugin_inspect"
-      conn = Faraday.new(url: @url) do |f|
-        f.request :digest, @dev_username, @dev_password
-        f.request :multipart
-        f.request :url_encoded
-        f.adapter Faraday.default_adapter
-      end
+      conn = multipart_connection
       payload =  {
         mysubmit: "Inspect",
         passwd: password,
@@ -35,12 +30,12 @@ module RokuBuilder
       if app_name
         app_name = app_name[1]
         dev_id = /Dev ID:\s*<\/td>\s*<td>\s*<font[^>]*>([^<]*)<\/font>\s*<\/td>/.match(response.body)[1]
-        creation_date = /new Date\(([^)]*)\)/.match(response.body.gsub("\n", ''))[1]
+        creation_date = /new Date\(([^)]*)\)/.match(response.body.delete("\n"))[1]
         dev_zip = /dev.zip:\s*<\/td>\s*<td>\s*<font[^>]*>([^<]*)<\/font>\s*<\/td>/.match(response.body)[1]
       else
         app_name = /App Name:[^<]*<div[^>]*>([^<]*)<\/div>/.match(response.body)[1]
         dev_id = /Dev ID:[^<]*<div[^>]*><font[^>]*>([^<]*)<\/font><\/div>/.match(response.body)[1]
-        creation_date = /new Date\(([^\/]*)\)/.match(response.body.gsub("\n", ''))[1]
+        creation_date = /new Date\(([^\/]*)\)/.match(response.body.delete("\n"))[1]
         dev_zip = /dev.zip:[^<]*<div[^>]*><font[^>]*>([^<]*)<\/font><\/div>/.match(response.body)[1]
       end
 
@@ -52,12 +47,7 @@ module RokuBuilder
     # @return [Boolean] Success
     def screencapture(out_folder:, out_file: nil)
       path = "/plugin_inspect"
-      conn = Faraday.new(url: @url) do |f|
-        f.request :digest, @dev_username, @dev_password
-        f.request :multipart
-        f.request :url_encoded
-        f.adapter Faraday.default_adapter
-      end
+      conn = multipart_connection
       payload =  {
         mysubmit: "Screenshot",
         passwd: @dev_password,
@@ -73,10 +63,7 @@ module RokuBuilder
         out_file = "dev_#{out_file[1]}.jpg" if out_file
       end
 
-      conn = Faraday.new(url: @url) do |f|
-        f.request :digest, @dev_username, @dev_password
-        f.adapter Faraday.default_adapter
-      end
+      conn = simple_connection
 
       response = conn.get path
 

data/lib/roku_builder/keyer.rb

@@ -12,18 +12,13 @@ module RokuBuilder
 
       # upload new key with password
       path = "/plugin_inspect"
-      conn = Faraday.new(url: @url) do |f|
-        f.request :digest, @dev_username, @dev_password
-        f.request :multipart
-        f.request :url_encoded
-        f.adapter Faraday.default_adapter
-      end
+      conn = multipart_connection
       payload =  {
         mysubmit: "Rekey",
         passwd: password,
         archive: Faraday::UploadIO.new(keyed_pkg, 'application/octet-stream')
       }
-      response = conn.post path, payload
+      conn.post path, payload
 
       # check key
       newId = dev_id
@@ -34,10 +29,7 @@ module RokuBuilder
     # @return [String] The current dev id
     def dev_id
       path = "/plugin_package"
-      conn = Faraday.new(url: @url) do |f|
-        f.request :digest, @dev_username, @dev_password
-        f.adapter Faraday.default_adapter
-      end
+      conn = simple_connection
       response = conn.get path
 
       dev_id = /Your Dev ID:\s*<font[^>]*>([^<]*)<\/font>/.match(response.body)

data/lib/roku_builder/linker.rb

@@ -8,27 +8,15 @@ module RokuBuilder
     # @note Any options will be accepted and sent to the app
     def link(options:)
       path = "/launch/dev"
-      payload = {}
       return false unless options
-      opts = options.split(/,\s*/)
-      opts.each do |opt|
-        opt = opt.split(":")
-        key = opt.shift.to_sym
-        value = opt.join(":")
-        payload[key] = value
-      end
+      payload = Util.options_parse(options: options)
 
       unless payload.keys.count > 0
         return false
       end
 
       path = "#{path}?#{parameterize(payload)}"
-      conn = Faraday.new(url: "#{@url}:8060") do |f|
-        f.request :digest, @dev_username, @dev_password
-        f.request :multipart
-        f.request :url_encoded
-        f.adapter Faraday.default_adapter
-      end
+      conn = multipart_connection(port: 8060)
 
       response = conn.post path
       return response.success?
@@ -40,7 +28,7 @@ module RokuBuilder
     # @param params [Hash] Parameters to be sent
     # @return [String] Parameters as a string, URI escaped
     def parameterize(params)
-      URI.escape(params.collect{|k,v| "#{k}=#{URI.escape(v, "?&")}"}.join('&'))
+      params.collect{|k,v| "#{k}=#{CGI.escape(v)}"}.join('&')
     end
   end
 end

data/lib/roku_builder/loader.rb

@@ -7,75 +7,39 @@ module RokuBuilder
     # @param root_dir [String] Path to the root directory of the roku app
     # @param branch [String] Branch of the git repository to sideload. Pass nil to use working directory. Default: nil
     # @param update_manifest [Boolean] Flag to update the manifest file before sideloading. Default: false
-    # @param fetch [Boolean] Flag to fetch all remotes before sideloading. Default: false
     # @param folders [Array<String>] Array of folders to be sideloaded. Pass nil to send all folders. Default: nil
     # @param files [Array<String>] Array of files to be sideloaded. Pass nil to send all files. Default: nil
-    # @param infile [String] 
     # @return [String] Build version on success, nil otherwise
-    def sideload(root_dir:, branch: nil, update_manifest: false, fetch: false, folders: nil, files: nil, infile: nil)
+    def sideload(root_dir:, branch: nil, update_manifest: false, folders: nil, files: nil)
       @root_dir = root_dir
       result = nil
-      stash = nil
-      if branch
-        git = Git.open(@root_dir)
-        if fetch
-          for remote in git.remotes
-            git.fetch(remote)
-          end
-        end
-      end
-      current_dir = Dir.pwd
       begin
-        if git and branch and branch != git.current_branch
-          Dir.chdir(@root_dir)
-          current_branch = git.current_branch
-          stash = git.branch.stashes.save("roku-builder-temp-stash")
-          git.checkout(branch)
-        end
-
+        git_switch_to(branch: branch)
         # Update manifest
         build_version = ""
         if update_manifest
-          build_version = ManifestManager.update_build(root_dir: root_dir, logger: @logger)
+          build_version = ManifestManager.update_build(root_dir: root_dir)
         else
-          build_version = ManifestManager.build_version(root_dir: root_dir, logger: @logger)
+          build_version = ManifestManager.build_version(root_dir: root_dir)
         end
-
         outfile = build(root_dir: root_dir, branch: branch, build_version: build_version, folders: folders, files: files)
-
         path = "/plugin_install"
-
         # Connect to roku and upload file
-        conn = Faraday.new(url: @url) do |f|
-          f.request :digest, @dev_username, @dev_password
-          f.request :multipart
-          f.request :url_encoded
-          f.adapter Faraday.default_adapter
-        end
+        conn = multipart_connection
         payload =  {
           mysubmit: "Replace",
           archive: Faraday::UploadIO.new(outfile, 'application/zip')
         }
         response = conn.post path, payload
-
         # Cleanup
         File.delete(outfile)
-
-        if git and current_branch
-          git.checkout(current_branch)
-          git.branch.stashes.apply if stash
-        end
-
-        if response.status == 200 and response.body =~ /Install Success/
-          result = build_version
-        end
-
-      rescue Git::GitExecuteError => e
-        @logger.error "Branch or ref does not exist"
-        @logger.error e.message
-        @logger.error e.backtrace
+        result = build_version if response.status==200 and response.body=~/Install Success/
+        git_switch_from(branch: branch)
+      rescue Git::GitExecuteError
+        git_rescue
       ensure
-        Dir.chdir(current_dir) unless current_dir == Dir.pwd
+        @current_dir ||= Dir.pwd
+        Dir.chdir(@current_dir) unless @current_dir == Dir.pwd
       end
       result
     end
@@ -86,31 +50,13 @@ module RokuBuilder
     # @param branch [String] Branch of the git repository to sideload. Pass nil to use working directory. Default: nil
     # @param build_version [String] Version to assigne to the build. If nil will pull the build version form the manifest. Default: nil
     # @param outfile [String] Path for the output file. If nil will create a file in /tmp. Default: nil
-    # @param fetch [Boolean] Flag to fetch all remotes before sideloading. Default: false
     # @param folders [Array<String>] Array of folders to be sideloaded. Pass nil to send all folders. Default: nil
     # @param files [Array<String>] Array of files to be sideloaded. Pass nil to send all files. Default: nil
     # @return [String] Path of the build
-    def build(root_dir:, branch: nil, build_version: nil, outfile: nil, fetch: false, folders: nil, files: nil)
+    def build(root_dir:, branch: nil, build_version: nil, outfile: nil, folders: nil, files: nil)
       @root_dir = root_dir
-      result = nil
-      stash = nil
-      if branch
-        git = Git.open(@root_dir)
-        if fetch
-          for remote in git.remotes
-            git.fetch(remote)
-          end
-        end
-      end
-      current_dir = Dir.pwd
       begin
-        if git and branch and branch != git.current_branch
-          Dir.chdir(@root_dir)
-          current_branch = git.current_branch
-          stash = git.branch.stashes.save("roku-builder-temp-stash")
-          git.checkout(branch)
-        end
-
+        git_switch_to(branch: branch)
         build_version = ManifestManager.build_version(root_dir: root_dir, logger: @logger) unless build_version
         unless folders
           folders = Dir.entries(root_dir).select {|entry| File.directory? File.join(root_dir, entry) and !(entry =='.' || entry == '..') }
@@ -119,10 +65,8 @@ module RokuBuilder
           files = Dir.entries(root_dir).select {|entry| File.file? File.join(root_dir, entry)}
         end
         outfile = "/tmp/build_#{build_version}.zip" unless outfile
-
-        File.delete(outfile) if File.exists?(outfile)
+        File.delete(outfile) if File.exist?(outfile)
         io = Zip::File.open(outfile, Zip::File::CREATE)
-
         # Add folders to zip
         folders.each do |folder|
           base_folder = File.join(@root_dir, folder)
@@ -131,22 +75,15 @@ module RokuBuilder
           entries.delete("..")
           writeEntries(@root_dir, entries, folder, io)
         end
-
         # Add file to zip
         writeEntries(@root_dir, files, "", io)
-
         io.close()
-
-        if git and current_branch
-          git.checkout(current_branch)
-          git.branch.stashes.apply if stash
-        end
-      rescue Git::GitExecuteError => e
-        @logger.error "Branch or ref does not exist"
-        @logger.error e.message
-        @logger.error e.backtrace
+        git_switch_from(branch: branch)
+      rescue Git::GitExecuteError
+        git_rescue
       ensure
-        Dir.chdir(current_dir) unless current_dir == Dir.pwd
+        @current_dir ||= Dir.pwd
+        Dir.chdir(@current_dir) unless @current_dir == Dir.pwd
       end
       outfile
     end
@@ -156,13 +93,7 @@ module RokuBuilder
         path = "/plugin_install"
 
         # Connect to roku and upload file
-        conn = Faraday.new(url: @url) do |f|
-          f.headers['Content-Type'] = Faraday::Request::Multipart.mime_type
-          f.request :digest, @dev_username, @dev_password
-          f.request :multipart
-          f.request :url_encoded
-          f.adapter Faraday.default_adapter
-        end
+        conn = multipart_connection
         payload =  {
           mysubmit: "Delete",
           archive: ""
@@ -194,5 +125,37 @@ module RokuBuilder
         end
       }
     end
+
+    # Switch to the correct branch
+    def git_switch_to(branch:)
+      if branch
+        @current_dir = Dir.pwd
+        @git ||= Git.open(@root_dir)
+        if branch != @git.current_branch
+          Dir.chdir(@root_dir)
+          @current_branch = @git.current_branch
+          @stash = @git.branch.stashes.save("roku-builder-temp-stash")
+          @git.checkout(branch)
+        end
+      end
+    end
+
+    # Switch back to the previous branch
+    def git_switch_from(branch:)
+      if branch
+        @git ||= Git.open(@root_dir)
+        if @git and @current_branch
+          @git.checkout(@current_branch)
+          @git.branch.stashes.apply if @stash
+        end
+      end
+    end
+
+    # Called if resuce from git exception
+    def git_rescue
+      @logger.error "Branch or ref does not exist"
+      @logger.error e.message
+      @logger.error e.backtrace
+    end
   end
 end

data/lib/roku_builder/manifest_manager.rb

@@ -6,7 +6,7 @@ module RokuBuilder
     # Updates the build version in the manifest file
     # @param root_dir [String] Path to the root directory for the app
     # @return [String] Build version on success, empty string otherwise
-    def self.update_build(root_dir:, logger:)
+    def self.update_build(root_dir:)
 
       build_version = ""
 
@@ -19,7 +19,6 @@ module RokuBuilder
 
               #Update build version.
               build_version = line.split(".")
-              iteration = 0
               if 2 == build_version.length
                 iteration = build_version[1].to_i + 1
                 build_version[0] = Time.now.strftime("%m%d%y")
@@ -47,7 +46,7 @@ module RokuBuilder
     # Retrive the build version from the manifest file
     # @param root_dir [String] Path to the root directory for the app
     # @return [String] Build version on success, empty string otherwise
-    def self.build_version(root_dir:, logger:)
+    def self.build_version(root_dir:)
       path = File.join(root_dir, 'manifest')
       build_version = ""
       File.open(path, 'r') do |file|

data/lib/roku_builder/monitor.rb

@@ -17,7 +17,6 @@ module RokuBuilder
 
     # Monitor a development log on the Roku device
     # @param type [Symbol] The log type to monitor
-    # @param verbose [Boolean] Print status messages.
     def monitor(type:)
       telnet_config = {
         'Host' => @roku_ip_address,
@@ -28,26 +27,30 @@ module RokuBuilder
         'Timeout' => false
       }
 
-      thread = Thread.new(telnet_config, waitfor_config) {|telnet_config,waitfor_config|
-        @logger.info "Monitoring #{type} console(#{telnet_config['Port']}) on #{telnet_config['Host'] }"
-        connection = Net::Telnet.new(telnet_config)
+      thread = Thread.new(telnet_config, waitfor_config) {|telnet,waitfor|
+        @logger.info "Monitoring #{type} console(#{telnet['Port']}) on #{telnet['Host'] }"
+        connection = Net::Telnet.new(telnet)
         Thread.current[:connection] = connection
         all_text = ""
         while true
-          connection.waitfor(waitfor_config) do |txt|
+          connection.waitfor(waitfor) do |txt|
             all_text = manage_text(all_text: all_text, txt: txt)
           end
         end
       }
       running = true
       while running
-        @logger.info "Q to exit"
-        command = gets.chomp
-        if command == "q"
-          thread.exit
-          running = false
-        else
-          thread[:connection].puts(command)
+        begin
+          @logger.info "Q to exit"
+          command = gets.chomp
+          if command == "q"
+            thread.exit
+            running = false
+          else
+            thread[:connection].puts(command)
+          end
+        rescue SystemExit, Interrupt
+          thread[:connection].puts("\C-c")
         end
       end
     end

data/lib/roku_builder/navigator.rb

@@ -38,11 +38,7 @@ module RokuBuilder
     # @return [Boolean] Success
     def nav(command:)
       if @commands.has_key?(command)
-        conn = Faraday.new(url: "#{@url}:8060") do |f|
-          f.request :multipart
-          f.request :url_encoded
-          f.adapter Faraday.default_adapter
-        end
+        conn = multipart_connection(port: 8060)
 
         path = "/keypress/#{@commands[command]}"
         response = conn.post path
@@ -56,11 +52,7 @@ module RokuBuilder
     # @param text [String] The text to type on the device
     # @return [Boolean] Success
     def type(text:)
-      conn = Faraday.new(url: "#{@url}:8060") do |f|
-        f.request :multipart
-        f.request :url_encoded
-        f.adapter Faraday.default_adapter
-      end
+      conn = multipart_connection(port: 8060)
       text.split(//).each do |c|
         path = "/keypress/LIT_#{CGI::escape(c)}"
         response = conn.post path

data/lib/roku_builder/packager.rb

@@ -11,13 +11,7 @@ module RokuBuilder
     def package(app_name_version:, out_file:, password:)
       # Sign package
       path = "/plugin_package"
-      conn = Faraday.new(url: @url) do |f|
-        f.headers['Content-Type'] = Faraday::Request::Multipart.mime_type
-        f.request :digest, @dev_username, @dev_password
-        f.request :multipart
-        f.request :url_encoded
-        f.adapter Faraday.default_adapter
-      end
+      conn = multipart_connection
       payload =  {
         mysubmit: "Package",
         app_name: app_name_version,