tempest-rb 0.0.2 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e74ff03fab2ee34902b7836bd77f0a41752135cda5aca37ca97570ac5ced79f3
-  data.tar.gz: edb35af23affe941bfdd361a04d86e18ded6ac068afd33df4d97d82aa62f445b
+  metadata.gz: 425f1a89085c0d2d762d9ef2697d0f34b752e7bfb479ff4dec077678987fa378
+  data.tar.gz: e61021b6f27a4e038f8b1b4d51697c169f5c90b99f7dc4ea0cdcfffacde4ba65
 SHA512:
-  metadata.gz: 0453a2009c3bed58216a221aad38a71b5cd97529e5b6a0dc210a9c2b72be3172ffc9ec3593679c577540fa937cd3226940eba11e02e952bf8255d445da1226ba
-  data.tar.gz: ef8abc6996dfdc86fb54d3ffdcfc7025c37444042a3e8c3fb3008a87bd3aa613d737f873a999541e73b7393c692569ab7ff3d6e226757618115350c83e66f4c1
+  metadata.gz: d3058fd2a2457246b63225ad6f4d46ac85e90e791dc0f364da1bc37ee1ab6b4ecb185aca488cd2f83c59e79c168d21e65f115a0b08c2cf49865ccf2f2c4e76f1
+  data.tar.gz: 6c092f9332873d3cea39f85fa33b8447f6fc4b8685c8b25b18490de845ac0eda408de15494a29e18a7f465d3e005248bbacb497f2365a4b7854512e10fcc86bf

data/lib/tempest/avatar_store.rb

