tempest-rb 0.0.1

data/lib/tempest/repl/runner.rb

@@ -0,0 +1,218 @@
+require "set"
+
+require_relative "../../tempest"
+require_relative "../timeline"
+require_relative "../post"
+require_relative "../jetstream/stream_manager"
+require_relative "dispatcher"
+require_relative "formatter"
+require_relative "registry"
+
+module Tempest
+  module REPL
+    class Runner
+      PROMPT = "tempest> ".freeze
+
+      HELP_TEXT = <<~HELP
+        Available commands:
+          :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
+          :help           Show this help
+          :quit           Exit tempest (or Ctrl-D)
+
+          $XX <text>      Reply to the post with id $XX
+
+        Any other input is sent as a new post.
+      HELP
+
+      DEFAULT_OPENER = ->(url) { system("open", url) }
+
+      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)
+        @session = session
+        @client = client
+        @input = input
+        @output = output
+        @stream_output = stream_output || output
+        @dispatcher = dispatcher
+        @stream_manager = stream_manager
+        @handle_resolver = handle_resolver
+        @timeline_store = timeline_store
+        @registry = registry
+        @opener = opener
+      end
+
+      def bootstrap_timeline
+        return unless @timeline_store
+
+        cached = @timeline_store.load
+        cached_posts = cached ? Array(cached[:posts]) : []
+        cached_posts.each { |post| @output.puts Formatter.post_line(post, registry: @registry) }
+
+        cached_uris = cached_posts.map(&:uri).to_set
+        begin
+          fetched = Timeline.fetch(@client)
+        rescue Tempest::Error => e
+          @output.puts "-- timeline fetch failed: #{e.message}"
+          return
+        end
+
+        new_posts = fetched.reject { |post| cached_uris.include?(post.uri) }
+        new_posts.reverse_each { |post| @output.puts Formatter.post_line(post, registry: @registry) }
+
+        merged = cached_posts + new_posts.reverse
+        @timeline_store.save(posts: merged)
+      end
+
+      def auto_start_stream
+        return unless @stream_manager
+        return if @stream_manager.running?
+
+        @stream_manager.start { |event| handle_stream_event(event) }
+      end
+
+      def run
+        loop do
+          line = read_line
+          command = @dispatcher.dispatch(line)
+
+          case command.name
+          when :quit
+            @stream_manager&.stop
+            @output.puts "bye."
+            break
+          when :noop
+            next
+          when :help
+            @output.puts HELP_TEXT
+          when :timeline
+            handle_timeline
+          when :stream
+            handle_stream(command.args.first)
+          when :post
+            handle_post(command.args.first)
+          when :reply
+            handle_reply(command.args[0], command.args[1])
+          when :open
+            handle_open(command.args.first)
+          when :unknown
+            @output.puts "unknown command: :#{command.args.first}"
+          end
+        end
+      end
+
+      private
+
+      def read_line
+        @input.readline(PROMPT)
+      rescue Interrupt
+        nil
+      end
+
+      def handle_timeline
+        posts = Timeline.fetch(@client)
+        if posts.empty?
+          @output.puts "(empty timeline)"
+        else
+          posts.reverse_each { |post| @output.puts Formatter.post_line(post, registry: @registry) }
+          @timeline_store&.save(posts: posts.reverse)
+        end
+      rescue Tempest::Error => e
+        @output.puts "error: #{e.message}"
+      end
+
+      def handle_post(text)
+        response = Post.create(@client, did: @session.did, text: text)
+        @output.puts "posted: #{response["uri"]}"
+      rescue Tempest::Error => e
+        @output.puts "error: #{e.message}"
+      end
+
+      def handle_reply(var, body)
+        target = @registry.find_post(var)
+        if target.nil?
+          @output.puts "unknown id: #{var}"
+          return
+        end
+        body = body.to_s.strip
+        if body.empty?
+          @output.puts "usage: $XX <text>"
+          return
+        end
+        response = Post.create(
+          @client,
+          did: @session.did,
+          text: body,
+          reply: { uri: reply_uri_for(target), cid: target.cid },
+        )
+        @output.puts "posted: #{response["uri"]}"
+      rescue Tempest::Error => e
+        @output.puts "error: #{e.message}"
+      end
+
+      def handle_open(var)
+        if var.nil? || var.empty?
+          @output.puts "usage: :open $LX"
+          return
+        end
+        url = @registry.find_url(var)
+        if url.nil?
+          @output.puts "unknown id: #{var}"
+          return
+        end
+        ok = @opener.call(url)
+        @output.puts "error: failed to open #{url}" unless ok
+      end
+
+      def reply_uri_for(target)
+        target.respond_to?(:uri) && target.uri ? target.uri : target.at_uri
+      end
+
+      def handle_stream(arg)
+        if @stream_manager.nil?
+          @output.puts "stream is not available in this session"
+          return
+        end
+
+        case arg
+        when nil, "on"
+          if @stream_manager.running?
+            @output.puts "stream is already on"
+          else
+            @stream_manager.start { |event| handle_stream_event(event) }
+            @output.puts "stream on"
+          end
+        when "off"
+          @stream_manager.stop
+          @output.puts "stream off"
+        else
+          @output.puts "usage: :stream on|off"
+        end
+      end
+
+      def handle_stream_event(event)
+        case event
+        when Tempest::Jetstream::StreamError
+          @stream_output.puts "stream error: #{event.cause.class}: #{event.cause.message}"
+        when Tempest::Jetstream::StreamStatus
+          @stream_output.puts Formatter.status_line(event)
+          backfill_timeline if event.state == :gapped
+        else
+          return unless event.respond_to?(:create?) && event.create?
+          return unless event.post? || event.like? || event.repost?
+
+          @stream_output.puts Formatter.event_line(event, registry: @registry, resolver: @handle_resolver)
+        end
+      end
+
+      def backfill_timeline
+        posts = Timeline.fetch(@client)
+        posts.reverse_each { |post| @stream_output.puts Formatter.post_line(post, registry: @registry) }
+      rescue Tempest::Error => e
+        @stream_output.puts "-- timeline backfill failed: #{e.message}"
+      end
+    end
+  end
+end

