atproto_client 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e459f2369670aec62ba641789c28a0e06e8c28892c11c490237388a99602f8d3
+  data.tar.gz: 2795f534c54c0021a027699c6d58fa0f36b33680b80c060be0aff301d7fc3b73
+SHA512:
+  metadata.gz: 92223d17916001ae87453c85de3f4cfb34877f77c11e5ff31991eca0a58b2a744bd21ab3381463e78b4c8a21db816b99887105d7651f9fde4091e25251eb7f5b
+  data.tar.gz: 6b2fd5552ccfe4239345052892d03af7a36ac26d47536eab9f79b40980e369d8799ed44c0276b6de8f68fcece79e81e782fd0b2710c39ee55bd23b783468d7b0

data/README.md

@@ -0,0 +1,52 @@
+# ATProto Client
+
+Ruby client for the AT Protocol, with support for oauth/dpop authentication. It has been built and tested for bluesky but it should be agnostic of PDS. An omniauth strategy using this layer should appear soon.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'atproto_client'
+```
+
+## Usage
+
+```ruby
+# Configure the client (optional)
+AtProto.configure do |config|
+  config.base_url = "https://bsky.social"  # default
+end
+
+# Initialize a client
+client = AtProto::Client.new(access_token, refresh_token)
+
+# Should be able to fetch collections
+client.make_api_request(
+  :get,
+  "#{PDS_URL}/xrpc/#{lexicon}",
+  params:{ repo: "did:therepodid", collection: "app.bsky.feed.post"}
+)
+
+# Also gives a handful DPOP handler for any request (here an oauth example)
+dpop_handler = AtProto::DpopHandler.new(options.dpop_private_key)
+response = @dpop_handler.make_request(
+  token_url,
+  :post,
+  headers: { "Content-Type" => "application/json", "Accept" => "application/json" },
+  body: token_params
+)
+
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/lasercats/atproto_client.
+
+## License
+
+The gem is available as open source under the terms of the MIT License.

data/lib/atproto_client/client.rb

@@ -0,0 +1,57 @@
+module AtProto
+  class Client
+    attr_reader :access_token, :refresh_token, :dpop_handler
+
+    def initialize(access_token, refresh_token, dpop_handler = nil)
+      @access_token = access_token
+      @refresh_token = refresh_token
+      @dpop_handler = dpop_handler || DpopHandler.new
+      @token_mutex = Mutex.new
+    end
+
+    def make_api_request(method, url, params: {}, body: nil)
+      retries = 0
+      begin
+        uri = URI(url)
+        uri.query = URI.encode_www_form(params) if params.any?
+        @dpop_handler.make_request(
+          uri.to_s,
+          method,
+          headers: { 'Authorization' => "Bearer #{@access_token}" },
+          body: body
+        )
+      rescue TokenExpiredError => e
+        raise e unless retries.zero? && @refresh_token
+
+        retries += 1
+        refresh_access_token!
+        retry
+      end
+    end
+
+    private
+
+    def refresh_access_token!
+      @token_mutex.synchronize do
+        response = @dpop_handler.make_request(
+          "#{base_url}/xrpc/com.atproto.server.refreshSession",
+          :post,
+          headers: {},
+          body: { refresh_token: @refresh_token }
+        )
+
+        unless response.is_a?(Net::HTTPSuccess)
+          raise RefreshTokenError, "Failed to refresh token: #{response.code} - #{response.body}"
+        end
+
+        data = JSON.parse(response.body)
+        @access_token = data['access_token']
+        @refresh_token = data['refresh_token']
+      end
+    end
+
+    def base_url
+      AtProto.configuration.base_url
+    end
+  end
+end

data/lib/atproto_client/configuration.rb

@@ -0,0 +1,19 @@
+module AtProto
+  class Configuration
+    attr_accessor :base_url
+
+    def initialize
+      @base_url = 'https://bsky.social'
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+  end
+end

data/lib/atproto_client/dpop_handler.rb