@@ -0,0 +1,199 @@
+require "fileutils"
+require "json"
+require "net/http"
+require "open3"
+require "tmpdir"
+require "uri"
+
+require_relative "../tempest"
+
+module Tempest
+  # Resolves Bluesky DIDs to a local PNG file path for the actor's avatar.
+  # Mirrors the shape of HandleResolver: an injected client speaks XRPC for
+  # `app.bsky.actor.getProfile`, and the result is cached in-process so the
+  # PDS isn't hit on every event.
+  #
+  # Disk layout: avatars live under `cache_dir/` as
+  # "<sanitized-did>__<avatar-cid>.png". The avatar CID is read from the
+  # tail of the avatar URL so that re-uploaded avatars (which receive a new
+  # CID) invalidate the cache without server-side coordination.
+  class AvatarStore
+    # Sentinel for "we tried, there is no avatar" — distinct from "we haven't
+    # looked yet" (nil). Mirrors the pattern in HandleResolver.
+    NOT_FOUND = Object.new.freeze
+
+    # Standalone profile client used by Tempest::CLI.
+    #
+    # AvatarStore resolves DIDs on a background thread, so the client it uses
+    # must be thread-safe. We deliberately do NOT use Tempest::XRPCClient
+    # here, because the underlying Tempest::HTTP layer is built on
+    # Async::HTTP::Internet whose Fibers cannot be resumed from a thread other
+    # than the one that created them — calling it from our worker yields
+    # `FiberError: fiber called across threads`.
+    #
+    # app.bsky.actor.getProfile is served unauthenticated by
+    # public.api.bsky.app, so we don't need a session here.
+    class DefaultProfileClient
+      HOST = "https://public.api.bsky.app".freeze
+
+      def get(nsid, query: nil)
+        uri = URI("#{HOST}/xrpc/#{nsid}")
+        uri.query = URI.encode_www_form(query) if query && !query.empty?
+        res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
+          http.get(uri.request_uri, "Accept" => "application/json")
+        end
+        raise Tempest::APIError.new(res.code.to_i, { "error" => res.message }) unless res.is_a?(Net::HTTPSuccess)
+        JSON.parse(res.body)
+      end
+    end
+
+    def initialize(client:, cache_dir:, fetcher: nil, converter: nil, async: true, executor: nil)
+      @client = client
+      @cache_dir = cache_dir
+      @fetcher = fetcher || self.class.default_fetcher
+      @converter = converter || self.class.default_converter
+      @async = async
+      @executor = executor || method(:default_executor)
+      @cache = {}
+      @pending = {}
+      @mutex = Mutex.new
+      FileUtils.mkdir_p(@cache_dir)
+    end
+
+    # Production HTTP fetcher used when no fetcher is injected. Returns the
+    # raw bytes and Content-Type header so the converter can pick the right
+    # input format.
+    def self.default_fetcher
+      @default_fetcher ||= lambda do |url|
+        uri = URI(url)
+        res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
+          http.get(uri.request_uri)
+        end
+        unless res.is_a?(Net::HTTPSuccess)
+          raise Tempest::APIError.new(res.code.to_i, { "error" => res.message })
+        end
+        [res.body, res["content-type"].to_s]
+      end
+    end
+
+    # Production format normalizer: shells out to ImageMagick to crop-fit the
+    # avatar into a 128x128 PNG. The crop pads non-square inputs so the Kitty
+    # graphics protocol can render at a consistent 1-row, 2-col aspect.
+    def self.default_converter
+      @default_converter ||= lambda do |bytes, content_type:|
+        ext = ext_for(content_type, bytes)
+        Dir.mktmpdir do |dir|
+          src = File.join(dir, "src.#{ext}")
+          dst = File.join(dir, "out.png")
+          File.binwrite(src, bytes)
+          _out, status = Open3.capture2e(
+            "magick", src,
+            "-resize", "128x128^",
+            "-gravity", "center",
+            "-extent", "128x128",
+            dst,
+          )
+          raise "magick convert failed" unless status.success?
+          File.binread(dst)
+        end
+      end
+    end
+
+    EXT_BY_MIME = {
+      "image/jpeg" => "jpg",
+      "image/jpg" => "jpg",
+      "image/png" => "png",
+      "image/webp" => "webp",
+      "image/gif" => "gif",
+      "image/avif" => "avif",
+    }.freeze
+
+    def self.ext_for(content_type, bytes)
+      mime = content_type.to_s.split(";").first.to_s.strip.downcase
+      return EXT_BY_MIME[mime] if EXT_BY_MIME.key?(mime)
+      head = bytes.byteslice(0, 16).to_s
+      return "jpg"  if head.start_with?("\xFF\xD8\xFF".b)
+      return "png"  if head.start_with?("\x89PNG\r\n\x1A\n".b)
+      return "gif"  if head.start_with?("GIF87a", "GIF89a")
+      return "webp" if head[0, 4] == "RIFF" && head[8, 4] == "WEBP"
+      "bin"
+    end
+
+    def path_for(did)
+      cached = @mutex.synchronize { @cache[did] }
+      return cached_value(cached) unless cached.nil?
+
+      if @async && (path = cached_file_for(did))
+        @mutex.synchronize { @cache[did] = path }
+        return path
+      end
+
+      if @async
+        enqueue_resolve(did)
+        nil
+      else
+        resolve_and_cache(did)
+      end
+    end
+
+    def seed(did, path)
+      @mutex.synchronize { @cache[did] = path }
+    end
+
+    private
+
+    def cached_value(value)
+      value.equal?(NOT_FOUND) ? nil : value
+    end
+
+    def cached_file_for(did)
+      Dir.glob(File.join(@cache_dir, "#{sanitize(did)}__*.png")).max_by { |path| File.mtime(path) }
+    end
+
+    def resolve_and_cache(did)
+      path = resolve_sync(did)
+      @mutex.synchronize { @cache[did] = path.nil? ? NOT_FOUND : path }
+      path
+    end
+
+    def enqueue_resolve(did)
+      should_dispatch = @mutex.synchronize do
+        next false if @pending[did]
+        @pending[did] = true
+        true
+      end
+      return unless should_dispatch
+
+      @executor.call do
+        begin
+          resolve_and_cache(did)
+        ensure
+          @mutex.synchronize { @pending.delete(did) }
+        end
+      end
+    end
+
+    def default_executor(&block)
+      Thread.new(&block)
+    end
+
+    def resolve_sync(did)
+      profile = @client.get("app.bsky.actor.getProfile", query: { "actor" => did })
+      avatar_url = profile.is_a?(Hash) ? profile["avatar"] : nil
+      return nil if avatar_url.nil? || avatar_url.empty?
+
+      bytes, content_type = @fetcher.call(avatar_url)
+      png = @converter.call(bytes, content_type: content_type)
+      cid = File.basename(URI(avatar_url).path)
+      path = File.join(@cache_dir, "#{sanitize(did)}__#{cid}.png")
+      File.binwrite(path, png)
+      path
+    rescue Tempest::APIError, StandardError
+      nil
+    end
+
+    def sanitize(did)
+      did.gsub(/[^A-Za-z0-9._-]/, "_")
+    end
+  end
+end

