sdls 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 134c42aa266627ae45c1e085d2b33e36dda4a1a54ff91aac0c7c8af973f55ddd
-  data.tar.gz: 39ebe584b534cc372ec2de8c4c7f486e4b2075734fb8bab14207f1cea2ca9a18
+  metadata.gz: 1649a83c3850e7e6a8657edfa6fce674ca844211d5264ef016dd9ddc6c413e8f
+  data.tar.gz: f826f7983ee0a67f1c1aabaeb6e172df8541f76c63415dbbf028600d479beeef
 SHA512:
-  metadata.gz: 0a87ee27110e3e2adcecc1ee5ebdc22208a45edd552dbc2319c918f7120e78bae355fe54ee61e796536cc2e50f6c7661d91edcff9eef099152a8ada29c30f1f5
-  data.tar.gz: fe91dc17db9b7123d927583f3b10cfaec1265f1802ff279880a99123f5a8fe57f920072cafc41429bc2907dedfbcd5507c7c4945388178925ffea8c53870b394
+  metadata.gz: 17ab00c3765268aa845339d54e65caea98c69e791d3f9f1d13345ab6aea5c82bc58576449b0921b1e6d9720163e30c03337ad0e1b6fbd3241b60601fe13b13d1
+  data.tar.gz: 54eca13f2a055533da40642741dd1e897816ea0daed83b59108cc92d53040bdeac0d29ebe3a5cdedf9e4ed19dd43c055113f3ee43a5ef0d5005d2470647f3d9f

data/lib/sdls/cli.rb

@@ -48,8 +48,8 @@ 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 "  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,6 +2,7 @@ require "net/http"
 require "uri"
 require "json"
 require "open3"
+require "tty-prompt"
 
 module SDLS
   class Client
@@ -13,8 +14,8 @@ module SDLS
     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 +27,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 +44,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,10 +91,31 @@ 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
@@ -113,5 +129,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,189 @@
 # frozen_string_literal: true
 
 require "yaml"
+require "open3"
+require "tty-prompt"
 
 module SDLS
-  REQUIRED_KEYS = %i[host username password]
+  # Configuration errors
+  class ConfigError < StandardError; end
+
+  class OnePasswordError < StandardError; end
+
+  # Core configuration keys that must be present
+  REQUIRED_KEYS = %i[host].freeze
+
   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)
+    class << self
+      def load(path, prompt: nil)
+        validate_file_exists!(path)
+        data = load_and_parse_yaml(path)
+        credentials = resolve_credentials(data, prompt: prompt)
 
-      data = YAML.load_file(path)
-      data = {} unless data.is_a?(Hash)
-      data = symbolize_keys(data)
+        new(**data.merge(credentials))
+      rescue Psych::SyntaxError => e
+        raise ConfigError, "Error parsing configuration file (#{path}): #{e.message}"
+      end
 
-      missing_keys = REQUIRED_KEYS - data.keys
-      nil_keys = REQUIRED_KEYS.select { |k| data[k].nil? }
+      private
 
-      if missing_keys.any? || nil_keys.any?
-        raise "Configuration file (#{path}) is missing required keys or values: #{(missing_keys + nil_keys).uniq.join(", ")}"
+      def validate_file_exists!(path)
+        raise ConfigError, "Configuration file not found: #{path}" unless File.exist?(path)
       end
 
-      new(**data)
-    rescue Psych::SyntaxError => e
-      raise "Error parsing configuration file (#{path}): #{e.message}"
-    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[: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]
+
+        # 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)
+          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)
+        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")
+        password = fetch_field_from_1password(op_item_name, "password")
+
+        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)
+        stdout, _, status = Open3.capture3(
+          "op", "item", "get", op_item_name, "--fields", field, "--reveal"
+        )
+
+        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.0"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,16 +1,58 @@
 --- !ruby/object:Gem::Specification
 name: sdls
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Camillo Visini
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+- !ruby/object:Gem::Dependency
+  name: clipboard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 description: A command-line interface for managing downloads on Synology Download
-  Station
+  Station.
 executables:
 - sdls
 extensions: []