@@ -0,0 +1,80 @@
+module AtProto
+  # Handler for DPoP (Demonstrating Proof-of-Possession) protocol implementation
+  class DpopHandler
+    # Initialize a new DPoP handler
+    # @param private_key [OpenSSL::PKey::EC, nil] Optional private key for signing tokens
+    def initialize(private_key = nil)
+      @private_key = private_key || generate_private_key
+      @current_nonce = nil
+      @nonce_mutex = Mutex.new
+      @token_mutex = Mutex.new
+    end
+
+    # Generates a DPoP token for a request
+    # @param http_method [String] The HTTP method of the request
+    # @param url [String] The target URL of the request
+    # @param nonce [String, nil] Optional nonce value
+    # @return [String] The generated DPoP token
+    def generate_token(http_method, url, nonce = @current_nonce)
+      @token_mutex.synchronize do
+        create_dpop_token(http_method, url, nonce)
+      end
+    end
+
+    # Updates the current nonce from response headers
+    # @param response [Net::HTTPResponse] Response containing dpop-nonce header
+    def update_nonce(response)
+      new_nonce = response.to_hash.dig('dpop-nonce', 0)
+      @nonce_mutex.synchronize do
+        @current_nonce = new_nonce if new_nonce
+      end
+    end
+
+    # Makes an HTTP request with DPoP handling,
+    # when no nonce is used for the first try, takes it from the response and retry
+    # @param uri [String] The target URI
+    # @param method [String] The HTTP method
+    # @param headers [Hash] Optional request headers
+    # @param body [Hash, nil] Optional request body
+    # @return [Net::HTTPResponse] The HTTP response
+    # @raise [APIError] If the request fails
+    def make_request(uri, method, headers: {}, body: nil)
+      retried = false
+      begin
+        dpop_token = generate_token(method.to_s.upcase, uri.to_s)
+        request = Request.new(method, uri, headers.merge('DPoP' => dpop_token))
+        request.body = body.to_json if body
+        request.run
+      rescue Net::HTTPClientException => e
+        unless retried
+          update_nonce(e.response)
+          retried = true
+          retry
+        end
+        raise APIError, "Request failed: #{e.response.code} - #{e.response.body}"
+      end
+    end
+
+    private
+
+    def generate_private_key
+      OpenSSL::PKey::EC.generate('prime256v1').tap(&:check_key)
+    end
+
+    # Creates a DPoP token with the specified parameters, encoded by jwk
+    def create_dpop_token(http_method, target_uri, nonce = nil)
+      jwk = JWT::JWK.new(@private_key).export
+      payload = {
+        jti: SecureRandom.hex(16),
+        htm: http_method,
+        htu: target_uri,
+        iat: Time.now.to_i,
+        exp: Time.now.to_i + 120
+      }
+
+      payload[:nonce] = nonce if nonce
+
+      JWT.encode(payload, @private_key, 'ES256', { typ: 'dpop+jwt', alg: 'ES256', jwk: jwk })
+    end
+  end
+end

data/lib/atproto_client/request.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module AtProto
+  # Handles HTTP requests for the AT Protocol client
+  # Throw the errors needed for the flow (Dpop and TokenInvalid)
+  class Request
+    # @return [URI] The URI for the request
+    # @return [Symbol] The HTTP method to use
+    # @return [Hash] Headers to be sent with the request
+    # @return [String, nil] The request body
+    attr_accessor :uri, :method, :headers, :body
+
+    # Creates a new Request instance
+    #
+    # @param method [Symbol] The HTTP method (:get, :post, :put, :delete)
+    # @param uri [String] The URI for the request
+    # @param headers [Hash] Optional headers to include
+    # @param body [String, nil] Optional request body
+    # @return [Request] A new Request instance
+    def initialize(method, uri, headers = {}, body = nil)
+      @uri = URI(uri)
+      @method = method
+      @headers = headers
+      @body = body
+    end
+
+    # Executes the HTTP request
+    #
+    # Makes the HTTP request with configured parameters and handles the response.
+    # Automatically sets Content-Type and Accept headers to application/json.
+    #
+    # @return [Hash] Parsed JSON response body
+    # @raise [Net::HTTPClientException] On bad request
+    # @raise [TokenExpiredError] When the authentication token has expired
+    # @raise [AuthError] When authentication fails
+    # @raise [APIError] When the API returns an unexpected error
+    def run
+      request_class = HTTP_METHODS[method]
+      req = request_class.new(uri).tap do |request|
+        headers.each { |k, v| request[k] = v }
+        request['Content-Type'] = 'application/json'
+        request['Accept'] = 'application/json'
+        request.body = body
+      end
+      response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+        http.request(req)
+      end
+      handle_response(response)
+    end
+
+    private
+
+    HTTP_METHODS = {
+      get: Net::HTTP::Get,
+      post: Net::HTTP::Post,
+      put: Net::HTTP::Put,
+      delete: Net::HTTP::Delete
+    }.freeze
+
+    def handle_response(response)
+      case response.code.to_i
+      when 400
+        body = JSON.parse(response.body)
+        response.error! if body['error'] == 'use_dpop_nonce'
+      when 401
+        body = JSON.parse(response.body)
+        raise TokenExpiredError if body['error'] == 'TokenExpiredError'
+
+        raise AuthError, "Unauthorized: #{body['error']}"
+      when 200..299
+        JSON.parse(response.body)
+      else
+        raise APIError, "Request failed: #{response.code} - #{response.body}"
+      end
+    end
+  end
+end

data/lib/atproto_client/version.rb

@@ -0,0 +1,3 @@
+module AtProto
+  VERSION = '0.1.0'
+end

data/lib/atproto_client.rb

@@ -0,0 +1,25 @@
+require 'atproto_client/version'
+require 'jwt'
+require 'openssl'
+require 'securerandom'
+require 'base64'
+require 'json'
+require 'net/http'
+require 'uri'
+
+module AtProto
+  class Error < StandardError; end
+
+  class AuthError < Error; end
+
+  class TokenExpiredError < AuthError; end
+
+  class RefreshTokenError < AuthError; end
+
+  class APIError < Error; end
+end
+
+require 'atproto_client/configuration'
+require 'atproto_client/client'
+require 'atproto_client/dpop_handler'
+require 'atproto_client/request'

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification
+name: atproto_client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- frabr
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-11-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jwt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: openssl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.18'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: A Ruby client for the AT Protocol authenticated request
+email:
+- francois@lasercats.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/atproto_client.rb
+- lib/atproto_client/client.rb
+- lib/atproto_client/configuration.rb
+- lib/atproto_client/dpop_handler.rb
+- lib/atproto_client/request.rb
+- lib/atproto_client/version.rb
+homepage: https://github.com/lasercats/atproto_client
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key: 
+specification_version: 4
+summary: AT Protocol client implementation for Ruby
+test_files: []