data/lib/tempest/cli.rb

@@ -7,6 +7,7 @@ require_relative "cursor_store"
 require_relative "timeline_store"
 require_relative "xrpc_client"
 require_relative "handle_resolver"
+require_relative "avatar_store"
 require_relative "follows"
 require_relative "jetstream/client"
 require_relative "jetstream/stream_manager"
@@ -46,6 +47,16 @@ module Tempest
       handle_resolver = Tempest::HandleResolver.new(client: client)
       handle_resolver.seed(session.did, session.handle)
 
+      # NOTE: we intentionally don't pass `client` (the XRPCClient) here.
+      # XRPCClient routes through Tempest::HTTP / Async, whose Fibers cannot
+      # be resumed across threads; AvatarStore runs resolution in background
+      # workers. DefaultProfileClient is a plain Net::HTTP client that hits
+      # public.api.bsky.app unauthenticated, which is thread-safe.
+      avatar_store = Tempest::AvatarStore.new(
+        client: Tempest::AvatarStore::DefaultProfileClient.new,
+        cache_dir: avatar_cache_dir(env),
+      )
+
       mode = feed_mode(argv: argv, env: env)
       plan = build_subscription(
         mode: mode, session: session, client: client,
@@ -86,8 +97,10 @@ module Tempest
         stream_output: screen.enabled? ? screen : Tempest::REPL::AsyncOutput.new(stdout),
         stream_manager: stream_manager,
         handle_resolver: handle_resolver,
+        avatar_store: avatar_store,
         timeline_store: timeline_store(env),
         opener: opener_for(env: env),
+        reauth: build_reauth(env, stdout, stdin, session_factory),
       )
 
       begin
@@ -143,6 +156,17 @@ module Tempest
       value.nil? || value.empty? ? nil : value
     end
 
+    # Builds the proc REPL::Runner uses to honour `:relogin`. The lambda
+    # re-reads credentials from `env` on each call (so a user can update env
+    # in-process if needed) and goes through the same 2FA prompt path as
+    # initial sign-in.
+    def build_reauth(env, stdout, stdin, session_factory)
+      lambda do
+        config = Tempest::Config.from_env(env)
+        create_with_2fa(config, env, stdout, stdin, session_factory)
+      end
+    end
+
     def create_with_2fa(config, env, stdout, stdin, session_factory)
       token = env["TEMPEST_AUTH_FACTOR_TOKEN"]
       session_factory.call(config, auth_factor_token: token)
@@ -194,6 +218,14 @@ module Tempest
       Tempest::TimelineStore.new(path: Tempest::TimelineStore.default_path(env))
     end
 
+    def avatar_cache_dir(env)
+      override = env["TEMPEST_AVATAR_CACHE_DIR"]
+      return override if override && !override.empty?
+      base = env["XDG_CACHE_HOME"]
+      base = File.join(env["HOME"] || Dir.home, ".cache") if base.nil? || base.empty?
+      File.join(base, "tempest", "avatars")
+    end
+
     def opener_for(env:, system_proc: Kernel.method(:system))
       cmd = env["TEMPEST_OPEN_CMD"]
       return Tempest::REPL::Runner::DEFAULT_OPENER if cmd.nil? || cmd.empty?

data/lib/tempest/jetstream/stream_manager.rb

@@ -143,6 +143,12 @@ module Tempest
               now = @clock.call
               @mutex.synchronize { @last_event_at = now }
               if event.respond_to?(:time_us) && event.time_us
