sdls 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f93df7e380b117625c986d4dd8ca5ad1ab6aa546fdc1a78a6661bd557b43300b
-  data.tar.gz: 3b2d8acc8c68b2220cfd034846ebb5a8cfe3719592df460a1901322651075420
+  metadata.gz: 80ab5c882f651304f21232bd31b312a328d08531c13db2a023e3a6ea28d47fd5
+  data.tar.gz: b40ac3decbb740eddef2e8a97e16e8079783bfa858b73ab922ef8849c3076eb6
 SHA512:
-  metadata.gz: fb0196fef41147ca868fa1e1e2fbc110a3627550efd76b01280b62697b696b62dd091471c015ee25fad4c0ad7df844c3ea1de30e08c9e12c975f2afe2c022ab5
-  data.tar.gz: bcdff97846e1d3479211d6763c88fc0a3fdd6a7f644139c8c35e6a19beb843f2e086ff70be854aff043e2f4a412533008d3fa2c2c4524ac660a489d608e2a024
+  metadata.gz: c2193a8357febf6e99d1164bdbdd7b12fbd7e374ba851ef267fda2b53f09bccde84fed20ddcc03d6ca72da39d177a6c698e8028abb04e0abbd84a2a058938a22
+  data.tar.gz: 48924c08c46cc3862e61cd6101c5b0c68b75500fdd3f43c46e9eb7c969591864954489b141e3bf0b9f092c888ad987e9790a1651e32be0c19bc288ed82c8add0

data/lib/sdls/cli.rb

@@ -23,7 +23,8 @@ module SDLS
           host: current_config.host,
           username: current_config.username,
           password: current_config.password,
-          op_item_name: current_config.op_item_name
+          op_item_name: current_config.op_item_name,
+          op_account: current_config.op_account
         )
       end
 
@@ -48,8 +49,9 @@ module SDLS
       puts "  host: #{current_config.host}"
       puts "  username: #{current_config.username}"
       puts "  password: [REDACTED]"
-      puts "  op_item_name: #{current_config.op_item_name}" if current_config.op_item_name
-      puts "  directories: #{current_config.directories.join(", ")}" if current_config.directories.any?
+      puts "  op_item_name: #{current_config.op_item_name || "[NOT SET]"}"
+      puts "  op_account: #{current_config.op_account || "[NOT SET]"}"
+      puts "  directories: #{current_config.directories.join(", ")}" if current_config.directories&.any?
     end
 
     desc "connect", "Verify connectivity and authentication with the server"

data/lib/sdls/client.rb

@@ -2,19 +2,21 @@ require "net/http"
 require "uri"
 require "json"
 require "open3"
+require "tty-prompt"
 
 module SDLS
   class Client
-    def initialize(host:, username:, password:, op_item_name: nil)
+    def initialize(host:, username:, password:, op_item_name: nil, op_account: nil)
       @host = host
       @username = username
       @password = password
       @op_item_name = op_item_name
+      @op_account = op_account
     end
 
     def authenticate(otp: nil)
-      uri = build_uri("/webapi/auth.cgi", auth_params(otp))
-      response_body = make_request(uri)
+      uri = URI.join(@host, "/webapi/auth.cgi")
+      response_body = make_post_request(uri, auth_params(otp))
 
       handle_auth_response(response_body, otp)
     rescue => e
@@ -26,7 +28,7 @@ module SDLS
       sid = authenticate
       return false unless sid
 
-      uri = build_uri("/webapi/DownloadStation/task.cgi")
+      uri = URI.join(@host, "/webapi/DownloadStation/task.cgi")
       data = download_params(magnet, destination, sid)
 
       response = Net::HTTP.post_form(uri, data)
@@ -43,14 +45,8 @@ module SDLS
 
     private
 
-    def build_uri(endpoint, params = nil)
-      uri = URI.parse("#{@host}#{endpoint}")
-      uri.query = URI.encode_www_form(params) if params
-      uri
-    end
-
-    def make_request(uri)
-      response = Net::HTTP.get_response(uri)
+    def make_post_request(uri, params)
+      response = Net::HTTP.post_form(uri, params)
       raise "HTTP error: #{response.code}" unless response.is_a?(Net::HTTPSuccess)
       JSON.parse(response.body)
     end
@@ -96,16 +92,40 @@ module SDLS
     end
 
     def retry_with_otp
