tempest-rb 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b619dd3e2a5448b9ed2f8c22bb286bec9fcb568f3f9d09db1a139774c226928
-  data.tar.gz: e06a2ee565a2cdf528f4c4c3f86257c55c8099e972d7ca4c239e8ae73aee605f
+  metadata.gz: a0b97b09816c158307f72637dbbcf78a30d1000c3ff8fe596fd2132b9c6a100c
+  data.tar.gz: 2e9adb8a4c025db72aa7e0841026e9508cc07f40c2009eb0dad348d80fb4a0e3
 SHA512:
-  metadata.gz: e282a10f7bd163df16b8ee0167bf2ac1fb8796a8d9e7bc797efaf2c63bc504f78c3356582e1b4534c3f179a2e5e4dfedebc44bbbb0c5f174727125ec9a1506ea
-  data.tar.gz: e6b13a102de8bc229b4c98559a7af2766370311a811aef1c32d31a5c64e606f4bd42eccf7a70a798997ae9c87337f3176d0644a33724ba5fd59ce62d714f73a1
+  metadata.gz: 741f2be6249b5be82eb250f979833ca0c2be9ce7d6a231fa528f163219c6f601fbd21b65c90c1aa4dbd83e43dbd5a021afcdef5a81dbc10f882ff81537c964cc
+  data.tar.gz: daa21dfb1cf269e63a4b0deaa57052f18cfd13af3f11bec8e263bc65507f78b16fb1b9732d5148062603a80cccd74eca990ef64fb748b1eca97025a7bc01b32f

data/README.md

@@ -17,6 +17,7 @@ This is an unofficial, third-party client. It is not affiliated with or endorsed
 
 - Ruby 4.0 or later
 - A Bluesky account and an [app password](https://bsky.app/settings/app-passwords)
+- [libvips](https://www.libvips.org/) for avatar thumbnail rendering (`brew install vips` on macOS, `apt install libvips42` on Debian/Ubuntu)
 
 ## Installation
 

data/lib/tempest/avatar_store.rb

@@ -1,8 +1,6 @@
 require "fileutils"
 require "json"
 require "net/http"
-require "open3"
-require "tmpdir"
 require "uri"
 
 require_relative "../tempest"
@@ -76,49 +74,21 @@ module Tempest
       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.
+    # Production format normalizer: uses libvips (via ruby-vips) to crop-fit
+    # the avatar into a 128x128, 8-bit sRGB PNG in-process. The center crop
+    # pads non-square inputs so the Kitty graphics protocol can render at a
+    # consistent 1-row, 2-col aspect, and the explicit 8-bit pngsave avoids
+    # the 16-bit output that some ImageMagick builds emit, which kitty refuses
+    # to draw.
     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
+        require "vips"
+        image = Vips::Image.thumbnail_buffer(bytes, 128, height: 128, crop: :centre)
+        image = image.colourspace("srgb") unless image.interpretation == :srgb
+        image.pngsave_buffer(bitdepth: 8)
       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?

data/lib/tempest/cli.rb

@@ -1,4 +1,5 @@
 require_relative "../tempest"
+require_relative "warning_filter"
 require_relative "commands/tui"
 require_relative "commands/base"
 require_relative "commands/whoami"
@@ -11,6 +12,8 @@ require_relative "debug_log"
 require_relative "deprecated_envs"
 require_relative "xrpc_client"
 
+Tempest::WarningFilter.install!
+
 module Tempest
   module CLI
     SUBCOMMANDS = %w[tui post feed whoami follow accounts login].freeze

data/lib/tempest/commands/post.rb

@@ -29,13 +29,16 @@ module Tempest
           langs: opts[:langs],
         )
 
+        url = Tempest::Post.bsky_url(at_uri: response["uri"], handle: session.handle)
+
         if opts[:json]
           require "json"
-          stdout.puts JSON.generate(
-            "uri" => response["uri"], "cid" => response["cid"],
-          )
+          payload = { "uri" => response["uri"], "cid" => response["cid"] }
+          payload["url"] = url if url
+          stdout.puts JSON.generate(payload)
         else
           stdout.puts "posted: #{response["uri"]}"
+          stdout.puts "url: #{url}" if url
         end
         0
       end
@@ -78,23 +81,9 @@ module Tempest
         end
       end
 
-      # Look up the parent's cid via com.atproto.repo.getRecord. AT Proto
-      # requires both uri and cid on a reply ref; we only have the URI from
-      # the CLI flag, so the lookup is necessary.
       def build_reply(uri, client:)
         return nil if uri.nil? || uri.empty?
-        repo, collection, rkey = parse_at_uri(uri)
-        record = client.get(
-          "com.atproto.repo.getRecord",
-          query: { "repo" => repo, "collection" => collection, "rkey" => rkey },
-        )
-        { uri: record.fetch("uri"), cid: record.fetch("cid") }
-      end
-
-      def parse_at_uri(uri)
-        match = uri.match(%r{\Aat://([^/]+)/([^/]+)/(.+)\z})
-        raise ArgumentError, "invalid at:// URI: #{uri.inspect}" unless match
-        [match[1], match[2], match[3]]
+        Tempest::Post.fetch_reply_refs(client, uri)
       end
     end
   end

data/lib/tempest/post.rb

@@ -47,10 +47,9 @@ module Tempest
     end
 
     # Compose a record for com.atproto.repo.createRecord (app.bsky.feed.post).
-    # When `reply` is provided, both root and parent are set to the same
-    # target. This is correct for top-level replies and a known v1 trade-off
-    # for replies deeper in a thread (AppView will nest the reply under
-    # `parent` instead of the original conversation root).
+    # `reply` is `{ root: {uri:, cid:}, parent: {uri:, cid:} }` so callers can
+    # preserve the original conversation root when replying deep in a thread.
+    # Use `fetch_reply_refs` to build this from a parent URI.
     def self.create(client, did:, text:, reply: nil, langs: nil,
                     created_at: Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%LZ"))
       record = {
@@ -59,14 +58,19 @@ module Tempest
         "createdAt" => created_at,
       }
       if reply
-        ref = { "uri" => reply[:uri], "cid" => reply[:cid] }
-        record["reply"] = { "root" => ref, "parent" => ref }
+        record["reply"] = {
+          "root"   => { "uri" => reply[:root][:uri],   "cid" => reply[:root][:cid] },
+          "parent" => { "uri" => reply[:parent][:uri], "cid" => reply[:parent][:cid] },
+        }
       end
 
       record["langs"] = langs if langs && !langs.empty?
 
-      link_facets = detect_link_facets(text)
-      record["facets"] = link_facets unless link_facets.empty?
+      facets = detect_mention_facets(text, client: client) +
+               detect_link_facets(text) +
+               detect_tag_facets(text)
+      facets.sort_by! { |f| f["index"]["byteStart"] }
+      record["facets"] = facets unless facets.empty?
 
       client.post(
         "com.atproto.repo.createRecord",
@@ -98,6 +102,129 @@ module Tempest
       )
     end
 
+    # Looks up `parent_uri` via com.atproto.repo.getRecord and returns reply
+    # refs that preserve the conversation root. If the parent is itself a
+    # reply, the parent's `reply.root` is reused so the new reply joins the
+    # original thread. If the parent is a top-level post, the parent stands
+    # in as the root (root and parent point at the same record).
+    def self.fetch_reply_refs(client, parent_uri)
+      match = parent_uri.to_s.match(%r{\Aat://([^/]+)/([^/]+)/(.+)\z})
+      raise ArgumentError, "invalid at:// URI: #{parent_uri.inspect}" unless match
+
+      record = client.get(
+        "com.atproto.repo.getRecord",
+        query: { "repo" => match[1], "collection" => match[2], "rkey" => match[3] },
+      )
+      parent_ref = { uri: record.fetch("uri"), cid: record.fetch("cid") }
+      parent_root = record.dig("value", "reply", "root")
+      root_ref =
+        if parent_root.is_a?(Hash) && parent_root["uri"] && parent_root["cid"]
+          { uri: parent_root["uri"], cid: parent_root["cid"] }
+        else
+          parent_ref
+        end
+      { root: root_ref, parent: parent_ref }
+    end
+
+    # Builds a bsky.app web URL from an at:// post URI. `handle` is preferred
+    # because human-readable URLs are nicer for sharing; when missing or empty
+    # the DID is used (bsky.app accepts both forms in the profile path).
+    # Returns nil when the URI is not an `app.bsky.feed.post` record.
+    def self.bsky_url(at_uri:, handle: nil)
+      match = at_uri.to_s.match(%r{\Aat://([^/]+)/app\.bsky\.feed\.post/(.+)\z})
+      return nil unless match
+
+      did = match[1]
+      rkey = match[2]
+      profile = handle && !handle.empty? ? handle : did
+      "https://bsky.app/profile/#{profile}/post/#{rkey}"
+    end
+
+    # Scans `text` for `@handle` mentions, resolves each to a DID via
+    # `app.bsky.actor.getProfile`, and builds AT Protocol mention facets.
+    # Without this, the AppView shows the mention as plain text instead of
+    # linking to the profile or generating a notification. Handles that fail
+    # to resolve are left as plain text (no facet added).
+    MENTION_PATTERN = /(?:\A|[\s(\[])@([a-zA-Z0-9._-]+\.[a-zA-Z]{2,})/n
+
+    def self.detect_mention_facets(text, client:)
+      return [] if text.nil? || text.empty?
+      return [] unless text.include?("@")
+
+      bytes = text.b
+      facets = []
+      pos = 0
+      while (match = MENTION_PATTERN.match(bytes, pos))
+        handle_byte_start = match.begin(1) - 1
+        handle_byte_end = match.end(1)
+        handle = match[1].dup.force_encoding(Encoding::UTF_8)
+        did = resolve_handle_did(handle, client: client)
+        if did
+          facets << {
+            "index" => { "byteStart" => handle_byte_start, "byteEnd" => handle_byte_end },
+            "features" => [
+              { "$type" => "app.bsky.richtext.facet#mention", "did" => did },
+            ],
+          }
+        end
+        pos = handle_byte_end
+      end
+      facets
+    end
+
+    def self.resolve_handle_did(handle, client:)
+      response = client.get("app.bsky.actor.getProfile", query: { "actor" => handle })
+      response.is_a?(Hash) ? response["did"] : nil
+    rescue Tempest::APIError
+      nil
+    end
+
+    # Scans `text` for `#hashtag` runs and builds AT Protocol tag facets.
+    # Without this the AppView shows the hashtag as plain text instead of
+    # linking it to the tag feed. The facet's `tag` value excludes the leading
+    # `#` (per app.bsky.richtext.facet#tag), while the byte index spans the
+    # `#` and the tag together. Mirrors the official @atproto/api detection:
+    # a hashtag must start the text or follow whitespace, contain at least one
+    # non-digit / non-punctuation character (so bare `#123` is ignored), and is
+    # capped at 64 graphemes after trailing punctuation is stripped.
+    # Zero-width / formatting code points the official regex excludes from a tag.
+    TAG_ZERO_WIDTH = "­⁠ ​‌‍⃢".freeze
+    TAG_PATTERN = /
+      (?:\A|\s)                                # start of text or whitespace
+      [\#＃]                               # '#' or fullwidth
+      (                                        # capture the tag body
+        (?!️)                             # not an emoji variation selector
+        [^\s#{TAG_ZERO_WIDTH}]*
+        [^\d\s\p{P}#{TAG_ZERO_WIDTH}]+          # >=1 non-digit, non-punct char
+        [^\s#{TAG_ZERO_WIDTH}]*
+      )
+    /x
+    TAG_TRAILING_PUNCTUATION = /\p{P}+\z/
+
+    def self.detect_tag_facets(text)
+      return [] if text.nil? || text.empty?
+      return [] unless text.include?("#") || text.include?("＃")
+
+      facets = []
+      pos = 0
+      while (match = TAG_PATTERN.match(text, pos))
+        pos = match.end(1)
+        tag = match[1].strip.sub(TAG_TRAILING_PUNCTUATION, "")
+        next if tag.empty? || tag.length > 64
+
+        hash_index = match.begin(1) - 1
+        byte_start = text[0...hash_index].bytesize
+        byte_end = byte_start + "##{tag}".bytesize
+        facets << {
+          "index" => { "byteStart" => byte_start, "byteEnd" => byte_end },
+          "features" => [
+            { "$type" => "app.bsky.richtext.facet#tag", "tag" => tag },
+          ],
+        }
+      end
+      facets
+    end
+
     # Scans `text` for bare URLs and builds AT Protocol link facets pointing
     # at each match. Without this, the AppView treats URLs as plain text and
     # does not render them as clickable links.

data/lib/tempest/repl/runner.rb

@@ -37,7 +37,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,
-                     avatar_store: nil, reauth: nil, compose: Compose.method(:run))
+                     avatar_store: nil, reauth: nil, compose: Compose.method(:run),
+                     clock: -> { Time.now })
         @session = session
         @client = client
         @input = input
@@ -52,11 +53,16 @@ module Tempest
         @avatar_store = avatar_store
         @reauth = reauth
         @compose = compose
+        @clock = clock
         # 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
+        # Unix-microseconds captured at stream start. Likes/reposts whose
+        # time_us is older are treated as cursor-replay catchup noise and
+        # suppressed; posts still come through so the timeline catches up.
+        @catchup_boundary_us = nil
       end
 
       def bootstrap_timeline
@@ -85,6 +91,7 @@ module Tempest
         return unless @stream_manager
         return if @stream_manager.running?
 
+        mark_catchup_boundary
         @stream_manager.start { |event| handle_stream_event(event) }
       end
 
@@ -202,11 +209,12 @@ module Tempest
           @output.puts "usage: $XX <text>"
           return
         end
+        reply_refs = Post.fetch_reply_refs(@client, reply_uri_for(target))
         response = Post.create(
           @client,
           did: @session.did,
           text: body,
-          reply: { uri: reply_uri_for(target), cid: target.cid },
+          reply: reply_refs,
         )
         @output.puts "posted: #{response["uri"]}"
       rescue Tempest::AuthenticationError => e
@@ -262,20 +270,11 @@ module Tempest
         target.respond_to?(:uri) && target.uri ? target.uri : target.at_uri
       end
 
-      # bsky.app accepts both handles and DIDs in the profile path. Prefer the
-      # handle when we have it (human-readable URLs are nicer for sharing or
-      # for the user to glance at), but fall back to the DID for posts that
-      # arrived through Jetstream where only the DID is known.
       def bsky_post_url(target)
-        at_uri = reply_uri_for(target)
-        match = at_uri.match(%r{\Aat://([^/]+)/app\.bsky\.feed\.post/(.+)\z})
-        return nil unless match
-
-        did = match[1]
-        rkey = match[2]
-        handle = target.respond_to?(:handle) ? target.handle : nil
-        profile = handle && !handle.empty? ? handle : did
-        "https://bsky.app/profile/#{profile}/post/#{rkey}"
+        Tempest::Post.bsky_url(
+          at_uri: reply_uri_for(target),
+          handle: target.respond_to?(:handle) ? target.handle : nil,
+        )
       end
 
       def handle_stream(arg)
@@ -289,6 +288,13 @@ module Tempest
           if @stream_manager.running?
             @output.puts "stream is already on"
           else
+            # Catch the user up to the present before the live worker resumes.
+            # Without this, the only path back to a fresh timeline after
+            # `:stream off` (or a long offline window before reconnect) is
+            # Jetstream's cursor replay — which can be empty if events were
+            # trimmed or filtered out client-side.
+            backfill_timeline
+            mark_catchup_boundary
             @stream_manager.start { |event| handle_stream_event(event) }
             @output.puts "stream on"
           end
@@ -311,12 +317,23 @@ module Tempest
           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)
+          return if (event.like? || event.repost?) && catchup_replay?(event)
 
           @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 mark_catchup_boundary
+        @catchup_boundary_us = (@clock.call.to_f * 1_000_000).to_i
+      end
+
+      def catchup_replay?(event)
+        return false unless @catchup_boundary_us
+        return false unless event.respond_to?(:time_us) && event.time_us
+        event.time_us < @catchup_boundary_us
+      end
+
       def backfill_timeline
         posts = Timeline.fetch(@client)
         posts.reverse_each do |post|

data/lib/tempest/version.rb

@@ -1,3 +1,3 @@
 module Tempest
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/lib/tempest/warning_filter.rb

@@ -0,0 +1,30 @@
+require_relative "../tempest"
+
+module Tempest
+  # Silences the Ruby 4.x experimental warning fired by `IO::Buffer`. The
+  # warning originates in `<internal:io>` but surfaces through async-dns /
+  # `resolv.rb` on the Jetstream WebSocket connect path, and the user cannot
+  # act on it. Other warnings, including unrelated `IO::Buffer` references,
+  # are forwarded to the original `Warning.warn` so genuine signals still
+  # reach stderr.
+  module WarningFilter
+    PATTERN = /IO::Buffer is experimental/
+
+    module_function
+
+    def suppress?(msg)
+      return false unless msg.is_a?(String)
+      msg.match?(PATTERN)
+    end
+
+    def install!
+      return if Warning.singleton_class.include?(self)
+      Warning.singleton_class.prepend(self)
+    end
+
+    def warn(msg, **kwargs)
+      return if Tempest::WarningFilter.suppress?(msg)
+      super
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tempest-rb
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Yuya Fujiwara
@@ -79,6 +79,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.28'
+- !ruby/object:Gem::Dependency
+  name: ruby-vips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
 description: tempest is a REPL-style terminal client for Bluesky built on AT Protocol
   and Ruby 4.0.
 email:
@@ -139,6 +153,7 @@ files:
 - lib/tempest/timeline.rb
 - lib/tempest/timeline_store.rb
 - lib/tempest/version.rb
+- lib/tempest/warning_filter.rb
 - lib/tempest/xrpc_client.rb
 licenses:
 - MIT