tempest-rb 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e74ff03fab2ee34902b7836bd77f0a41752135cda5aca37ca97570ac5ced79f3
-  data.tar.gz: edb35af23affe941bfdd361a04d86e18ded6ac068afd33df4d97d82aa62f445b
+  metadata.gz: c28613c22b61422cea99a83eb372bca8a1c1404c51f5d491846380bdd33d5196
+  data.tar.gz: efbfee28e847621e49afdc75da6d3ada58513dc16c29eaa29c1ef99753cb1336
 SHA512:
-  metadata.gz: 0453a2009c3bed58216a221aad38a71b5cd97529e5b6a0dc210a9c2b72be3172ffc9ec3593679c577540fa937cd3226940eba11e02e952bf8255d445da1226ba
-  data.tar.gz: ef8abc6996dfdc86fb54d3ffdcfc7025c37444042a3e8c3fb3008a87bd3aa613d737f873a999541e73b7393c692569ab7ff3d6e226757618115350c83e66f4c1
+  metadata.gz: f1670a1a245c27a1177efca4ee74fc23f83d625b40fbabe368126d82d25c5866768800adabe2c16a38094b7abc03ee36138a5d72c51a83b39f0dfa0b019362b3
+  data.tar.gz: 5bdb09991abbf954111f27bce93b8d6d22900442f910f70994e97130cb657a52fd083005c889d4aa1bc15a0c35617e6c480363e9bfd63f1ffc0ef82646e8cfc8

data/lib/tempest/avatar_store.rb

@@ -0,0 +1,190 @@
+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
+        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 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,6 +97,7 @@ 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),
       )
@@ -194,6 +206,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/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

@@ -30,7 +30,8 @@ module Tempest
 
       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)
         @session = session
         @client = client
         @input = input
@@ -42,6 +43,12 @@ module Tempest
         @timeline_store = timeline_store
         @registry = registry
         @opener = opener
+        @avatar_store = avatar_store
+        # 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 +56,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 +67,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)
@@ -116,7 +123,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
@@ -202,17 +209,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/version.rb

@@ -1,3 +1,3 @@
 module Tempest
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 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.0
 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