federails 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc485556cd2ae749668f8f6a6ffec973361bdef6970e421845b9c2de64e8cecf
-  data.tar.gz: 34630a4b116e47b3d4c3ec4fd7599ba0264f4dd76fdff5db795d2be90c50c2cc
+  metadata.gz: 070da5d2cc3d016475a69f797c6280595618d5f60de95cf7506bb2a1e9cbce4c
+  data.tar.gz: a954535a092fa71fdb911f973363d8372b6d56e42b32190394e92026567c6913
 SHA512:
-  metadata.gz: b296b6db88b1077326722a187f6074fc8f9bbeb4f43d0f90a2c7811fb7bfd14b0e247f64149ce41c0e53128ce45d3e7e61ecfb0da8d47e64b6b7f188dfa33c8c
-  data.tar.gz: 948085a88295cf6c6699ed1dbea2a64a30d8695bb1a9d596cb83d66753eb4e26b5129d0d00574d21f230544b75a3f859411e64c785878abc2ce85021ef41a2b5
+  metadata.gz: 69fba1438beef26a150079c2a39eb185903025dcad3c24f5dfee941d844710d12938cf5546f0dc488f725096a2c4e6f32dfba4d1d3c825b9ba9418f063bb4ec9
+  data.tar.gz: 01ef6821f7b1aa9422f013e23ed20b1225f0e630d4925ca81c7490f43d790a1d77a3b93e8d72783d93aee59f1760b48bbdd71a59feca353bca0a1277a6bd03c0

data/README.md