data/lib/tempest/repl/screen.rb

@@ -0,0 +1,119 @@
+require_relative "../../tempest"
+
+module Tempest
+  module REPL
+    # Implements the earthquake-style split layout: the bottom row holds the
+    # tempest> prompt, while the rest of the terminal scrolls timeline lines
+    # in from below. Built on the DECSTBM (top/bottom margin) escape sequence
+    # so we don't need a full curses screen.
+    #
+    # Sequences used:
+    #   CSI top;bottom r  set scrolling region
+    #   CSI r             reset scrolling region (full screen)
+    #   CSI row;col H     move cursor
+    #   ESC 7 / ESC 8     save/restore cursor (DECSC/DECRC)
+    class Screen
+      def initialize(io:, rows: nil)
+        @io = io
+        @rows = rows
+        @enabled = false
+        @mutex = Mutex.new
+      end
+
+      def enable
+        return unless @io.respond_to?(:tty?) && @io.tty?
+        rows = @rows || detect_rows
+        return unless rows && rows >= 4
+
+        @rows = rows
+        @io.print "\e[1;#{rows - 1}r"   # scrolling region: rows 1..rows-1
+        @io.print "\e[#{rows};1H"        # park cursor on the final row (prompt)
+        @io.flush if @io.respond_to?(:flush)
+        @enabled = true
+      end
+
+      def disable
+        return unless @enabled
+        @io.print "\e[r"
+        @io.flush if @io.respond_to?(:flush)
+        @enabled = false
+      end
+
+      def enabled?
+        @enabled
+      end
+
+      def puts(*lines)
+        @mutex.synchronize do
+          if @enabled
+            flat = lines.empty? ? [""] : lines.flat_map { |l| l.to_s.split("\n") }
+            flat.each { |line| insert_above_prompt(line) }
+          else
+            # Best-effort write that doesn't shred the prompt when we don't have
+            # a scrolling region in place. Reline rerender is invoked by
+            # AsyncOutput; Screen itself stays neutral here.
+            (lines.empty? ? [""] : lines).each do |line|
+              @io.print "\r\e[2K"
+              @io.puts line
+            end
+            @io.flush if @io.respond_to?(:flush)
+          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 detect_rows
+        return nil unless defined?(IO) && IO.respond_to?(:console)
+        console = IO.console
+        return nil unless console
+        rows, _cols = console.winsize
+        rows
+      rescue StandardError
+        nil
+      end
+
+      def insert_above_prompt(line)
+        bottom_of_region = @rows - 1
+        @io.print "\e7"                       # save cursor
+        @io.print "\e[#{bottom_of_region};1H" # move to last row of scrolling region
+        @io.print "\r\e[2K"                   # clear that row first
+        @io.print "#{line}\n"                 # write line; \n scrolls region up by 1
+        @io.print "\e8"                       # restore cursor
+        @io.flush if @io.respond_to?(:flush)
+      end
+
+      def rerender_prompt
+        return unless defined?(Reline)
+        Reline.line_editor&.rerender
+      rescue StandardError
+        # never let a redraw failure surface
+      end
+    end
+  end
+end

data/lib/tempest/session.rb

@@ -0,0 +1,91 @@
+require "base64"
+require "json"
+
+require_relative "../tempest"
+require_relative "http"
+
+module Tempest
+  class Session
+    EXPIRY_LEEWAY_SECONDS = 30
+
+    attr_reader :access_jwt, :refresh_jwt, :did, :handle, :pds_host
+    attr_accessor :on_change, :identifier
+
+    def self.create(config, auth_factor_token: nil)
+      url = "#{config.pds_host}/xrpc/com.atproto.server.createSession"
+      body = { identifier: config.identifier, password: config.app_password }
+      body[:authFactorToken] = auth_factor_token if auth_factor_token
+
+      response = Tempest::HTTP.post_json(url, body: body)
+
+      unless response.ok?
+        details = response.body.is_a?(Hash) ? response.body : {}
+        raise AuthenticationError.new(
+          "createSession failed (#{response.status}): #{details["message"] || response.body.inspect}",
+          code: details["error"],
+        )
+      end
+
+      from_payload(response.body, pds_host: config.pds_host)
+    end
+
+    def self.from_payload(payload, pds_host:)
+      new(
+        access_jwt: payload.fetch("accessJwt"),
+        refresh_jwt: payload.fetch("refreshJwt"),
+        did: payload.fetch("did"),
+        handle: payload.fetch("handle"),
+        pds_host: pds_host,
+      )
+    end
+
+    def initialize(access_jwt:, refresh_jwt:, did:, handle:, pds_host:, identifier: nil)
+      @access_jwt = access_jwt
+      @refresh_jwt = refresh_jwt
+      @did = did
+      @handle = handle
+      @pds_host = pds_host
+      @identifier = identifier
+    end
+
+    def access_expired?
+      exp = jwt_exp(@access_jwt)
+      return true if exp.nil?
+      Time.now.to_i + EXPIRY_LEEWAY_SECONDS >= exp
+    end
+
+    def refresh!
+      url = "#{@pds_host}/xrpc/com.atproto.server.refreshSession"
+      response = Tempest::HTTP.post_json(
+        url,
+        headers: { "Authorization" => "Bearer #{@refresh_jwt}" },
+      )
+
+      unless response.ok?
+        details = response.body.is_a?(Hash) ? response.body : {}
+        raise AuthenticationError.new(
+          "refreshSession failed (#{response.status}): #{details["message"] || response.body.inspect}",
+          code: details["error"],
+        )
+      end
+
+      @access_jwt = response.body.fetch("accessJwt")
+      @refresh_jwt = response.body.fetch("refreshJwt")
+      @did = response.body.fetch("did")
+      @handle = response.body.fetch("handle")
+      @on_change&.call(self)
+      self
+    end
+
+    private
+
+    def jwt_exp(token)
+      _, payload, _ = token.split(".")
+      return nil if payload.nil?
+      decoded = Base64.urlsafe_decode64(payload + "=" * ((4 - payload.size % 4) % 4))
+      JSON.parse(decoded)["exp"]
+    rescue ArgumentError, JSON::ParserError
+      nil
+    end
+  end
+end

data/lib/tempest/session_store.rb

@@ -0,0 +1,66 @@
+require "fileutils"
+require "json"
+
+require_relative "../tempest"
+require_relative "session"
+
+module Tempest
+  class SessionStore
+    def self.default_path(env = ENV)
+      explicit = env["TEMPEST_SESSION_PATH"]
+      return explicit if explicit && !explicit.empty?
+
+      base = env["XDG_CONFIG_HOME"]
+      base = File.join(env["HOME"].to_s, ".config") if base.nil? || base.empty?
+      File.join(base, "tempest", "session.json")
+    end
+
+    def initialize(path:)
+      @path = path
+    end
+
+    attr_reader :path
+
+    def save(session, identifier:)
+      payload = {
+        "identifier" => identifier,
+        "pds_host" => session.pds_host,
+        "did" => session.did,
+        "handle" => session.handle,
+        "access_jwt" => session.access_jwt,
+        "refresh_jwt" => session.refresh_jwt,
+      }
+
+      FileUtils.mkdir_p(File.dirname(@path))
+      File.open(@path, File::WRONLY | File::CREAT | File::TRUNC, 0o600) do |io|
+        io.write(JSON.generate(payload))
+      end
+      File.chmod(0o600, @path)
+    end
+
+    def load(identifier: nil, pds_host: nil)
+      return nil unless File.exist?(@path)
+
+      raw = File.read(@path)
+      data = JSON.parse(raw)
+      return nil unless data.is_a?(Hash)
+      return nil if identifier && data["identifier"] != identifier
+      return nil if pds_host && data["pds_host"] != pds_host
+
+      Tempest::Session.new(
+        access_jwt: data.fetch("access_jwt"),
+        refresh_jwt: data.fetch("refresh_jwt"),
+        did: data.fetch("did"),
+        handle: data.fetch("handle"),
+        pds_host: data.fetch("pds_host"),
+        identifier: data["identifier"],
+      )
+    rescue JSON::ParserError, KeyError
+      nil
+    end
+
+    def clear
+      File.delete(@path) if File.exist?(@path)
+    end
+  end
+end

data/lib/tempest/timeline.rb

@@ -0,0 +1,15 @@
+require_relative "../tempest"
+require_relative "post"
+
+module Tempest
+  module Timeline
+    DEFAULT_LIMIT = 50
+
+    module_function
+
+    def fetch(client, limit: DEFAULT_LIMIT)
+      response = client.get("app.bsky.feed.getTimeline", query: { "limit" => limit })
+      Array(response["feed"]).map { |entry| Post.from_feed_view(entry["post"]) }
+    end
+  end
+end

data/lib/tempest/timeline_store.rb