+                # Replay protection: when reconnecting with a preserved cursor,
+                # Jetstream re-yields events at or below the cursor (the cursor
+                # is inclusive). Drop them so downstream sees each event once.
+                # last_event_at above is still updated, so the watchdog
+                # correctly sees the connection as alive.
+                next if cursor && event.time_us <= cursor
                 cursor = event.time_us
                 @mutex.synchronize { @cursor_state[:live] = cursor }
                 if @cursor_store && cursor != last_saved_cursor

data/lib/tempest/jetstream/watchdog.rb

@@ -11,8 +11,13 @@ module Tempest
     # therefore never runs. The watchdog periodically inspects
     # `stream_manager.last_event_at` and, if no event has arrived within
     # `threshold_seconds`, calls `force_reconnect` to break the stalled call.
+    #
+    # The threshold has to be long enough that a quiet but healthy stream
+    # (e.g. `--feed=self`, where only the user's own posts come through)
+    # doesn't trip it. macOS sleeps are typically minutes to hours, so 10
+    # minutes catches real stalls without flapping on idle streams.
     class Watchdog
-      DEFAULT_THRESHOLD_SECONDS = 90
+      DEFAULT_THRESHOLD_SECONDS = 600
       DEFAULT_INTERVAL_SECONDS = 30
 
       def initialize(stream_manager:,

data/lib/tempest/kitty.rb

@@ -0,0 +1,48 @@
+require "base64"
+
+require_relative "../tempest"
+
+module Tempest
+  # Encodes an image as a Kitty graphics protocol "transmit and display"
+  # escape sequence. Pure transformation: no I/O beyond optionally reading
+  # the bytes from a path. Output is meant to be inlined into a single
+  # terminal row when called with the defaults (rows: 1, cols: 2).
+  #
+  # Protocol reference:
+  #   https://sw.kovidgoyal.net/kitty/graphics-protocol/
+  #
+  # Key control opcodes used:
+  #   a=T   transmit and immediately display
+  #   f=100 source bytes are PNG
+  #   r=N   render at N terminal rows
+  #   c=N   render at N terminal columns
+  #   C=1   do not advance the cursor (image is drawn at the current cell,
+  #         the cursor stays where it was)
+  #   m=0/1 multi-chunk marker: 1 = more chunks follow, 0 = final chunk
+  module Kitty
+    CHUNK_BYTES = 4096
+
+    module_function
+
+    def inline(png, rows: 1, cols: 2)
+      bytes = png.is_a?(String) && File.file?(png) ? File.binread(png) : png
+      data = Base64.strict_encode64(bytes)
+      out = String.new
+      pos = 0
+      first = true
+      while pos < data.bytesize
+        piece = data.byteslice(pos, CHUNK_BYTES)
+        pos += CHUNK_BYTES
+        more = pos < data.bytesize ? 1 : 0
+        controls = if first
+          "a=T,f=100,r=#{rows},c=#{cols},C=1,m=#{more}"
+        else
+          "m=#{more}"
+        end
+        out << "\e_G#{controls};#{piece}\e\\"
+        first = false
+      end
+      out
+    end
+  end
+end

data/lib/tempest/repl/dispatcher.rb

@@ -5,7 +5,7 @@ module Tempest
     Command = Data.define(:name, :args)
 
     class Dispatcher
-      KNOWN_COMMANDS = %i[timeline quit help stream open].freeze
+      KNOWN_COMMANDS = %i[timeline quit help stream open relogin].freeze
       DOLLAR_ID = /\A\$[A-Z]{2}\z/.freeze
 
       def dispatch(input)

data/lib/tempest/repl/formatter.rb

@@ -2,6 +2,7 @@ require "time"
 require "uri"
 
 require_relative "../../tempest"
+require_relative "../kitty"
 
 module Tempest
   module REPL
@@ -31,13 +32,14 @@ module Tempest
 
       module_function
 
-      def post_line(post, registry: nil)
+      def post_line(post, registry: nil, avatar_store: nil)
         var = registry&.assign_post(post)
         facets = post.respond_to?(:facets) ? post.facets : nil
         body = annotate_urls(squeeze(post.text), registry, facets: facets)
         body = decorate_body(body)
         body = prepend_reply_marker(body, reply_parent_uri_of(post), registry)
-        compose(var, format_time(post.created_at), post.handle, nil, body)
+        icon = avatar_icon(post_did(post), avatar_store)
+        compose(var, format_time(post.created_at), post.handle, nil, body, icon: icon)
       end
 
       def decorate_body(text)
@@ -70,7 +72,7 @@ module Tempest
         time.respond_to?(:localtime) ? time.localtime.strftime("%H:%M") : time.to_s
       end
 
-      def event_line(event, registry: nil, resolver: nil)
+      def event_line(event, registry: nil, resolver: nil, avatar_store: nil)
         handle = resolver&.resolve(event.did)
         if event.operation == :delete
           body = "(deleted #{event.collection}/#{event.rkey})"
@@ -88,7 +90,8 @@ module Tempest
           body = prepend_reply_marker(body, reply_parent_uri_of(event), registry)
           var = registry&.assign_post(event)
         end
-        compose(var, format_time(event.created_at), handle, event.did, body)
+        icon = avatar_icon(event.did, avatar_store)
+        compose(var, format_time(event.created_at), handle, event.did, body, icon: icon)
       end
 
       def subject_owner_label(subject_uri, resolver, registry = nil)
@@ -182,14 +185,34 @@ module Tempest
         nil
       end
 
-      def compose(var, time, handle, did, text)
+      def compose(var, time, handle, did, text, icon: nil)
         prefix = ""
         prefix += id_label(var) if var
         prefix += bracket(time) if time
         identity = handle ? handle_label(handle) : did_label(did)
+        identity = "#{icon}  #{identity}" if icon
         "#{prefix}#{identity}: #{text}"
       end
 
+      # DID for a Post is extracted from its at:// URI, since Post itself only
+      # carries handle. AvatarStore is keyed by DID, so we have to derive it.
+      def post_did(post)
+        return nil unless post.respond_to?(:uri)
+        subject_did(post.uri)
+      end
+
+      # Returns the Kitty graphics escape for this DID's avatar, or nil when
+      # avatars are off, the store has nothing yet, or colors are disabled
+      # (test mode mirrors today's color suppression so snapshots stay clean).
+      def avatar_icon(did, avatar_store)
+        return nil unless avatar_store
+        return nil unless Formatter.color
+        return nil if did.nil? || did.empty?
+        path = avatar_store.path_for(did)
+        return nil if path.nil?
+        Kitty.inline(path)
+      end
+
       def bracket(time)
         Formatter.color ? "#{CYAN}[#{time}]#{RESET} " : "[#{time}] "
       end

data/lib/tempest/repl/runner.rb

@@ -18,6 +18,7 @@ module Tempest
           :timeline       Fetch and print the home timeline
           :stream on|off  Toggle the Jetstream live feed
           :open $LX       Open the URL with id $LX in the browser
+          :relogin        Re-authenticate when the cached session is dead
           :help           Show this help
           :quit           Exit tempest (or Ctrl-D)
 
@@ -28,9 +29,12 @@ module Tempest
 
       DEFAULT_OPENER = ->(url) { system("open", url) }
 
+      RELOGIN_HINT = "type :relogin to re-authenticate".freeze
+
       def initialize(session:, client:, input:, output:, dispatcher: Dispatcher.new,
                      stream_manager: nil, handle_resolver: nil, stream_output: nil,
-                     timeline_store: nil, registry: Registry.new, opener: DEFAULT_OPENER)
+                     timeline_store: nil, registry: Registry.new, opener: DEFAULT_OPENER,
+                     avatar_store: nil, reauth: nil)
         @session = session
         @client = client
         @input = input