-      puts "OTP required for authentication. Fetching from 1Password..."
-      fetched_otp = fetch_otp_from_1password
-      return authenticate(otp: fetched_otp) if fetched_otp
-      raise "Could not retrieve OTP from 1Password"
+      puts "OTP required for authentication."
+
+      # Try 1Password first if configured and available
+      if @op_item_name && onepassword_cli_available?
+        puts "Fetching OTP from 1Password..."
+        fetched_otp = fetch_otp_from_1password
+        return authenticate(otp: fetched_otp) if fetched_otp
+        puts "Failed to retrieve OTP from 1Password, falling back to manual entry."
+      end
+
+      # Fallback to manual OTP entry
+      fetched_manual_otp = prompt_for_manual_otp
+      return authenticate(otp: fetched_manual_otp) if fetched_manual_otp
+
+      raise "Could not retrieve OTP"
+    end
+
+    def onepassword_cli_available?
+      return @op_cli_available unless @op_cli_available.nil?
+
+      @op_cli_available = if ENV.key?("SDLS_FORCE_OP_CLI")
+        ENV["SDLS_FORCE_OP_CLI"] == "true"
+      else
+        system("which op > /dev/null 2>&1")
+      end
     end
 
     def fetch_otp_from_1password
       return nil unless @op_item_name
 
-      stdout, stderr, status = Open3.capture3("op item get \"#{@op_item_name}\" --otp")
+      cmd = ["op", "item", "get", @op_item_name, "--otp"]
+      cmd += ["--account", @op_account] if @op_account && !@op_account.to_s.strip.empty?
+
+      stdout, stderr, status = Open3.capture3(*cmd)
       if status.success?
         stdout.strip
       else
@@ -113,5 +133,10 @@ module SDLS
         nil
       end
     end
+
+    def prompt_for_manual_otp
+      prompt = TTY::Prompt.new
+      prompt.mask("Please enter your OTP code:")
+    end
   end
 end

data/lib/sdls/config.rb

@@ -1,31 +1,192 @@
 # frozen_string_literal: true
 
 require "yaml"
+require "open3"
+require "tty-prompt"
 
 module SDLS
-  REQUIRED_KEYS = %i[host username password]
-  Config = Data.define(:host, :username, :password, :op_item_name, :directories) do
-    def self.load(path)
-      raise "Configuration file not found: #{path}" unless File.exist?(path)
+  # Configuration errors
+  class ConfigError < StandardError; end
 
-      data = YAML.load_file(path)
-      data = {} unless data.is_a?(Hash)
-      data = symbolize_keys(data)
+  class OnePasswordError < StandardError; end
 
-      missing_keys = REQUIRED_KEYS - data.keys
-      nil_keys = REQUIRED_KEYS.select { |k| data[k].nil? }
+  # Core configuration keys that must be present
+  REQUIRED_KEYS = %i[host].freeze
 
-      if missing_keys.any? || nil_keys.any?
-        raise "Configuration file (#{path}) is missing required keys or values: #{(missing_keys + nil_keys).uniq.join(", ")}"
+  Config = Data.define(:host, :username, :password, :op_item_name, :op_account, :directories) do
+    class << self
+      def load(path, prompt: nil)
+        validate_file_exists!(path)
+        data = load_and_parse_yaml(path)
+        credentials = resolve_credentials(data, prompt: prompt)
+
+        new(**data.merge(credentials))
+      rescue Psych::SyntaxError => e
+        raise ConfigError, "Error parsing configuration file (#{path}): #{e.message}"
       end
 
-      new(**data)
-    rescue Psych::SyntaxError => e
-      raise "Error parsing configuration file (#{path}): #{e.message}"
-    end
+      private
+
+      def validate_file_exists!(path)
+        raise ConfigError, "Configuration file not found: #{path}" unless File.exist?(path)
+      end
+
+      def load_and_parse_yaml(path)
+        data = YAML.load_file(path)
+        data = {} unless data.is_a?(Hash)
+        data = symbolize_keys(data)
+
+        validate_required_keys!(data, path)
+        set_defaults(data)
+      end
+
+      def validate_required_keys!(data, path)
+        missing_keys = REQUIRED_KEYS - data.keys
+        nil_keys = REQUIRED_KEYS.select { |k| data[k].nil? || data[k].to_s.strip.empty? }
+
+        if missing_keys.any? || nil_keys.any?
+          invalid_keys = (missing_keys + nil_keys).uniq
+          raise ConfigError, "Configuration file (#{path}) is missing required keys or values: #{invalid_keys.join(", ")}"
+        end
+      end
+
+      def set_defaults(data)
+        data[:op_item_name] ||= nil
+        data[:op_account] ||= nil
+        data[:directories] ||= []
+        data
+      end
+
+      def symbolize_keys(hash)
+        hash.to_h { |k, v| [k.to_sym, v] }
+      end
+
+      def resolve_credentials(data, prompt: nil)
+        op_item_name = data[:op_item_name]
+        op_account = data[:op_account]
+
+        # Check if we have both username and password from config
+        has_config_username = data[:username] && !data[:username].to_s.strip.empty?
+        has_config_password = data[:password] && !data[:password].to_s.strip.empty?
+
+        # If we have both credentials from config, use them
+        if has_config_username && has_config_password
+          return {
+            username: data[:username],
+            password: data[:password]
+          }
+        end
+
+        # If 1Password item is specified and we're missing some credentials, try to fetch from there
+        if op_item_name && !op_item_name.to_s.strip.empty? && (!has_config_username || !has_config_password)
+          onepassword_credentials = fetch_credentials_from_1password(op_item_name, op_account)
+          if onepassword_credentials[:success]
+            final_username = has_config_username ? data[:username] : onepassword_credentials[:username]
+            final_password = has_config_password ? data[:password] : onepassword_credentials[:password]
+
+            # If we still don't have username or password after 1Password, prompt for them
+            final_username ||= prompt_for_credential("username", mask: false, prompt: prompt)
+            final_password ||= prompt_for_credential("password", mask: true, prompt: prompt)
+
+            return {
+              username: final_username,
+              password: final_password
+            }
+          end
+        end
+
+        # Fallback to config file and manual entry
+        {
+          username: resolve_username(data[:username], nil, prompt: prompt),
+          password: resolve_password(data[:password], nil, prompt: prompt)
+        }
+      end
+
+      def resolve_username(config_username, op_username, prompt: nil)
+        # Priority 1: 1Password username if available
+        return op_username if op_username && !op_username.strip.empty?
 