@@ -0,0 +1,108 @@
+require "fileutils"
+require "json"
+require "time"
+
+require_relative "../tempest"
+require_relative "post"
+require_relative "facet"
+
+module Tempest
+  # Persists the home timeline snapshot so a restarted tempest can show the
+  # last-seen posts before the network is even reachable. Stored alongside
+  # session.json / cursor.json under XDG_CONFIG_HOME.
+  #
+  # Callers pass posts in chronological order (oldest first, newest last); the
+  # store keeps only the most recent MAX_POSTS to bound disk usage.
+  class TimelineStore
+    MAX_POSTS = 50
+
+    def self.default_path(env = ENV)
+      explicit = env["TEMPEST_TIMELINE_PATH"]
+      return explicit if explicit && !explicit.empty?
+
+      base = env["XDG_CONFIG_HOME"]
+      base = File.join(env["HOME"].to_s, ".config") if base.nil? || base.empty?
+      File.join(base, "tempest", "timeline.json")
+    end
+
+    def initialize(path:)
+      @path = path
+    end
+
+    attr_reader :path
+
+    def save(posts:, at: Time.now)
+      payload = {
+        "posts" => posts.last(MAX_POSTS).map { |p| serialize_post(p) },
+        "saved_at" => at.utc.iso8601(6),
+      }
+
+      FileUtils.mkdir_p(File.dirname(@path))
+      File.open(@path, File::WRONLY | File::CREAT | File::TRUNC, 0o600) do |io|
+        io.write(JSON.generate(payload))
+      end
+    end
+
+    def load
+      return nil unless File.exist?(@path)
+
+      data = JSON.parse(File.read(@path))
+      return nil unless data.is_a?(Hash) && data["posts"].is_a?(Array) && data["saved_at"]
+
+      {
+        posts: data["posts"].map { |hash| deserialize_post(hash) },
+        saved_at: Time.iso8601(data["saved_at"]),
+      }
+    rescue JSON::ParserError, ArgumentError
+      nil
+    end
+
+    private
+
+    def serialize_post(post)
+      {
+        "uri" => post.uri,
+        "cid" => post.cid,
+        "handle" => post.handle,
+        "display_name" => post.display_name,
+        "text" => post.text,
+        "created_at" => post.created_at,
+        "facets" => post.facets.map { |f| serialize_facet(f) },
+        "reply_parent_uri" => post.reply_parent_uri,
+      }
+    end
+
+    def deserialize_post(hash)
+      Post.new(
+        uri: hash["uri"],
+        cid: hash["cid"],
+        handle: hash["handle"],
+        display_name: hash["display_name"],
+        text: hash["text"],
+        created_at: hash["created_at"],
+        facets: deserialize_facets(hash["facets"]),
+        reply_parent_uri: hash["reply_parent_uri"],
+      )
+    end
+
+    def serialize_facet(facet)
+      {
+        "byte_start" => facet.byte_start,
+        "byte_end" => facet.byte_end,
+        "uri" => facet.uri,
+      }
+    end
+
+    def deserialize_facets(raw)
+      return [] unless raw.is_a?(Array)
+      raw.filter_map do |hash|
+        next nil unless hash.is_a?(Hash)
+        byte_start = hash["byte_start"]
+        byte_end = hash["byte_end"]
+        uri = hash["uri"]
+        next nil unless byte_start.is_a?(Integer) && byte_end.is_a?(Integer) && uri.is_a?(String)
+        Facet::Link.new(byte_start: byte_start, byte_end: byte_end, uri: uri)
+      end
+    end
+  end
+end

data/lib/tempest/version.rb

@@ -0,0 +1,3 @@
+module Tempest
+  VERSION = "0.0.1"
+end

data/lib/tempest/xrpc_client.rb

@@ -0,0 +1,53 @@
+require_relative "../tempest"
+require_relative "http"
+
+module Tempest
+  class XRPCClient
+    def initialize(session)
+      @session = session
+    end
+
+    def get(nsid, query: nil)
+      perform { |access_jwt|
+        Tempest::HTTP.get_json(
+          endpoint(nsid),
+          headers: auth_headers(access_jwt),
+          query: query,
+        )
+      }
+    end
+
+    def post(nsid, body:)
+      perform { |access_jwt|
+        Tempest::HTTP.post_json(
+          endpoint(nsid),
+          headers: auth_headers(access_jwt),
+          body: body,
+        )
+      }
+    end
+
+    private
+
+    def endpoint(nsid)
+      "#{@session.pds_host}/xrpc/#{nsid}"
+    end
+
+    def auth_headers(access_jwt)
+      { "Authorization" => "Bearer #{access_jwt}" }
+    end
+
+    def perform
+      response = yield(@session.access_jwt)
+
+      if response.unauthorized?
+        @session.refresh!
+        response = yield(@session.access_jwt)
+      end
+
+      raise Tempest::APIError.new(response.status, response.body) unless response.ok?
+
+      response.body
+    end
+  end
+end

data/lib/tempest.rb

@@ -0,0 +1,24 @@
+require_relative "tempest/version"
+
+module Tempest
+  class Error < StandardError; end
+
+  class AuthenticationError < Error
+    attr_reader :code
+
+    def initialize(message, code: nil)
+      super(message)
+      @code = code
+    end
+  end
+
+  class APIError < Error
+    attr_reader :status, :body
+
+    def initialize(status, body)
+      @status = status
+      @body = body
+      super("XRPC request failed with status #{status}: #{body.inspect}")
+    end
+  end
+end