@@ -42,6 +46,13 @@ module Tempest
         @timeline_store = timeline_store
         @registry = registry
         @opener = opener
+        @avatar_store = avatar_store
+        @reauth = reauth
+        # URIs already printed via bootstrap_timeline or backfill_timeline.
+        # Jetstream's cursor-replay can re-emit those same posts on startup
+        # (the persisted cursor is older than the getTimeline window), so the
+        # stream handler skips post events whose URI is in this set.
+        @displayed_post_uris = Set.new
       end
 
       def bootstrap_timeline
@@ -49,7 +60,7 @@ module Tempest
 
         cached = @timeline_store.load
         cached_posts = cached ? Array(cached[:posts]) : []
-        cached_posts.each { |post| @output.puts Formatter.post_line(post, registry: @registry) }
+        cached_posts.each { |post| print_post(post) }
 
         cached_uris = cached_posts.map(&:uri).to_set
         begin
@@ -60,7 +71,7 @@ module Tempest
         end
 
         new_posts = fetched.reject { |post| cached_uris.include?(post.uri) }
-        new_posts.reverse_each { |post| @output.puts Formatter.post_line(post, registry: @registry) }
+        new_posts.reverse_each { |post| print_post(post) }
 
         merged = cached_posts + new_posts.reverse
         @timeline_store.save(posts: merged)