-    def self.symbolize_keys(hash)
-      hash.to_h { |k, v| [k.to_sym, v] }
+        # Priority 2: Config file username if available
+        return config_username if config_username && !config_username.strip.empty?
+
+        # Priority 3: Manual entry
+        prompt_for_credential("username", mask: false, prompt: prompt)
+      end
+
+      def resolve_password(config_password, op_password, prompt: nil)
+        # Priority 1: 1Password password if available
+        return op_password if op_password && !op_password.strip.empty?
+
+        # Priority 2: Config file password if available
+        return config_password if config_password && !config_password.strip.empty?
+
+        # Priority 3: Manual entry
+        prompt_for_credential("password", mask: true, prompt: prompt)
+      end
+
+      def fetch_credentials_from_1password(op_item_name, op_account = nil)
+        return {success: false} unless onepassword_cli_available?
+
+        puts "Fetching credentials from 1Password for item: #{op_item_name}..."
+
+        username = fetch_field_from_1password(op_item_name, "username", op_account)
+        password = fetch_field_from_1password(op_item_name, "password", op_account)
+
+        puts "1Password item '#{op_item_name}' retrieved successfully."
+        puts "Username: #{username.nil? ? "not found" : username}"
+
+        if username || password
+          success_msg = []
+          success_msg << "username" if username
+          success_msg << "password" if password
+          puts "Successfully retrieved #{success_msg.join(" and ")} from 1Password"
+
+          {success: true, username: username, password: password}
+        else
+          puts "No credentials found in 1Password item"
+          {success: false}
+        end
+      rescue OnePasswordError => e
+        puts "1Password error: #{e.message}"
+        {success: false}
+      rescue => e
+        puts "Unexpected error fetching credentials from 1Password: #{e.message}"
+        {success: false}
+      end
+
+      def fetch_field_from_1password(op_item_name, field, op_account = nil)
+        cmd = ["op", "item", "get", op_item_name, "--fields", field, "--reveal"]
+        cmd += ["--account", op_account] if op_account && !op_account.to_s.strip.empty?
+
+        stdout, _, status = Open3.capture3(*cmd)
+
+        if status.success? && !stdout.strip.empty?
+          stdout.strip
+        end
+      rescue => e
+        raise OnePasswordError, "Failed to retrieve #{field} from 1Password: #{e.message}"
+      end
+
+      def onepassword_cli_available?
+        return @op_cli_available unless @op_cli_available.nil?
+
+        @op_cli_available = if ENV.key?("SDLS_FORCE_OP_CLI")
+          ENV["SDLS_FORCE_OP_CLI"] == "true"
+        else
+          system("which op > /dev/null 2>&1")
+        end
+      end
+
+      def prompt_for_credential(type, mask: false, prompt: nil)
+        puts "No #{type} available, please enter manually:"
+        prompt ||= TTY::Prompt.new
+
+        if mask
+          prompt.mask("Please enter your #{type}:")
+        else
+          prompt.ask("Please enter your #{type}:")
+        end
+      end
     end
   end
 end

data/lib/sdls/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sdls
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Camillo Visini
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: tty-prompt
   requirement: !ruby/object:Gem::Requirement
@@ -43,14 +43,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '2.0'
 description: A command-line interface for managing downloads on Synology Download
   Station.
 executables: