tempest-rb 0.0.1

data/lib/tempest/jetstream/watchdog.rb

@@ -0,0 +1,92 @@
+require_relative "../../tempest"
+require_relative "../debug_log"
+
+module Tempest
+  module Jetstream
+    # Detects stalled Jetstream connections and force-reconnects them.
+    #
+    # Background: after macOS sleep/wake the kernel may still consider the
+    # WebSocket's TCP socket alive, so Jetstream::Client#each_event blocks in
+    # `recv` indefinitely instead of raising. StreamManager's reconnect loop
+    # 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.
+    class Watchdog
+      DEFAULT_THRESHOLD_SECONDS = 90
+      DEFAULT_INTERVAL_SECONDS = 30
+
+      def initialize(stream_manager:,
+                     threshold_seconds: DEFAULT_THRESHOLD_SECONDS,
+                     interval_seconds: DEFAULT_INTERVAL_SECONDS,
+                     clock: -> { Time.now },
+                     sleeper: ->(s) { sleep(s) },
+                     logger: nil)
+        @stream_manager = stream_manager
+        @threshold_seconds = threshold_seconds
+        @interval_seconds = interval_seconds
+        @clock = clock
+        @sleeper = sleeper
+        @logger = logger || Tempest::DebugLog.build_null_logger
+        @thread = nil
+        @mutex = Mutex.new
+        @stopping = false
+      end
+
+      def start
+        @mutex.synchronize do
+          return if @thread&.alive?
+          @stopping = false
+          @thread = Thread.new { run }
+        end
+      end
+
+      def stop
+        thread = @mutex.synchronize do
+          @stopping = true
+          t = @thread
+          @thread = nil
+          t
+        end
+        return unless thread
+        thread.kill
+        thread.join
+      end
+
+      private
+
+      def run
+        Thread.current.report_on_exception = false
+        until stopping?
+          @sleeper.call(@interval_seconds)
+          break if stopping?
+          tick
+        end
+      end
+
+      def tick
+        last = @stream_manager.last_event_at
+        return unless @stream_manager.running?
+        return if last.nil?
+
+        elapsed = @clock.call - last
+        return unless elapsed > @threshold_seconds
+
+        @logger.warn("watchdog") do
+          "stalled stream elapsed_seconds=#{elapsed.round(1)} threshold=#{@threshold_seconds} — forcing reconnect"
+        end
+        @stream_manager.force_reconnect
+      rescue StandardError => e
+        # Never let a bad clock, logger, or stream_manager bug kill the thread.
+        # Best-effort log; if logger also raises, swallow.
+        begin
+          @logger.error("watchdog") { "tick error=#{e.class}: #{e.message}" }
+        rescue StandardError
+        end
+      end
+
+      def stopping?
+        @mutex.synchronize { @stopping }
+      end
+    end
+  end
+end

data/lib/tempest/post.rb

