raindrop 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7148b543f6cdcbd94afeec11799f20ed1f8fa157f31273da4e79d6143f6dc4fd
+  data.tar.gz: 77696f09d91334cfebd665e24e4dcbb2466a5f350a2db1b2fc54813f631a0d13
+SHA512:
+  metadata.gz: 0a36518c713fa9813937a64575dcd491af37ad3c02294b0f7d0617ab4709a816953d506b84c977729431dfd671cc6718fcfee98de6a681a4c3a7c94e100fe41a
+  data.tar.gz: 4c450619941ec53ee1b193a4d07643fe2835f3adb9cbaaf78d0bb19aaabea4e36a9da81e4afbcf33fb78c2a02998ac35e2b83b2efdfdaabbea84f405a6d0075a

data/README.md

@@ -0,0 +1 @@
+# raindrop

data/exe/raindrop

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+
+require "raindrop"
+
+exit Raindrop::CLI.new(ARGV).run

data/lib/raindrop/cli.rb

@@ -0,0 +1,660 @@
+# frozen_string_literal: true
+
+require "io/console"
+require "json"
+require "optparse"
+require "uri"
+
+require_relative "client"
+require_relative "config"
+require_relative "errors"
+require_relative "oauth"
+
+module Raindrop
+  class CLI
+    SUCCESS = 0
+    FAILURE = 1
+    DEFAULT_SEARCH_LIMIT = 50
+    MAX_SEARCH_LIMIT = 50
+
+    def initialize(argv, stdin: $stdin, stdout: $stdout, stderr: $stderr, config: nil)
+      @argv = argv.dup
+      @stdin = stdin
+      @stdout = stdout
+      @stderr = stderr
+      @config = config || Config.new
+    end
+
+    def run
+      command = @argv.shift
+
+      case command
+      when "auth"
+        run_auth(@argv)
+      when "config"
+        run_config(@argv)
+      when "add"
+        add(@argv)
+      when "search"
+        search(@argv)
+      when "get"
+        get(@argv)
+      when "delete"
+        delete(@argv)
+      when "tags"
+        tags(@argv)
+      when "collections"
+        collections(@argv)
+      when "-h", "--help", nil
+        print_usage
+        SUCCESS
+      else
+        @stderr.puts "Unknown command: #{command}"
+        print_usage(@stderr)
+        FAILURE
+      end
+    rescue OptionParser::ParseError => e
+      @stderr.puts e.message
+      FAILURE
+    rescue Error => e
+      @stderr.puts e.message
+      FAILURE
+    end
+
+    private
+
+    def run_auth(argv)
+      subcommand = argv.shift
+
+      case subcommand
+      when "login"
+        auth_login(argv)
+      when "token"
+        reject_arguments!(argv)
+        raise AuthenticationError, "Test token authentication is not supported. Run `raindrop auth login`."
+      when "status"
+        auth_status(argv)
+      when "logout"
+        auth_logout(argv)
+      when "-h", "--help", nil
+        print_auth_usage
+        SUCCESS
+      else
+        @stderr.puts "Unknown auth command: #{subcommand}"
+        print_auth_usage(@stderr)
+        FAILURE
+      end
+    end
+
+    def run_config(argv)
+      subcommand = argv.shift
+
+      case subcommand
+      when "path"
+        config_path(argv)
+      when nil
+        config_show(argv)
+      when "-h", "--help"
+        print_config_usage
+        SUCCESS
+      else
+        @stderr.puts "Unknown config command: #{subcommand}"
+        print_config_usage(@stderr)
+        FAILURE
+      end
+    end
+
+    def auth_login(argv)
+      options = parse_auth_login_options(argv)
+      reject_arguments!(argv)
+
+      oauth = OAuth.new
+      code = options.fetch(:code)
+      redirect_uri = options.fetch(:redirect_uri) || OAuth::DEFAULT_REDIRECT_URI
+      if code.to_s.strip.empty?
+        @stdout.puts "Redirect URI:"
+        @stdout.puts redirect_uri
+        @stdout.puts
+        @stdout.puts "Open this URL:"
+        @stdout.puts oauth.authorization_url(
+          client_id: options.fetch(:client_id),
+          redirect_uri: redirect_uri
+        )
+        @stdout.puts "Waiting for OAuth callback on #{redirect_uri}"
+        code = oauth.receive_authorization_code(redirect_uri: redirect_uri)
+      end
+      raise AuthenticationError, "Authorization code is empty." if code.to_s.strip.empty?
+
+      payload = oauth.exchange_code(
+        client_id: options.fetch(:client_id),
+        client_secret: options.fetch(:client_secret),
+        redirect_uri: redirect_uri,
+        code: code.strip
+      )
+      @config.save_oauth_token(payload)
+      @stdout.puts "OAuth token saved to #{@config.path}"
+      SUCCESS
+    end
+
+    def auth_status(argv)
+      reject_arguments!(argv)
+
+      token = @config.access_token
+
+      if token.empty?
+        @stdout.puts "Not authenticated. Run `raindrop auth login`."
+        FAILURE
+      elsif @config.auth_type != "oauth"
+        @stdout.puts "Test token authentication is not supported. Run `raindrop auth login`."
+        FAILURE
+      else
+        @stdout.puts "Authenticated by #{@config.path}"
+        SUCCESS
+      end
+    end
+
+    def auth_logout(argv)
+      reject_arguments!(argv)
+
+      deleted = @config.delete_access_token
+      if deleted
+        @stdout.puts "Token removed from #{@config.path}"
+      else
+        @stdout.puts "No token found in #{@config.path}"
+      end
+
+      SUCCESS
+    end
+
+    def config_path(argv)
+      reject_arguments!(argv)
+      @stdout.puts @config.path
+      SUCCESS
+    end
+
+    def config_show(argv)
+      reject_arguments!(argv)
+
+      type = @config.auth_type
+      token = @config.access_token
+
+      if type.empty? || token.empty?
+        @stdout.puts "Auth: not configured"
+      elsif type != "oauth"
+        @stdout.puts "Auth: unsupported"
+        @stdout.puts "Type: #{type}"
+        @stdout.puts "Run `raindrop auth login`."
+      else
+        @stdout.puts "Auth: #{type}"
+        @stdout.puts "Access token: [REDACTED]"
+        @stdout.puts "Refresh token: #{@config.refresh_token? ? "[REDACTED]" : "not stored"}"
+        @stdout.puts "Token type: #{@config.token_type.empty? ? "unknown" : @config.token_type}"
+        @stdout.puts "Expires in: #{@config.expires_in || "unknown"}"
+      end
+
+      SUCCESS
+    end
+
+    def add(argv)
+      options = parse_add_options(argv)
+      link = parse_url(argv.shift)
+      reject_arguments!(argv)
+
+      payload = authenticated_client.create_raindrop(
+        link,
+        title: options.fetch(:title),
+        excerpt: options.fetch(:description),
+        note: options.fetch(:note),
+        tags: options.fetch(:tags),
+        collection_id: options.fetch(:collection_id)
+      )
+      item = payload.fetch("item", {})
+
+      if options.fetch(:json)
+        print_json_item(item)
+      else
+        print_raindrop_detail(item)
+      end
+
+      SUCCESS
+    end
+
+    def search(argv)
+      options = parse_search_options(argv)
+      query = build_search_query(argv, options)
+      raise SearchError, "Search query is required." if query.empty? && search_query_required?(options)
+
+      if options.fetch(:all)
+        search_all(
+          authenticated_client,
+          query,
+          collection_id: search_collection_id(options),
+          json: options.fetch(:json)
+        )
+      else
+        payload = authenticated_client.search_raindrops(
+          query,
+          collection_id: search_collection_id(options),
+          perpage: options.fetch(:limit)
+        )
+        print_search_items(payload.fetch("items", []), json: options.fetch(:json))
+      end
+
+      SUCCESS
+    end
+
+    def get(argv)
+      options = parse_get_options(argv)
+      id = parse_raindrop_id(argv.shift)
+      reject_arguments!(argv)
+
+      payload = authenticated_client.get_raindrop(id)
+      item = payload.fetch("item", {})
+
+      if options.fetch(:json)
+        print_json_item(item)
+      else
+        print_raindrop_detail(item)
+      end
+
+      SUCCESS
+    end
+
+    def delete(argv)
+      options = parse_delete_options(argv)
+      id = parse_raindrop_id(argv.shift)
+      reject_arguments!(argv)
+
+      payload = authenticated_client.delete_raindrop(id)
+      print_delete_result(id, payload, json: options.fetch(:json))
+
+      SUCCESS
+    end
+
+    def tags(argv)
+      reject_arguments!(argv)
+
+      payload = authenticated_client.tags
+      items = payload.fetch("items", [])
+
+      if items.empty?
+        @stdout.puts "No tags found."
+      else
+        items.each do |item|
+          @stdout.puts "#{item["_id"]}\t#{item["count"]}"
+        end
+      end
+
+      SUCCESS
+    end
+
+    def collections(argv)
+      reject_arguments!(argv)
+
+      items = authenticated_client.root_collections.fetch("items", []) +
+              authenticated_client.child_collections.fetch("items", [])
+      items = unique_items_by_id(items)
+
+      if items.empty?
+        @stdout.puts "No collections found."
+      else
+        items.each do |item|
+          @stdout.puts "#{item["_id"]}\t#{item["title"]}\t#{item["count"]}"
+        end
+      end
+
+      SUCCESS
+    end
+
+    def authenticated_client
+      @authenticated_client ||= begin
+        token = @config.access_token
+        raise AuthenticationError, "Not authenticated. Run `raindrop auth login`." if token.empty?
+        raise AuthenticationError, "Test token authentication is not supported. Run `raindrop auth login`." unless @config.auth_type == "oauth"
+
+        Client.new(token: token)
+      end
+    end
+
+    def parse_auth_login_options(argv)
+      options = { client_id: nil, client_secret: nil, redirect_uri: nil, code: nil }
+      parser = OptionParser.new do |opts|
+        opts.on("--client-id ID") do |client_id|
+          options[:client_id] = client_id
+        end
+
+        opts.on("--client-secret SECRET") do |client_secret|
+          options[:client_secret] = client_secret
+        end
+
+        opts.on("--redirect-uri URI") do |redirect_uri|
+          options[:redirect_uri] = redirect_uri
+        end
+
+        opts.on("--code CODE") do |code|
+          options[:code] = code
+        end
+      end
+      parser.parse!(argv)
+      validate_auth_login_options!(options)
+      options
+    end
+
+    def parse_add_options(argv)
+      options = { json: false, title: nil, description: nil, note: nil, tags: [], collection_id: nil }
+      parser = OptionParser.new do |opts|
+        opts.on("--json") do
+          options[:json] = true
+        end
+
+        opts.on("--title TITLE") do |title|
+          options[:title] = title
+        end
+
+        opts.on("--description DESCRIPTION") do |description|
+          options[:description] = description
+        end
+
+        opts.on("--note NOTE") do |note|
+          options[:note] = note
+        end
+
+        opts.on("--tag TAG") do |tag|
+          options[:tags] << tag
+        end
+
+        opts.on("--collection ID", Integer) do |collection_id|
+          options[:collection_id] = collection_id
+        end
+      end
+      parser.parse!(argv)
+      validate_add_options!(options)
+      options
+    end
+
+    def parse_get_options(argv)
+      options = { json: false }
+      parser = OptionParser.new do |opts|
+        opts.on("--json") do
+          options[:json] = true
+        end
+      end
+      parser.parse!(argv)
+      options
+    end
+
+    def parse_delete_options(argv)
+      options = { json: false }
+      parser = OptionParser.new do |opts|
+        opts.on("--json") do
+          options[:json] = true
+        end
+      end
+      parser.parse!(argv)
+      options
+    end
+
+    def parse_raindrop_id(value)
+      raise OptionParser::MissingArgument, "ID" if value.to_s.strip.empty?
+
+      id = Integer(value, exception: false)
+      raise OptionParser::InvalidArgument, value if id.nil? || id <= 0
+
+      id
+    end
+
+    def parse_url(value)
+      raise OptionParser::MissingArgument, "URL" if value.to_s.strip.empty?
+
+      uri = URI.parse(value)
+      return value if uri.is_a?(URI::HTTP) && !uri.host.to_s.empty?
+
+      raise OptionParser::InvalidArgument, value
+    rescue URI::InvalidURIError
+      raise OptionParser::InvalidArgument, value
+    end
+
+    def validate_add_options!(options)
+      validate_optional_text!("title", options.fetch(:title))
+      validate_optional_text!("description", options.fetch(:description))
+      validate_optional_text!("note", options.fetch(:note))
+      raise OptionParser::InvalidArgument, "tag" unless options.fetch(:tags).all? { |tag| !tag.to_s.strip.empty? }
+    end
+
+    def validate_optional_text!(name, value)
+      return if value.nil? || !value.to_s.strip.empty?
+
+      raise OptionParser::InvalidArgument, name
+    end
+
+    def validate_auth_login_options!(options)
+      %i[client_id client_secret].each do |name|
+        validate_required_text!(name.to_s.tr("_", "-"), options.fetch(name))
+      end
+      parse_url(options.fetch(:redirect_uri)) unless options.fetch(:redirect_uri).nil?
+    end
+
+    def validate_required_text!(name, value)
+      raise OptionParser::MissingArgument, name if value.nil?
+      raise OptionParser::InvalidArgument, name if value.to_s.strip.empty?
+    end
+
+    def parse_search_options(argv)
+      options = { limit: DEFAULT_SEARCH_LIMIT, all: false, collection_id: nil, json: false, tags: [] }
+      limit_option_used = false
+      parser = OptionParser.new do |opts|
+        opts.on("--all") do
+          options[:all] = true
+        end
+
+        opts.on("--json") do
+          options[:json] = true
+        end
+
+        opts.on("--collection ID", Integer) do |collection_id|
+          options[:collection_id] = collection_id
+        end
+
+        opts.on("--limit LIMIT", Integer) do |limit|
+          options[:limit] = limit
+          limit_option_used = true
+        end
+
+        opts.on("--tag TAG") do |tag|
+          options[:tags] << tag
+        end
+      end
+      parser.parse!(argv)
+      validate_search_options!(options, limit_option_used)
+      options
+    end
+
+    def build_search_query(argv, options)
+      query = argv.join(" ").strip
+      tag_query = options.fetch(:tags).map { |tag| format_tag_query(tag) }.join(" ")
+      [query, tag_query].reject(&:empty?).join(" ")
+    end
+
+    def validate_search_options!(options, limit_option_used)
+      validate_limit!(options.fetch(:limit))
+      validate_tags!(options.fetch(:tags))
+
+      if options.fetch(:all) && limit_option_used
+        raise SearchError, "`--all` cannot be used with `--limit`."
+      end
+    end
+
+    def search_query_required?(options)
+      options.fetch(:collection_id).nil?
+    end
+
+    def search_collection_id(options)
+      options.fetch(:collection_id) || 0
+    end
+
+    def validate_limit!(limit)
+      return if limit.between?(1, MAX_SEARCH_LIMIT)
+
+      raise SearchError, "Search limit must be between 1 and #{MAX_SEARCH_LIMIT}."
+    end
+
+    def validate_tags!(tags)
+      return if tags.all? { |tag| !tag.to_s.strip.empty? }
+
+      raise SearchError, "Search tag must not be empty."
+    end
+
+    def format_tag_query(tag)
+      tag = tag.strip
+      return %(#"#{tag}") if tag.include?(" ")
+
+      "##{tag}"
+    end
+
+    def search_all(client, query, collection_id:, json:)
+      page = 0
+      fetched = 0
+      found = false
+      collected_items = []
+
+      loop do
+        payload = client.search_raindrops(query, collection_id: collection_id, perpage: 50, page: page)
+        items = payload.fetch("items", [])
+        break if items.empty?
+
+        if json
+          collected_items.concat(items)
+        else
+          print_search_items(items)
+        end
+        found = true
+
+        fetched += items.size
+        count = payload["count"].to_i
+        break if count.positive? && fetched >= count
+
+        page += 1
+        sleep 1
+      end
+
+      if json
+        print_json_items(collected_items)
+      else
+        @stdout.puts "No raindrops found." unless found
+      end
+    end
+
+    def print_search_items(items, json: false)
+      return print_json_items(items) if json
+
+      if items.empty?
+        @stdout.puts "No raindrops found."
+      else
+        items.each do |item|
+          id = item["_id"].to_s
+          link = item["link"].to_s
+          title = item["title"].to_s.strip
+          title = link if title.empty?
+          @stdout.puts "#{id}  #{title}"
+          @stdout.puts "            #{link}"
+          @stdout.puts
+        end
+      end
+    end
+
+    def print_json_items(items)
+      @stdout.puts JSON.generate(items)
+    end
+
+    def print_json_item(item)
+      @stdout.puts JSON.generate(item)
+    end
+
+    def print_delete_result(id, payload, json: false)
+      if json
+        print_json_item(payload)
+      else
+        @stdout.puts "Deleted raindrop: #{id}"
+      end
+    end
+
+    def print_raindrop_detail(item)
+      id = item["_id"].to_s
+      link = item["link"].to_s
+      title = item["title"].to_s.strip
+      title = link if title.empty?
+      tags = Array(item["tags"]).map(&:to_s)
+      created = item["created"].to_s
+      updated = item["lastUpdate"].to_s
+      excerpt = item["excerpt"].to_s.strip
+      note = item["note"].to_s.strip
+
+      @stdout.puts "ID: #{id}" unless id.empty?
+      @stdout.puts "Title: #{title}" unless title.empty?
+      @stdout.puts "URL: #{link}" unless link.empty?
+      @stdout.puts "Tags: #{tags.join(", ")}" unless tags.empty?
+      @stdout.puts "Created: #{created}" unless created.empty?
+      @stdout.puts "Updated: #{updated}" unless updated.empty?
+
+      print_detail_text("Description", excerpt)
+      print_detail_text("Note", note)
+    end
+
+    def print_detail_text(label, text)
+      return if text.empty?
+
+      @stdout.puts "#{label}:"
+      @stdout.puts text
+    end
+
+    def unique_items_by_id(items)
+      items.each_with_object({}) do |item, indexed_items|
+        id = item["_id"]
+        next if id.nil?
+
+        indexed_items[id] ||= item
+      end.values
+    end
+
+    def reject_arguments!(argv)
+      raise OptionParser::InvalidArgument, argv.join(" ") unless argv.empty?
+    end
+
+    def print_usage(io = @stdout)
+      io.puts <<~USAGE
+        Usage: raindrop <command>
+
+        Commands:
+          add     Add a raindrop
+          auth    Manage authentication
+          config  Show configuration information
+          delete  Delete a saved raindrop
+          get     Show a saved raindrop
+          search  Search saved raindrops
+          tags    List tags
+          collections
+                  List collections
+      USAGE
+    end
+
+    def print_auth_usage(io = @stdout)
+      io.puts <<~USAGE
+        Usage: raindrop auth <command>
+
+        Commands:
+          login   Login with OAuth
+          status  Show authentication status
+          logout  Remove the stored token
+      USAGE
+    end
+
+    def print_config_usage(io = @stdout)
+      io.puts <<~USAGE
+        Usage: raindrop config [command]
+
+        Commands:
+          path    Show config file path
+      USAGE
+    end
+  end
+end

data/lib/raindrop/client.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+require_relative "errors"
+
+module Raindrop
+  class Client
+    BASE_URL = "https://api.raindrop.io/rest/v1"
+
+    def initialize(token:, connection: nil)
+      @token = token
+      @connection = connection || default_connection
+    end
+
+    def search_raindrops(query, collection_id: 0, perpage: 10, page: 0)
+      response = @connection.get("raindrops/#{collection_id}") do |request|
+        request.params.update(
+          "search" => query,
+          "perpage" => perpage,
+          "page" => page
+        )
+      end
+      handle_response(response)
+    rescue Faraday::ConnectionFailed => e
+      raise ApiError, "API request failed: #{e.message}"
+    end
+
+    def get_raindrop(id)
+      response = @connection.get("raindrop/#{id}")
+      handle_response(response)
+    rescue Faraday::ConnectionFailed => e
+      raise ApiError, "API request failed: #{e.message}"
+    end
+
+    def create_raindrop(link, title: nil, excerpt: nil, note: nil, tags: [], collection_id: nil)
+      response = @connection.post("raindrop") do |request|
+        request.headers["Content-Type"] = "application/json"
+        request.body = JSON.generate(create_raindrop_body(link, title, excerpt, note, tags, collection_id))
+      end
+      handle_response(response)
+    rescue Faraday::ConnectionFailed => e
+      raise ApiError, "API request failed: #{e.message}"
+    end
+
+    def delete_raindrop(id)
+      response = @connection.delete("raindrop/#{id}")
+      handle_response(response)
+    rescue Faraday::ConnectionFailed => e
+      raise ApiError, "API request failed: #{e.message}"
+    end
+
+    def tags(collection_id: 0)
+      response = @connection.get("tags/#{collection_id}")
+      handle_response(response)
+    rescue Faraday::ConnectionFailed => e
+      raise ApiError, "API request failed: #{e.message}"
+    end
+
+    def root_collections
+      response = @connection.get("collections")
+      handle_response(response)
+    rescue Faraday::ConnectionFailed => e
+      raise ApiError, "API request failed: #{e.message}"
+    end
+
+    def child_collections
+      response = @connection.get("collections/childrens")
+      handle_response(response)
+    rescue Faraday::ConnectionFailed => e
+      raise ApiError, "API request failed: #{e.message}"
+    end
+
+    private
+
+    def default_connection
+      Faraday.new(url: BASE_URL) do |connection|
+        connection.headers["Accept"] = "application/json"
+        connection.headers["Authorization"] = "Bearer #{@token}"
+      end
+    end
+
+    def create_raindrop_body(link, title, excerpt, note, tags, collection_id)
+      body = {
+        "link" => link,
+        "pleaseParse" => {}
+      }
+      body["title"] = title unless title.to_s.empty?
+      body["excerpt"] = excerpt unless excerpt.to_s.empty?
+      body["note"] = note unless note.to_s.empty?
+      body["tags"] = tags unless tags.empty?
+      body["collection"] = { "$id" => collection_id } unless collection_id.nil?
+      body
+    end
+
+    def handle_response(response)
+      payload = parse_payload(response)
+      return payload if response.success?
+
+      raise ApiError, error_message(response, payload)
+    end
+
+    def parse_payload(response)
+      body = response.body.to_s
+      return {} if body.empty?
+
+      JSON.parse(body)
+    rescue JSON::ParserError => e
+      return {} unless response.success?
+
+      raise ApiError, "Failed to parse API response: #{e.message}"
+    end
+
+    def error_message(response, payload)
+      if response.status == 401
+        return "Authentication failed. The stored token may be invalid. Run `raindrop auth login` again."
+      end
+
+      message = payload["errorMessage"] || payload["message"] || response.reason_phrase || "HTTP error"
+      "API request failed: #{response.status} #{message}"
+    end
+  end
+end

data/lib/raindrop/config.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "yaml"
+
+require_relative "errors"
+
+module Raindrop
+  class Config
+    CONFIG_DIR_MODE = 0o700
+    CONFIG_FILE_MODE = 0o600
+
+    attr_reader :path
+
+    def initialize
+      @path = File.expand_path(self.class.default_path)
+    end
+
+    def self.default_path
+      config_home = ENV.fetch("XDG_CONFIG_HOME") do
+        File.join(Dir.home, ".config")
+      end
+
+      File.join(config_home, "raindrop-cli", "config.yml")
+    end
+
+    def access_token
+      data.dig("auth", "access_token").to_s.strip
+    end
+
+    def auth_type
+      data.dig("auth", "type").to_s.strip
+    end
+
+    def refresh_token?
+      !data.dig("auth", "refresh_token").to_s.strip.empty?
+    end
+
+    def token_type
+      data.dig("auth", "token_type").to_s.strip
+    end
+
+    def expires_in
+      data.dig("auth", "expires_in")
+    end
+
+    def save_oauth_token(payload)
+      access_token = payload["access_token"].to_s.strip
+      raise ConfigError, "OAuth response did not include an access token." if access_token.empty?
+
+      update do |data|
+        data["auth"] = {
+          "type" => "oauth",
+          "access_token" => access_token
+        }
+        data["auth"]["refresh_token"] = payload["refresh_token"].to_s unless payload["refresh_token"].to_s.empty?
+        data["auth"]["token_type"] = payload["token_type"].to_s unless payload["token_type"].to_s.empty?
+        data["auth"]["expires_in"] = payload["expires_in"] if payload.key?("expires_in")
+      end
+
+      true
+    end
+
+    def delete_access_token
+      return false unless File.file?(@path)
+
+      data = read_data
+      token = data.dig("auth", "access_token").to_s.strip
+      return false if token.empty?
+
+      data.delete("auth")
+      write_data(data)
+
+      true
+    end
+
+    private
+
+    def data
+      return {} unless File.file?(@path)
+
+      read_data
+    end
+
+    def update
+      data = self.data
+      yield data
+      write_data(data)
+    end
+
+    def read_data
+      YAML.safe_load_file(@path, permitted_classes: [], aliases: false) || {}
+    rescue Psych::SyntaxError => e
+      raise ConfigError, "Failed to read config file: #{e.message}"
+    end
+
+    def write_data(data)
+      if data.empty?
+        File.delete(@path) if File.file?(@path)
+        return
+      end
+
+      ensure_parent_directory!
+      File.write(@path, YAML.dump(data), mode: "w", perm: CONFIG_FILE_MODE)
+      File.chmod(CONFIG_FILE_MODE, @path)
+    end
+
+    def ensure_parent_directory!
+      dir = File.dirname(@path)
+      FileUtils.mkdir_p(dir, mode: CONFIG_DIR_MODE)
+      File.chmod(CONFIG_DIR_MODE, dir)
+    end
+  end
+end

data/lib/raindrop/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Raindrop
+  class Error < StandardError; end
+  class AuthenticationError < Error; end
+  class ApiError < Error; end
+  class ConfigError < Error; end
+  class SearchError < Error; end
+end

data/lib/raindrop/oauth.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+require "socket"
+require "uri"
+
+require_relative "errors"
+
+module Raindrop
+  class OAuth
+    BASE_URL = "https://api.raindrop.io/v1"
+    AUTHORIZATION_URL = "#{BASE_URL}/oauth/authorize"
+    DEFAULT_REDIRECT_URI = "http://127.0.0.1:42813/callback"
+
+    def initialize(connection: nil)
+      @connection = connection || default_connection
+    end
+
+    def authorization_url(client_id:, redirect_uri:)
+      query = URI.encode_www_form(
+        "response_type" => "code",
+        "client_id" => client_id,
+        "redirect_uri" => redirect_uri
+      )
+      "#{AUTHORIZATION_URL}?#{query}"
+    end
+
+    def exchange_code(client_id:, client_secret:, redirect_uri:, code:)
+      response = @connection.post("oauth/access_token") do |request|
+        request.headers["Content-Type"] = "application/json"
+        request.body = JSON.generate(
+          "grant_type" => "authorization_code",
+          "code" => code,
+          "client_id" => client_id,
+          "client_secret" => client_secret,
+          "redirect_uri" => redirect_uri
+        )
+      end
+      handle_response(response)
+    rescue Faraday::ConnectionFailed => e
+      raise ApiError, "OAuth request failed: #{e.message}"
+    end
+
+    def receive_authorization_code(redirect_uri:)
+      redirect = URI.parse(redirect_uri)
+      server = TCPServer.new(redirect.host, redirect.port)
+      socket = server.accept
+      request_line = socket.gets.to_s
+      code = authorization_code_from_request(request_line, expected_path: redirect.path)
+      write_callback_response(socket, "Authentication complete. You can close this window.")
+      code
+    ensure
+      socket&.close
+      server&.close
+    end
+
+    private
+
+    def default_connection
+      Faraday.new(url: BASE_URL) do |connection|
+        connection.headers["Accept"] = "application/json"
+      end
+    end
+
+    def handle_response(response)
+      payload = parse_payload(response)
+      return payload if response.success?
+
+      message = payload["error"] || payload["errorMessage"] || payload["message"] || response.reason_phrase || "HTTP error"
+      raise ApiError, "OAuth request failed: #{response.status} #{message}"
+    end
+
+    def parse_payload(response)
+      body = response.body.to_s
+      return {} if body.empty?
+
+      JSON.parse(body)
+    rescue JSON::ParserError => e
+      return {} unless response.success?
+
+      raise ApiError, "Failed to parse OAuth response: #{e.message}"
+    end
+
+    def authorization_code_from_request(request_line, expected_path:)
+      target = request_line.split[1].to_s
+      raise AuthenticationError, "Authorization code is empty." if target.empty?
+
+      uri = URI.parse(target)
+      raise AuthenticationError, "Unexpected OAuth callback path: #{uri.path}" unless uri.path == expected_path
+
+      query = URI.decode_www_form(uri.query.to_s).to_h
+      raise AuthenticationError, "OAuth authorization failed: #{query.fetch("error")}" if query.key?("error")
+
+      code = query.fetch("code", "").to_s.strip
+      raise AuthenticationError, "Authorization code is empty." if code.empty?
+
+      code
+    rescue URI::InvalidURIError
+      raise AuthenticationError, "Authorization code is empty."
+    end
+
+    def write_callback_response(socket, body)
+      socket.write "HTTP/1.1 200 OK\r\n"
+      socket.write "Content-Type: text/plain; charset=utf-8\r\n"
+      socket.write "Content-Length: #{body.bytesize}\r\n"
+      socket.write "Connection: close\r\n"
+      socket.write "\r\n"
+      socket.write body
+    end
+  end
+end

data/lib/raindrop/version.rb

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

data/lib/raindrop.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "raindrop/cli"
+require_relative "raindrop/client"
+require_relative "raindrop/oauth"
+require_relative "raindrop/version"

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: raindrop
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- utakaha
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A small Ruby command line client for searching and managing Raindrop.io
+  bookmarks.
+executables:
+- raindrop
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- exe/raindrop
+- lib/raindrop.rb
+- lib/raindrop/cli.rb
+- lib/raindrop/client.rb
+- lib/raindrop/config.rb
+- lib/raindrop/errors.rb
+- lib/raindrop/oauth.rb
+- lib/raindrop/version.rb
+homepage: https://github.com/utakaha/raindrop.rb
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/utakaha/raindrop.rb
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Command line client for Raindrop.io
+test_files: []