@@ -97,6 +108,8 @@ module Tempest
             handle_reply(command.args[0], command.args[1])
           when :open
             handle_open(command.args.first)
+          when :relogin
+            handle_relogin
           when :unknown
             @output.puts "unknown command: :#{command.args.first}"
           end
@@ -116,7 +129,7 @@ module Tempest
         if posts.empty?
           @output.puts "(empty timeline)"
         else
-          posts.reverse_each { |post| @output.puts Formatter.post_line(post, registry: @registry) }
+          posts.reverse_each { |post| @output.puts Formatter.post_line(post, registry: @registry, avatar_store: @avatar_store) }
           @timeline_store&.save(posts: posts.reverse)
         end
       rescue Tempest::Error => e
@@ -126,10 +139,25 @@ module Tempest
       def handle_post(text)
         response = Post.create(@client, did: @session.did, text: text)
         @output.puts "posted: #{response["uri"]}"
+      rescue Tempest::AuthenticationError => e
+        @output.puts "error: #{e.message} (#{RELOGIN_HINT})"
       rescue Tempest::Error => e
         @output.puts "error: #{e.message}"
       end
 
+      def handle_relogin
+        if @reauth.nil?
+          @output.puts "relogin is not available in this session"
+          return
+        end
+
+        new_session = @reauth.call
+        @session.replace_with!(new_session)
+        @output.puts "signed in as @#{@session.handle}"
+      rescue Tempest::Error => e
+        @output.puts "relogin failed: #{e.message}"
+      end
+
       def handle_reply(var, body)
         target = @registry.find_post(var)
         if target.nil?
@@ -148,6 +176,8 @@ module Tempest
           reply: { uri: reply_uri_for(target), cid: target.cid },
         )
         @output.puts "posted: #{response["uri"]}"
+      rescue Tempest::AuthenticationError => e
+        @output.puts "error: #{e.message} (#{RELOGIN_HINT})"
       rescue Tempest::Error => e
         @output.puts "error: #{e.message}"
       end
@@ -202,17 +232,27 @@ module Tempest
         else
           return unless event.respond_to?(:create?) && event.create?
           return unless event.post? || event.like? || event.repost?
+          return if event.post? && @displayed_post_uris.include?(event.at_uri)
 
-          @stream_output.puts Formatter.event_line(event, registry: @registry, resolver: @handle_resolver)
+          @stream_output.puts Formatter.event_line(event, registry: @registry, resolver: @handle_resolver, avatar_store: @avatar_store)
+          @displayed_post_uris << event.at_uri if event.post?
         end
       end
 
       def backfill_timeline
         posts = Timeline.fetch(@client)
-        posts.reverse_each { |post| @stream_output.puts Formatter.post_line(post, registry: @registry) }
+        posts.reverse_each do |post|
+          next if @displayed_post_uris.include?(post.uri)
+          print_post(post, output: @stream_output)
+        end
       rescue Tempest::Error => e
         @stream_output.puts "-- timeline backfill failed: #{e.message}"
       end
+
+      def print_post(post, output: @output)
+        output.puts Formatter.post_line(post, registry: @registry, avatar_store: @avatar_store)
+        @displayed_post_uris << post.uri
+      end
     end
   end
 end

data/lib/tempest/repl/screen.rb

@@ -37,6 +37,7 @@ module Tempest
 
       def disable
         return unless @enabled