@@ -0,0 +1,56 @@
+require_relative "../tempest"
+require_relative "facet"
+
+module Tempest
+  Post = Data.define(:uri, :cid, :handle, :display_name, :text, :created_at, :facets, :reply_parent_uri) do
+    def initialize(uri:, cid:, handle:, display_name:, text:, created_at:,
+                   facets: [], reply_parent_uri: nil)
+      super
+    end
+
+    def self.from_feed_view(post)
+      post = post || {}
+      author = post["author"] || {}
+      record = post["record"] || {}
+      reply = record["reply"]
+      reply_parent = reply.is_a?(Hash) ? reply["parent"] : nil
+      new(
+        uri: post["uri"],
+        cid: post["cid"],
+        handle: author["handle"],
+        display_name: author["displayName"],
+        text: record["text"],
+        created_at: record["createdAt"],
+        facets: Facet.parse(record["facets"]),
+        reply_parent_uri: reply_parent.is_a?(Hash) ? reply_parent["uri"] : nil,
+      )
+    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).
+    def self.create(client, did:, text:, reply: nil,
+                    created_at: Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.%LZ"))
+      record = {
+        "$type" => "app.bsky.feed.post",
+        "text" => text,
+        "createdAt" => created_at,
+      }
+      if reply
+        ref = { "uri" => reply[:uri], "cid" => reply[:cid] }
+        record["reply"] = { "root" => ref, "parent" => ref }
+      end
+
+      client.post(
+        "com.atproto.repo.createRecord",
+        body: {
+          repo: did,
+          collection: "app.bsky.feed.post",
+          record: record,
+        },
+      )
+    end
+  end
+end

data/lib/tempest/repl/async_output.rb

@@ -0,0 +1,62 @@
+require_relative "../../tempest"
+
+module Tempest
+  module REPL
+    # Wraps an IO so writes from background threads (Jetstream events) don't
+    # smash Reline's prompt. Each puts clears the current terminal line and
+    # then asks Reline to re-render the prompt and the user's in-flight input
+    # buffer. Best-effort: if Reline isn't loaded or the rerender hook isn't
+    # available, we just degrade to a normal write.
+    class AsyncOutput
+      def initialize(io)
+        @io = io
+      end
+
+      def puts(*lines)
+        if lines.empty?
+          @io.print "\r\e[2K"
+          @io.puts
+        else
+          lines.each do |line|
+            @io.print "\r\e[2K"
+            @io.puts line
+          end
+        end
+        rerender_prompt
+      end
+
+      def print(*args)
+        @io.print(*args)
+      end
+
+      def write(*args)
+        @io.write(*args)
+      end
+
+      def flush
+        @io.flush if @io.respond_to?(:flush)
+      end
+
+      def tty?
+        @io.respond_to?(:tty?) ? @io.tty? : false
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @io.respond_to?(name, include_private)
+      end
+
+      def method_missing(name, *args, **kwargs, &block)
+        @io.send(name, *args, **kwargs, &block)
+      end
+
+      private
+
+      def rerender_prompt
+        return unless defined?(Reline)
+        Reline.line_editor&.rerender
+      rescue StandardError
+        # Reline's private APIs may move; never let a redraw failure surface.
+      end
+    end
+  end
+end

data/lib/tempest/repl/dispatcher.rb

@@ -0,0 +1,36 @@
+require_relative "../../tempest"
+
+module Tempest
+  module REPL
+    Command = Data.define(:name, :args)
+
+    class Dispatcher
+      KNOWN_COMMANDS = %i[timeline quit help stream open].freeze
+      DOLLAR_ID = /\A\$[A-Z]{2}\z/.freeze
+
+      def dispatch(input)
+        return Command.new(name: :quit, args: []) if input.nil?
+
+        stripped = input.strip
+        return Command.new(name: :noop, args: []) if stripped.empty?
+
+        if stripped.start_with?(":")
+          name, *rest = stripped[1..].split(/\s+/)
+          symbol = name.to_sym
+          if KNOWN_COMMANDS.include?(symbol)
+            Command.new(name: symbol, args: rest)
+          else
+            Command.new(name: :unknown, args: [name])
+          end
+        else
+          head, tail = stripped.split(/\s+/, 2)
+          if DOLLAR_ID.match?(head)
+            Command.new(name: :reply, args: [head, tail.to_s])
+          else
+            Command.new(name: :post, args: [stripped])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tempest/repl/formatter.rb

@@ -0,0 +1,205 @@
+require "time"
+require "uri"
+
+require_relative "../../tempest"
+
+module Tempest
+  module REPL
+    # Renders posts and Jetstream events as terminal lines, earthquake-style:
+    #   [$AA] [HH:MM] @handle: text
+    # The leading [$AA] is only emitted when a Registry is supplied (and the
+    # event is something that can be replied to — a post, not a delete or a
+    # like/repost record). URLs found in the body are annotated inline with
+    # their own ($LA) ids when a registry is supplied.
+    # ANSI colors are emitted only when Formatter.color is true (set by the
+    # CLI when stdout is a TTY); tests run with color disabled.
+    module Formatter
+      RESET = "\e[0m".freeze
+      CYAN = "\e[36m".freeze
+      GREEN = "\e[32m".freeze
+      DIM = "\e[2m".freeze
+      HASHTAG_BLUE = "\e[38;5;110m".freeze
+
+      HASHTAG_PATTERN = /#[[:alnum:]_]+/.freeze
+      URL_PATTERN = %r{https?://[^\s]+}.freeze
+      DECORATE_PATTERN = Regexp.union(URL_PATTERN, HASHTAG_PATTERN).freeze
+
+      class << self
+        attr_accessor :color
+      end
+      self.color = false
+
+      module_function
+
+      def post_line(post, registry: 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)
+      end
+
+      def decorate_body(text)
+        return text unless Formatter.color
+        return text if text.nil? || text.empty?
+
+        text.gsub(DECORATE_PATTERN) do |match|
+          color = match.start_with?("http") ? DIM : HASHTAG_BLUE
+          "#{color}#{match}#{RESET}"
+        end
+      end
+
+      def status_line(status)
+        body = case status.state
+        when :disconnected
+          status.reason == :error && status.error ? "disconnected: #{status.error.message}" : "disconnected"
+        when :reconnecting
+          "reconnecting..."
+        when :live
+          "live"
+        when :gapped
+          "fetching timeline (offline since #{format_status_time(status.since)})"
+        else
+          status.state.to_s
+        end
+        Formatter.color ? "#{DIM}-- #{body}#{RESET}" : "-- #{body}"
+      end
+
+      def format_status_time(time)
+        time.respond_to?(:localtime) ? time.localtime.strftime("%H:%M") : time.to_s
+      end
+
+      def event_line(event, registry: nil, resolver: nil)
+        handle = resolver&.resolve(event.did)
+        if event.operation == :delete
+          body = "(deleted #{event.collection}/#{event.rkey})"
+          var = nil
+        elsif event.respond_to?(:like?) && event.like?
+          body = "liked #{subject_owner_label(event.subject_uri, resolver)}"
+          var = nil
+        elsif event.respond_to?(:repost?) && event.repost?
+          body = "reposted #{subject_owner_label(event.subject_uri, resolver)}"
+          var = nil
+        else
+          facets = event.respond_to?(:facets) ? event.facets : nil
+          body = annotate_urls(squeeze(event.text), registry, facets: facets)
+          body = decorate_body(body)
+          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)
+      end
+
+      def subject_owner_label(subject_uri, resolver)
+        did = subject_did(subject_uri)
+        return "a post" unless did
+
+        handle = resolver&.resolve(did)
+        owner = handle ? handle_label(handle) : did_label(did)
+        "#{owner}'s post"
+      end
+
+      def subject_did(subject_uri)
+        return nil if subject_uri.nil? || subject_uri.empty?
+        match = subject_uri.match(%r{\Aat://([^/]+)/})
+        match && match[1]
+      end
+
+      def reply_parent_uri_of(record)
+        record.respond_to?(:reply_parent_uri) ? record.reply_parent_uri : nil
+      end
+
+      def prepend_reply_marker(body, reply_parent_uri, registry)
+        return body if reply_parent_uri.nil? || reply_parent_uri.empty?
+        return body unless registry
+
+        parent_var = registry.var_for_uri(reply_parent_uri)
+        marker = parent_var ? "↪#{parent_var} " : "↪ "
+        "#{marker}#{body}"
+      end
+
+      def annotate_urls(text, registry, facets: nil)
+        return text unless registry
+        text = text.to_s
+        if facets && !facets.empty?
+          return annotate_urls_with_facets(text, registry, facets)
+        end
+
+        urls = URI.extract(text, ["http", "https"]).uniq
+        urls.each do |url|
+          var = registry.assign_url(url)
+          text = text.sub(url, "#{url} (#{var})")
+        end
+        text
+      end
+
+      def annotate_urls_with_facets(text, registry, facets)
+        text = text.dup.force_encoding(Encoding::UTF_8)
+        bytesize = text.bytesize
+        valid = facets
+          .select { |f| f.byte_start.is_a?(Integer) && f.byte_end.is_a?(Integer) }
+          .select { |f| f.byte_start >= 0 && f.byte_end <= bytesize && f.byte_start < f.byte_end }
+          .sort_by(&:byte_start)
+
+        # Assign vars in reading order so earlier facets get earlier ids.
+        replacements = valid.map do |facet|
+          var = registry.assign_url(facet.uri)
+          domain = host_of(facet.uri) || facet.uri
+          [facet, "[#{domain} #{var}]"]
+        end
+
+        # Apply substitutions in reverse byte order so earlier ranges remain valid.
+        replacements.reverse_each do |facet, replacement|
+          head = text.byteslice(0, facet.byte_start) || ""
+          tail = text.byteslice(facet.byte_end, text.bytesize - facet.byte_end) || ""
+          text = (head + replacement + tail).force_encoding(Encoding::UTF_8)
+        end
+        text
+      end
+
+      def host_of(uri)
+        parsed = URI.parse(uri)
+        host = parsed.host
+        host && !host.empty? ? host : nil
+      rescue URI::InvalidURIError
+        nil
+      end
+
+      def squeeze(text)
+        text.to_s.gsub(/\s*\n\s*/, " ")
+      end
+
+      def format_time(iso)
+        return nil if iso.nil? || iso.empty?
+        Time.iso8601(iso).localtime.strftime("%H:%M")
+      rescue ArgumentError
+        nil
+      end
+
+      def compose(var, time, handle, did, text)
+        prefix = ""
+        prefix += id_label(var) if var
+        prefix += bracket(time) if time
+        identity = handle ? handle_label(handle) : did_label(did)
+        "#{prefix}#{identity}: #{text}"
+      end
+
+      def bracket(time)
+        Formatter.color ? "#{CYAN}[#{time}]#{RESET} " : "[#{time}] "
+      end
+
+      def id_label(var)
+        Formatter.color ? "#{DIM}[#{var}]#{RESET} " : "[#{var}] "
+      end
+
+      def handle_label(handle)
+        Formatter.color ? "#{GREEN}@#{handle}#{RESET}" : "@#{handle}"
+      end
+
+      def did_label(did)
+        Formatter.color ? "#{DIM}<#{did}>#{RESET}" : "<#{did}>"
+      end
+    end
+  end
+end

data/lib/tempest/repl/registry.rb

@@ -0,0 +1,57 @@
+require_relative "../id_var"
+
+module Tempest
+  module REPL
+    # Holds two IdVar rings (post + link) plus side tables that resolve a
+    # var string back to the original Post / URL. Lifetime is the
+    # current REPL session; nothing is persisted.
+    class Registry
+      def initialize
+        @post_ids = Tempest::IdVar.new(range: "AA".."ZZ")
+        @link_ids = Tempest::IdVar.new(range: "LA".."LZ")
+        @posts = {}
+        @urls = {}
+      end
+
+      def assign_post(post)
+        var = @post_ids.generate(post_key(post))
+        @posts[var] = post
+        var
+      end
+
+      def assign_url(url)
+        var = @link_ids.generate(url)
+        @urls[var] = url
+        var
+      end
+
+      def find_post(var)
+        @posts[var]
+      end
+
+      def find_url(var)
+        @urls[var]
+      end
+
+      # Reverse lookup: returns the var currently mapped to the given
+      # post URI, or nil if the URI has never been assigned or its slot
+      # has been recycled to a different post.
+      def var_for_uri(uri)
+        @posts.each do |var, post|
+          return var if post_key(post) == uri
+        end
+        nil
+      end
+
+      private
+
+      def post_key(post)
+        if post.respond_to?(:uri) && post.uri
+          post.uri
+        else
+          post.at_uri
+        end
+      end
+    end
+  end
+end