@@ -102,6 +102,17 @@ Federails.configure do |config|
 end
 ```
 
+#### Remote following
+
+By default, remote follow requests (where you press a follow button on another server and get redirected home to complete the follow)
+will use the built-in client paths. If you're not using the client, or want to provide your own user interface, you can set the path like this, assuming that `new_follow_url` is a valid route in your app. A `uri` query parameter template will be automatically appended, you don't need to specify that.
+
+```
+Federails.configure do |config|
+  config.remote_follow_url_method = :new_follow_url
+end
+```
+
 ### Migrations
 
 Copy the migrations:

data/app/controllers/federails/application_controller.rb

@@ -11,6 +11,10 @@ module Federails
     def error_fallback(exception, fallback_message, status)
       message = exception&.message || fallback_message
       respond_to do |format|
+        format.jrd { head status }
+        format.xrd { head status }
+        format.activitypub { head status }
+        format.nodeinfo { head status }
         format.json { render json: { error: message }, status: status }
         format.html { raise exception }
       end

data/app/controllers/federails/client/activities_controller.rb

@@ -8,7 +8,7 @@ module Federails
       # GET /app/activities.json
       def index
         @activities = policy_scope(Federails::Activity, policy_scope_class: Federails::Client::ActivityPolicy::Scope).all
-        @activities = @activities.where actor_id: params[:actor_id] if params[:actor_id]
+        @activities = @activities.where actor: Actor.find_param(params[:actor_id]) if params[:actor_id]
       end
 
       # GET /app/feed

data/app/controllers/federails/client/actors_controller.rb

@@ -25,7 +25,7 @@ module Federails
 
       # Use callbacks to share common setup or constraints between actions.
       def set_actor
-        @actor = Federails::Actor.find(params[:id])
+        @actor = Federails::Actor.find_param(params[:id])
         authorize @actor, policy_class: Federails::Client::ActorPolicy
       end
 

data/app/controllers/federails/client/followings_controller.rb

@@ -4,6 +4,14 @@ module Federails
       before_action :authenticate_user!
       before_action :set_following, only: [:accept, :destroy]
 
+      # GET /app/followings/new?uri={uri}
+      def new
+        # Find actor (and fetch if necessary)
+        actor = Actor.find_or_create_by_federation_url(params[:uri])
+        # Redirect to local profile page which will have a follow button on it
+        redirect_to federails.client_actor_url(actor)
+      end
+
       # PUT /app/followings/:id/accept
       # PUT /app/followings/:id/accept.json
       def accept
@@ -62,7 +70,7 @@ module Federails
 
       # Use callbacks to share common setup or constraints between actions.
       def set_following
-        @following = Following.find(params[:id])
+        @following = Following.find_param(params[:id])
         authorize @following, policy_class: Federails::Client::FollowingPolicy
       end
 

data/app/controllers/federails/server/activities_controller.rb

@@ -8,7 +8,7 @@ module Federails
       # GET /federation/activities
       # GET /federation/actors/1/outbox.json
       def outbox
-        @actor            = Actor.find(params[:actor_id])
+        @actor            = Actor.find_param(params[:actor_id])
         @activities       = policy_scope(Federails::Activity, policy_scope_class: Federails::Server::ActivityPolicy::Scope).where(actor: @actor).order(created_at: :desc)
         @total_activities = @activities.count
         @activities       = @activities.page(params[:page])
@@ -20,12 +20,12 @@ module Federails
       # POST /federation/actors/1/inbox
       def create
         payload = payload_from_params
-        return render json: {}, status: :unprocessable_entity unless payload
+        return head :unprocessable_entity unless payload
 
         if Fediverse::Inbox.dispatch_request(payload)
-          render json: {}, status: :created
+          head :created
         else
-          render json: {}, status: :unprocessable_entity
+          head :unprocessable_entity
         end
       end
 
@@ -33,7 +33,7 @@ module Federails
 
       # Use callbacks to share common setup or constraints between actions.
       def set_activity
-        @activity = Activity.find_by!(actor_id: params[:actor_id], id: params[:id])
+        @activity = Actor.find_param(params[:actor_id]).activities.find_param(params[:id])
       end
 
       # Only allow a list of trusted parameters through.

data/app/controllers/federails/server/actors_controller.rb

@@ -21,7 +21,7 @@ module Federails
 
       # Use callbacks to share common setup or constraints between actions.
       def set_actor
-        @actor = Actor.find(params[:id])
+        @actor = Actor.find_param(params[:id])
         authorize @actor, policy_class: Federails::Server::ActorPolicy
       end
 

data/app/controllers/federails/server/followings_controller.rb

@@ -10,7 +10,8 @@ module Federails
 
       # Use callbacks to share common setup or constraints between actions.
       def set_following
-        @following = Following.find_by!(actor_id: params[:actor_id], id: params[:id])
+        actor = Actor.find_param(params[:actor_id])
+        @following = Following.find_by!(actor: actor, uuid: params[:id])
         authorize @following, policy_class: Federails::Server::FollowingPolicy
       end
     end

data/app/controllers/federails/server/nodeinfo_controller.rb

@@ -2,7 +2,7 @@ module Federails
   module Server
     class NodeinfoController < ServerController
       def index
-        render formats: [:json]
+        render formats: [:nodeinfo]
       end
 
       def show # rubocop:todo Metrics/AbcSize
@@ -15,7 +15,7 @@ module Federails
           @active_month += model.where(created_at: ((30.days.ago)...Time.current)).count
           @active_halfyear += model.where(created_at: ((180.days.ago)...Time.current)).count
         end
-        render formats: [:json]
+        render formats: [:nodeinfo]
       end
     end
   end

data/app/controllers/federails/server/web_finger_controller.rb

@@ -15,11 +15,11 @@ module Federails
         end
         raise ActiveRecord::RecordNotFound if @user.nil?
 
-        render formats: [:json]
+        render formats: [:jrd]
       end
 
       def host_meta
-        render content_type: 'application/xrd+xml', formats: [:xml]
+        render formats: [:xrd]
       end
 
       # TODO: complete missing endpoints

data/app/helpers/federails/application_helper.rb

@@ -1,4 +1,12 @@
 module Federails
   module ApplicationHelper
+    def remote_follow_url
+      method_name = Federails.configuration.remote_follow_url_method.to_s
+      if method_name.starts_with? 'federails.'
+        send(method_name.gsub('federails.', ''))
+      else
+        Rails.application.routes.url_helpers.send(method_name)
+      end
+    end
   end
 end

data/app/models/concerns/federails/entity.rb

@@ -2,7 +2,18 @@ module Federails
   module Entity
     extend ActiveSupport::Concern
 
-    included do
+    included do # rubocop:todo Metrics/BlockLength
+      include ActiveSupport::Callbacks
+      define_callbacks :followed
+
+      # Define a method that will be called after the entity receives a follow request
+      # @param method [Symbol] The name of the method to call, or a block that will be called directly
+      # @example
+      #   after_followed :accept_follow
+      def self.after_followed(method)
+        set_callback :followed, :after, method
+      end
+
       has_one :actor, class_name: 'Federails::Actor', as: :entity, dependent: :destroy
 
       after_create :create_actor

data/app/models/concerns/federails/has_uuid.rb

@@ -0,0 +1,35 @@
+module Federails
+  module HasUuid
+    extend ActiveSupport::Concern
+
+    included do
+      before_validation :generate_uuid
+      validates :uuid, presence: true, uniqueness: true
+
+      def self.find_param(param)
+        find_by!(uuid: param)
+      end
+    end
+
+    def to_param
+      uuid
+    end
+
+    # Override UUID accessor to provide lazy initialization of UUIDs for old data
+    def uuid
+      if self[:uuid].blank?
+        generate_uuid
+        save!
+      end
+      self[:uuid]
+    end
+
+    private
+
+    def generate_uuid
+      return if self[:uuid].present?
+
+      (self.uuid = SecureRandom.uuid) while self[:uuid].blank? || self.class.exists?(uuid: self[:uuid])
+    end
+  end
+end

data/app/models/federails/activity.rb

@@ -1,5 +1,7 @@
 module Federails
   class Activity < ApplicationRecord
+    include Federails::HasUuid
+
     belongs_to :entity, polymorphic: true
     belongs_to :actor
 
@@ -13,22 +15,15 @@ module Federails
 
     after_create_commit :post_to_inboxes
 
-    def recipients # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+    def recipients
       return [] unless actor.local?
 
-      actors = []
-      case action
-      when 'Create'
-        actors.push(entity.target_actor) if entity_type == 'Federails::Following'
-        # FIXME: Move this to dummy, somehow
-        actors.push(*actor.followers) if entity_type == 'Note'
-      when 'Accept'
-        actors.push(entity.actor) if entity_type == 'Federails::Following'
-      when 'Undo'
-        actors.push(entity.target_actor) if entity_type == 'Federails::Following'
+      case entity_type
+      when 'Federails::Following'
+        [(action == 'Accept' ? entity.actor : entity.target_actor)]
+      else
+        actor.followers
       end
-
-      actors
     end
 
     private

data/app/models/federails/actor.rb

@@ -3,6 +3,8 @@ require 'fediverse/webfinger'
 
 module Federails
   class Actor < ApplicationRecord # rubocop:disable Metrics/ClassLength
+    include Federails::HasUuid
+
     validates :federated_url, presence: { unless: :entity }, uniqueness: { unless: :entity }
     validates :username, presence: { unless: :entity }
     validates :server, presence: { unless: :entity }
@@ -112,7 +114,7 @@ module Federails
 
       def find_by_federation_url(federated_url)
         local_route = Utils::Host.local_route federated_url
-        return find local_route[:id] if local_route && local_route[:controller] == 'federails/server/actors' && local_route[:action] == 'show'
+        return find_param(local_route[:id]) if local_route && local_route[:controller] == 'federails/server/actors' && local_route[:action] == 'show'
 
         actor = find_by federated_url: federated_url
         return actor if actor
@@ -148,5 +150,40 @@ module Federails
         end
       end
     end
+
+    def public_key
+      ensure_key_pair_exists!
+      self[:public_key]
+    end
+
+    def private_key
+      ensure_key_pair_exists!
+      self[:private_key]
+    end
+
+    def key_id
+      "#{federated_url}#main-key"
+    end
+
+    private
+
+    def ensure_key_pair_exists!
+      return if self[:private_key].present? || !local?
+
+      update!(generate_key_pair)
+    end
+
+    def generate_key_pair
+      rsa_key = OpenSSL::PKey::RSA.new 2048
+      cipher  = OpenSSL::Cipher.new('AES-128-CBC')
+      {
+        private_key: if Rails.application.credentials.secret_key_base
+                       rsa_key.to_pem(cipher, Rails.application.credentials.secret_key_base)
+                     else
+                       rsa_key.to_pem
+                     end,
+        public_key:  rsa_key.public_key.to_pem,
+      }
+    end
   end
 end

data/app/models/federails/following.rb

@@ -1,5 +1,7 @@
 module Federails
   class Following < ApplicationRecord
+    include Federails::HasUuid
+
     enum status: { pending: 0, accepted: 1 }
 
     validates :target_actor_id, uniqueness: { scope: [:actor_id, :target_actor_id] }
@@ -9,6 +11,7 @@ module Federails
     # FIXME: Handle this with something like undelete
     has_many :activities, as: :entity, dependent: :destroy
 
+    after_create :after_follow
     after_create :create_activity
     after_destroy :destroy_activity
 
@@ -32,6 +35,12 @@ module Federails
 
     private
 
+    def after_follow
+      target_actor&.entity&.run_callbacks :followed, :after do
+        self
+      end
+    end
+
     def create_activity
       Activity.create! actor: actor, action: 'Create', entity: self
     end

data/app/views/federails/client/actors/show.html.erb

@@ -61,7 +61,7 @@
 <p>
   <b>Home page:</b>
   <% if @actor.local? && Federails::Configuration.user_profile_url_method %>
-    <%= link_to @actor.send(Federails::Configuration.user_username_field), send(Federails::Configuration.user_profile_url_method, @actor.user) %>
+    <%= link_to @actor.send(Federails::Configuration.user_username_field), Rails.application.routes.url_helpers.send(Federails::Configuration.user_profile_url_method, @actor.user) %>
   <% elsif @actor.profile_url %>
     <%= link_to @actor.name, @actor.profile_url %>
   <% else %>

data/app/views/federails/server/activities/{_activity.json.jbuilder → _activity.activitypub.jbuilder}

@@ -6,4 +6,9 @@ json.type activity.action
 json.actor activity.actor.federated_url
 json.to ['https://www.w3.org/ns/activitystreams#Public']
 json.cc [activity.actor.followers_url]
-json.object activity.entity.federated_url
+
+if activity.entity.respond_to? :to_activitypub_object
+  json.object activity.entity.to_activitypub_object
+elsif activity.entity.respond_to? :federated_url
+  json.object activity.entity.federated_url
+end

data/app/views/federails/server/actors/{_actor.json.jbuilder → _actor.activitypub.jbuilder}

@@ -1,4 +1,7 @@
-json.set! '@context', 'https://www.w3.org/ns/activitystreams'
+json.set! '@context', [
+  'https://www.w3.org/ns/activitystreams',
+  'https://w3id.org/security/v1',
+]
 
 json.id actor.federated_url
 json.name actor.name
@@ -9,3 +12,10 @@ json.outbox actor.outbox_url
 json.followers actor.followers_url
 json.following actor.followings_url
 json.url actor.profile_url
+if actor.public_key
+  json.publicKey do
+    json.id actor.key_id
+    json.owner actor.federated_url
+    json.publicKeyPem actor.public_key
+  end
+end

data/app/views/federails/server/web_finger/{find.json.jbuilder → find.jrd.jbuilder}

@@ -4,7 +4,7 @@ links = [
   # Federation actor URL
   {
     rel:  'self',
-    type: 'application/activity+json',
+    type: Mime[:activitypub].to_s,
     href: @user.actor.federated_url,
   },
 ]
@@ -17,4 +17,8 @@ if @user.actor.profile_url
              href: @user.actor.profile_url
 end
 
+# Remote following
+links.push rel:      'http://ostatus.org/schema/1.0/subscribe',
+           template: "#{remote_follow_url}?uri={uri}"
+
 json.links links

data/config/initializers/mime_types.rb

@@ -0,0 +1,21 @@
+# Webfinger: https://datatracker.ietf.org/doc/html/rfc7033
+Mime::Type.register 'application/jrd+json', :jrd
+Mime::Type.register 'application/xrd+xml', :xrd
+
+# ActivityPub: https://www.w3.org/TR/activitypub/#retrieving-objects
+Mime::Type.register 'application/ld+json; profile="https://www.w3.org/ns/activitystreams"', :activitypub, ['application/activity+json', 'application/json']
+
+# Nodeinfo: https://github.com/jhass/nodeinfo/blob/main/PROTOCOL.md#retrieval
+Mime::Type.register 'application/json; profile="http://nodeinfo.diaspora.software/ns/schema/2.0#"', :nodeinfo
+
+# Get current request parsers. Apparently we need to do it this way and can't add in-place, see
+# https://api.rubyonrails.org/classes/ActionDispatch/Http/Parameters/ClassMethods.html#method-i-parameter_parsers-3D
+parsers = ActionDispatch::Request.parameter_parsers
+# Copy the default JSON parsing for JSON types
+[:jrd, :activitypub, :nodeinfo].each do |mime_type|
+  parsers[Mime[mime_type].symbol] = parsers[:json]
+end
+# XRD just needs a simple XML parser
+parsers[Mime[:xrd].symbol] = ->(raw_post) { Hash.from_xml(raw_post) || {} }
+# Store updated parsers
+ActionDispatch::Request.parameter_parsers = parsers

data/config/routes.rb

@@ -18,7 +18,7 @@ Federails::Engine.routes.draw do
         resources :activities, only: [:index]
       end
       get :feed, to: 'activities#feed'
-      resources :followings, only: [:create, :destroy] do
+      resources :followings, only: [:new, :create, :destroy] do
         collection do
           post :follow, to: 'followings#follow'
         end

data/db/migrate/20241002094500_add_uuids.rb

@@ -0,0 +1,13 @@
+class AddUuids < ActiveRecord::Migration[7.0]
+  def change
+    [
+      :federails_actors,
+      :federails_activities,
+      :federails_followings,
+    ].each do |table|
+      change_table table do |t|
+        t.string :uuid, default: nil, index: { unique: true }
+      end
+    end
+  end
+end

data/db/migrate/20241002094501_add_keypair_to_actors.rb

@@ -0,0 +1,8 @@
+class AddKeypairToActors < ActiveRecord::Migration[7.0]
+  def change
+    change_table :federails_actors do |t|
+      t.text :public_key
+      t.text :private_key
+    end
+  end
+end

data/lib/federails/configuration.rb

@@ -42,6 +42,10 @@ module Federails
     mattr_accessor :client_routes_path
     @@client_routes_path = :app
 
+    # Route method for remote-following requests
+    mattr_accessor :remote_follow_url_method
+    @@remote_follow_url_method = 'federails.new_client_following_url'
+
     # Method to use for links to user profiles
     # @deprecated Set profile_url_method option on acts_as_federails_actor instead
     mattr_accessor :user_profile_url_method

data/lib/federails/version.rb

@@ -1,3 +1,3 @@
 module Federails
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.2.0'.freeze
 end

data/lib/federails.rb

@@ -27,10 +27,11 @@ module Federails
       :user_class, # @deprecated
       :server_routes_path,
       :client_routes_path,
+      :remote_follow_url_method,
       :user_profile_url_method, # @deprecated
       :user_name_field, # @deprecated
       :user_username_field, # @deprecated
-    ].each { |key| Configuration.send :"#{key}=", config[key] }
+    ].each { |key| Configuration.send :"#{key}=", config[key] if config.key?(key) }
   end
 end
 # rubocop:enable Style/ClassVars

data/lib/fediverse/notifier.rb

@@ -1,21 +1,60 @@
+require 'fediverse/signature'
+
 module Fediverse
   class Notifier
     class << self
       def post_to_inboxes(activity)
         actors = activity.recipients
-
         Rails.logger.debug('Nobody to notice') && return if actors.count.zero?
 
-        message = Federails::ApplicationController.renderer.new.render(
+        message = payload(activity)
+        actors.each do |recipient|
+          Rails.logger.debug { "Sending activity ##{activity.id} to #{recipient.inbox_url}" }
+          post_to_inbox(to: recipient, message: message, from: activity.actor)
+        end
+      end
+
+      private
+
+      def payload(activity)
+        Federails::ApplicationController.renderer.new.render(
           template: 'federails/server/activities/show',
           assigns:  { activity: activity },
           format:   :json
         )
-        actors.each do |actor|
-          Rails.logger.debug { "Sending activity ##{activity.id} to #{actor.inbox_url}" }
-          Faraday.post actor.inbox_url, message, 'Content-Type' => 'application/json', 'Accept' => 'application/json'
+      end
+
+      def post_to_inbox(to:, message:, from: nil)
+        conn = Faraday.default_connection
+        conn.builder.build_response(
+          conn,
+          signed_request(to: to, message: message, from: from)
+        )
+      end
+
+      def signed_request(to:, message:, from:)
+        req = request(to: to, message: message)
+        req.headers['Signature'] = Fediverse::Signature.sign(sender: from, request: req) if from
+        req
+      end
+
+      def request(to:, message:) # rubocop:todo Metrics/AbcSize
+        Faraday.default_connection.build_request(:post) do |req|
+          req.url to.inbox_url
+          req.body = message
+          req.headers['Content-Type'] = Mime[:activitypub].to_s
+          req.headers['Accept'] = Mime[:activitypub].to_s
+          req.headers['Host'] = URI.parse(to.inbox_url).host
+          req.headers['Date'] = Time.now.utc.httpdate
+          req.headers['Digest'] = digest(message)
         end
       end
+
+      def digest(message)
+        "SHA-256=#{Base64.strict_encode64(
+          OpenSSL::Digest.new('SHA256').digest(message)
+        )}"
+      end
     end
   end
 end

data/lib/fediverse/signature.rb

@@ -0,0 +1,49 @@
+module Fediverse
+  class Signature
+    class << self
+      def sign(sender:, request:)
+        private_key = OpenSSL::PKey::RSA.new sender.private_key, Rails.application.credentials.secret_key_base
+        headers = '(request-target) host date digest'
+        sig = Base64.strict_encode64(
+          private_key.sign(
+            OpenSSL::Digest.new('SHA256'), signature_payload(request: request, headers: headers)
+          )
+        )
+        {
+          keyId:     sender.key_id,
+          headers:   headers,
+          signature: sig,
+        }.map { |k, v| "#{k}=\"#{v}\"" }.join(',')
+      end
+
+      def verify(sender:, request:)
+        raise 'Unsigned headers' unless request.headers['Signature']
+
+        signature_header = request.headers['Signature'].split(',').to_h do |pair|
+          /\A(?<key>[\w]+)="(?<value>.*)"\z/ =~ pair
+          [key, value]
+        end
+
+        headers   = signature_header['headers']
+        signature = Base64.decode64(signature_header['signature'])
+        key       = OpenSSL::PKey::RSA.new(sender.public_key)
+
+        comparison_string = signature_payload(request: request, headers: headers)
+
+        key.verify(OpenSSL::Digest.new('SHA256'), signature, comparison_string)
+      end
+
+      private
+
+      def signature_payload(request:, headers:)
+        headers.split.map do |signed_header_name|
+          if signed_header_name == '(request-target)'
+            "(request-target): #{request.http_method} #{URI.parse(request.path).path}"
+          else
+            "#{signed_header_name}: #{request.headers[signed_header_name.capitalize]}"
+          end
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/fediverse/webfinger.rb

@@ -30,28 +30,52 @@ module Fediverse
 
       # Returns actor id
       def webfinger(username, domain)
-        scheme = Federails.configuration.force_ssl ? 'https' : 'http'
-        json = get_json "#{scheme}://#{domain}/.well-known/webfinger", resource: "acct:#{username}@#{domain}"
+        json = webfinger_response(username, domain)
         link = json['links'].find { |l| l['type'] == 'application/activity+json' }
 
         link['href'] if link
       end
 
+      # Returns remote follow link template, or complete link if actor_url is provided
+      def remote_follow_url(username, domain, actor_url: nil)
+        json = webfinger_response(username, domain)
+        link = json['links'].find { |l| l['rel'] == 'http://ostatus.org/schema/1.0/subscribe' }
+        return nil if link&.dig('template').nil?
+
+        if actor_url
+          link['template'].gsub('{uri}', CGI.escape(actor_url))
+        else
+          link['template']
+        end
+      end
+
       private
 
+      def webfinger_response(username, domain)
+        scheme = Federails.configuration.force_ssl ? 'https' : 'http'
+        get_json "#{scheme}://#{domain}/.well-known/webfinger", resource: "acct:#{username}@#{domain}"
+      end
+
+      def server_and_port(id)
+        uri = URI.parse id
+        if uri.port && [80, 443].exclude?(uri.port)
+          "#{uri.host}:#{uri.port}"
+        else
+          uri.host
+        end
+      end
+
       def webfinger_to_actor(data)
-        uri    = URI.parse data['id']
-        server = uri.host
-        server += ":#{uri.port}" if uri.port && [80, 443].exclude?(uri.port)
         Federails::Actor.new federated_url:  data['id'],
                              username:       data['preferredUsername'],
                              name:           data['name'],
-                             server:         server,
+                             server:         server_and_port(data['id']),
                              inbox_url:      data['inbox'],
                              outbox_url:     data['outbox'],
                              followers_url:  data['followers'],
                              followings_url: data['following'],
-                             profile_url:    data['url']
+                             profile_url:    data['url'],
+                             public_key:     data.dig('publicKey', 'publicKeyPem')
       end
 
       def get_json(url, payload = {})

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: federails
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Manuel Tancoigne
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-04 00:00:00.000000000 Z
+date: 2024-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -134,6 +134,7 @@ files:
 - app/jobs/federails/notify_inbox_job.rb
 - app/mailers/federails/application_mailer.rb
 - app/models/concerns/federails/entity.rb
+- app/models/concerns/federails/has_uuid.rb
 - app/models/federails/activity.rb
 - app/models/federails/actor.rb
 - app/models/federails/application_record.rb
@@ -166,24 +167,27 @@ files:
 - app/views/federails/client/followings/index.json.jbuilder
 - app/views/federails/client/followings/show.html.erb
 - app/views/federails/client/followings/show.json.jbuilder
-- app/views/federails/server/activities/_activity.json.jbuilder
-- app/views/federails/server/activities/outbox.json.jbuilder
-- app/views/federails/server/activities/show.json.jbuilder
-- app/views/federails/server/actors/_actor.json.jbuilder
-- app/views/federails/server/actors/followers.json.jbuilder
-- app/views/federails/server/actors/following.json.jbuilder
-- app/views/federails/server/actors/show.json.jbuilder
-- app/views/federails/server/followings/_following.json.jbuilder
-- app/views/federails/server/followings/show.json.jbuilder
-- app/views/federails/server/nodeinfo/index.json.jbuilder
-- app/views/federails/server/nodeinfo/show.json.jbuilder
-- app/views/federails/server/web_finger/find.json.jbuilder
-- app/views/federails/server/web_finger/host_meta.xml.erb
+- app/views/federails/server/activities/_activity.activitypub.jbuilder
+- app/views/federails/server/activities/outbox.activitypub.jbuilder
+- app/views/federails/server/activities/show.activitypub.jbuilder
+- app/views/federails/server/actors/_actor.activitypub.jbuilder
+- app/views/federails/server/actors/followers.activitypub.jbuilder
+- app/views/federails/server/actors/following.activitypub.jbuilder
+- app/views/federails/server/actors/show.activitypub.jbuilder
+- app/views/federails/server/followings/_following.activitypub.jbuilder
+- app/views/federails/server/followings/show.activitypub.jbuilder
+- app/views/federails/server/nodeinfo/index.nodeinfo.jbuilder
+- app/views/federails/server/nodeinfo/show.nodeinfo.jbuilder
+- app/views/federails/server/web_finger/find.jrd.jbuilder
+- app/views/federails/server/web_finger/host_meta.xrd.erb
+- config/initializers/mime_types.rb
 - config/routes.rb
 - db/migrate/20200712133150_create_federails_actors.rb
 - db/migrate/20200712143127_create_federails_followings.rb
 - db/migrate/20200712174938_create_federails_activities.rb
 - db/migrate/20240731145400_change_actor_entity_rel_to_polymorphic.rb
+- db/migrate/20241002094500_add_uuids.rb
+- db/migrate/20241002094501_add_keypair_to_actors.rb
 - lib/federails.rb
 - lib/federails/configuration.rb
 - lib/federails/engine.rb
@@ -192,6 +196,7 @@ files:
 - lib/fediverse/inbox.rb
 - lib/fediverse/notifier.rb
 - lib/fediverse/request.rb
+- lib/fediverse/signature.rb
 - lib/fediverse/webfinger.rb
 - lib/generators/federails/install/USAGE
 - lib/generators/federails/install/install_generator.rb