+        @io.print "\e_Ga=d,q=2\e\\"
         @io.print "\e[r"
         @io.flush if @io.respond_to?(:flush)
         @enabled = false
@@ -130,6 +131,7 @@ module Tempest
 
       def wrap_to_cols(line)
         return [line] unless @cols && @cols.positive?
+        return [line] if line.include?("\e_G")
         return [line] if Reline::Unicode.calculate_width(line, true) <= @cols
 
         chunks, _ = Reline::Unicode.split_by_width(line, @cols)

data/lib/tempest/session.rb

@@ -46,6 +46,7 @@ module Tempest
       @handle = handle
       @pds_host = pds_host
       @identifier = identifier
+      @refresh_mutex = Mutex.new
     end
 
     def access_expired?
@@ -54,7 +55,40 @@ module Tempest
       Time.now.to_i + EXPIRY_LEEWAY_SECONDS >= exp
     end
 
-    def refresh!
+    # Adopts another Session's credentials in place. Used by :relogin so the
+    # XRPCClient that already holds a reference to this Session keeps working
+    # without having to be reconstructed.
+    def replace_with!(other)
+      @refresh_mutex.synchronize do
+        @access_jwt = other.access_jwt
+        @refresh_jwt = other.refresh_jwt
+        @did = other.did
+        @handle = other.handle
+        @pds_host = other.pds_host
+      end
+      @on_change&.call(self)
+      self
+    end
+
+    # Refreshes the session using the current refresh_jwt.
+    #
+    # When `if_unchanged_from:` is supplied, the refresh is skipped if the
+    # session's access_jwt has already moved past that value. Combined with the
+    # internal mutex, this lets concurrent callers coalesce a single
+    # refreshSession round-trip: the first caller refreshes while the rest wait
+    # for the lock and then observe the new token, no-op'ing instead of issuing
+    # duplicate refresh requests.
+    def refresh!(if_unchanged_from: nil)
+      @refresh_mutex.synchronize do
+        return self if if_unchanged_from && @access_jwt != if_unchanged_from
+
+        perform_refresh
+      end
+    end
+
+    private
+
+    def perform_refresh
       url = "#{@pds_host}/xrpc/com.atproto.server.refreshSession"
       response = Tempest::HTTP.post_json(
         url,
@@ -77,8 +111,6 @@ module Tempest
       self
     end
 
-    private
-
     def jwt_exp(token)
       _, payload, _ = token.split(".")
       return nil if payload.nil?

data/lib/tempest/version.rb

@@ -1,3 +1,3 @@
 module Tempest
-  VERSION = "0.0.2"
+  VERSION = "0.1.1"
 end

data/lib/tempest/xrpc_client.rb

@@ -38,10 +38,11 @@ module Tempest
     end
 
     def perform
-      response = yield(@session.access_jwt)
+      attempted_jwt = @session.access_jwt
+      response = yield(attempted_jwt)
 
-      if response.unauthorized?
-        @session.refresh!
+      if auth_expired_response?(response)
+        @session.refresh!(if_unchanged_from: attempted_jwt)
         response = yield(@session.access_jwt)
       end
 
@@ -49,5 +50,13 @@ module Tempest
 
       response.body
     end
+
+    def auth_expired_response?(response)
+      return true if response.unauthorized?
+      return false unless response.status == 400
+      return false unless response.body.is_a?(Hash)
+
+      response.body["error"] == "ExpiredToken"
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tempest-rb
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.1
 platform: ruby
 authors:
 - Yuya Fujiwara
@@ -92,6 +92,7 @@ files:
 - README.md
 - exe/tempest
 - lib/tempest.rb
+- lib/tempest/avatar_store.rb
 - lib/tempest/cli.rb
 - lib/tempest/config.rb
 - lib/tempest/cursor_store.rb
@@ -106,6 +107,7 @@ files:
 - lib/tempest/jetstream/stream_manager.rb
 - lib/tempest/jetstream/subscription.rb
 - lib/tempest/jetstream/watchdog.rb
+- lib/tempest/kitty.rb
 - lib/tempest/post.rb
 - lib/tempest/repl/async_output.rb
 - lib/tempest/repl/dispatcher.rb