tempest-rb 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c28613c22b61422cea99a83eb372bca8a1c1404c51f5d491846380bdd33d5196
-  data.tar.gz: efbfee28e847621e49afdc75da6d3ada58513dc16c29eaa29c1ef99753cb1336
+  metadata.gz: b397a067ca8e4f637036351fd8d3f29f41dc7ef6a96d809c8f793993f34c940d
+  data.tar.gz: 83435fddf2631e5d16afdc8d185ae3b3ba5666c1a5bb6b838705e5ee4fc526f2
 SHA512:
-  metadata.gz: f1670a1a245c27a1177efca4ee74fc23f83d625b40fbabe368126d82d25c5866768800adabe2c16a38094b7abc03ee36138a5d72c51a83b39f0dfa0b019362b3
-  data.tar.gz: 5bdb09991abbf954111f27bce93b8d6d22900442f910f70994e97130cb657a52fd083005c889d4aa1bc15a0c35617e6c480363e9bfd63f1ffc0ef82646e8cfc8
+  metadata.gz: c770fedb069f714b7a280535efe1c5984001bfcad6cce6a1ab4cc0e6ee8ee579fec9402659578b1573572c98d40fd089fe82f5469c0e040f0cc33b1dfeda39a0
+  data.tar.gz: 3cba24306fa9a90c00f44c77bd768753b1ab26f3420be6fb3706b275bdbaa426e869ce791248e3c0be7a8dfc27e673610f7286b60ffb416806c4b01b26ccf724

data/README.md

@@ -101,6 +101,25 @@ A built-in watchdog runs alongside the Jetstream consumer regardless of logging:
 
 To inspect the log, grep by component tag: `grep '\[stream\]' ~/tempest-debug.log` shows connect, reconnect, gap, and disconnect events, while `grep '\[watchdog\]' ~/tempest-debug.log` shows forced reconnects.
 
+## Non-interactive CLI
+
+Once you have signed in once with `tempest tui`, you can call the CLI from scripts and tools:
+
+```sh
+tempest whoami --json
+tempest post "今日もよろしくお願いします"
+tempest feed me --since today --format json | jq '.text'
+tempest feed author asonas.bsky.social --limit 20
+```
+
+`--format=json` emits newline-delimited JSON; one post per line. The schema is documented in `lib/tempest/post_view.rb`.
+
+`--format=raw` emits the underlying `getAuthorFeed`/`getTimeline` response pretty-printed; do not rely on its shape.
+
+`--format=line` (default when stdout is a TTY) prints the same single-line representation as the TUI scroll buffer.
+
+The non-interactive subcommands require a cached session on disk. If your cache is missing or expired, run `tempest tui` once to refresh it.
+
 ## Development
 
 ```sh

data/lib/tempest/avatar_store.rb

@@ -123,6 +123,11 @@ module Tempest
       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
@@ -141,6 +146,10 @@ module Tempest
       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 }

data/lib/tempest/cli.rb

@@ -1,25 +1,15 @@
 require_relative "../tempest"
-require_relative "config"
-require_relative "debug_log"
-require_relative "session"
-require_relative "session_store"
-require_relative "cursor_store"
-require_relative "timeline_store"
+require_relative "commands/tui"
+require_relative "commands/base"
+require_relative "commands/whoami"
+require_relative "commands/post"
+require_relative "commands/feed"
 require_relative "xrpc_client"
-require_relative "handle_resolver"
-require_relative "avatar_store"
-require_relative "follows"
-require_relative "jetstream/client"
-require_relative "jetstream/stream_manager"
-require_relative "jetstream/subscription"
-require_relative "jetstream/watchdog"
-require_relative "repl/runner"
-require_relative "repl/formatter"
-require_relative "repl/async_output"
-require_relative "repl/screen"
 
 module Tempest
   module CLI
+    SUBCOMMANDS = %w[tui post feed whoami].freeze
+
     module_function
 
     def run(argv: ARGV, env: ENV, stdout: $stdout, stderr: $stderr, stdin: $stdin,
@@ -31,295 +21,120 @@ module Tempest
       end
 
       if argv.include?("--help") || argv.include?("-h")
-        stdout.puts help_text
+        stdout.puts Tempest::Commands::Tui.help_text
         return 0
       end
 
-      Tempest::REPL::Formatter.color = stdout.respond_to?(:tty?) && stdout.tty? && env["NO_COLOR"].to_s.empty?
-
-      debug_logger = build_debug_logger(env)
-
-      store ||= Tempest::SessionStore.new(path: Tempest::SessionStore.default_path(env))
-      session = sign_in(env, stdout, stdin, session_factory, store: store)
-      client = Tempest::XRPCClient.new(session)
-      input = RelineReader.new
-
-      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,
-        handle_resolver: handle_resolver, stdout: stdout,
-      )
-
-      jetstream_client = Tempest::Jetstream::Client.new(
-        wanted_collections: [
-          "app.bsky.feed.post",
-          "app.bsky.feed.like",
-          "app.bsky.feed.repost",
-        ],
-        wanted_dids: plan.wanted_dids,
-      )
-      stream_manager = Tempest::Jetstream::StreamManager.new(
-        client: jetstream_client,
-        cursor_store: cursor_store(env),
-        filter: plan.filter,
-        logger: debug_logger,
-      )
-      watchdog = Tempest::Jetstream::Watchdog.new(
-        stream_manager: stream_manager,
-        logger: debug_logger,
-        **watchdog_options(env),
-      )
-
-      stdout.puts "tempest #{Tempest::VERSION} — signed in as @#{session.handle}"
-      stdout.puts "Type :help for commands, :quit to exit."
-
-      screen = Tempest::REPL::Screen.new(io: stdout)
-      screen.enable
-
-      runner = Tempest::REPL::Runner.new(
-        session: session,
-        client: client,
-        input: input,
-        output: screen.enabled? ? screen : stdout,
-        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),
-      )
-
-      begin
-        runner.bootstrap_timeline
-
-        if stream_default_on?(argv, env)
-          runner.auto_start_stream
+      head = argv.first
+      case
+      when head.nil?, head.start_with?("-"), head == "tui"
+        rest = (head == "tui") ? argv.drop(1) : argv
+        Tempest::Commands::Tui.call(
+          argv: rest, env: env, stdout: stdout, stderr: stderr, stdin: stdin,
+          session_factory: session_factory, store: store,
+        )
+      when SUBCOMMANDS.include?(head)
+        begin
+          dispatch_subcommand(head, argv, env: env, stdout: stdout, stderr: stderr, stdin: stdin)
+        rescue Tempest::Error, ArgumentError => e
+          stderr.puts "error: #{e.message}"
+          Tempest::Commands::Base.exit_code_for(e)
         end
+      else
+        stderr.puts "unknown command: #{head.inspect}"
+        64
+      end
+    end
 
-        watchdog.start
-        runner.run
-        0
-      ensure
-        watchdog.stop
-        screen.disable
+    def dispatch_subcommand(head, argv, env:, stdout:, stderr:, stdin:)
+      session = Tempest::Commands::Base.authenticate(env: env, stderr: stderr)
+      return 3 if session.nil?
+      client = Tempest::XRPCClient.new(session)
+      case head
+      when "whoami"
+        Tempest::Commands::Whoami.call(
+          argv: argv.drop(1), session: session,
+          stdout: stdout, stderr: stderr,
+        )
+      when "post"
+        Tempest::Commands::Post.call(
+          argv: argv.drop(1), session: session, client: client,
+          stdout: stdout, stderr: stderr, stdin: stdin,
+        )
+      when "feed"
+        Tempest::Commands::Feed.call(
+          argv: argv.drop(1), session: session, client: client,
+          stdout: stdout, stderr: stderr,
+        )
       end
-    rescue Tempest::Config::MissingValue => e
-      stderr.puts "configuration error: #{e.message}"
-      stderr.puts "Set TEMPEST_IDENTIFIER and TEMPEST_APP_PASSWORD before launching."
-      2
-    rescue Tempest::AuthenticationError => e
-      stderr.puts "authentication failed: #{e.message}"
-      3
-    rescue Tempest::Error => e
-      stderr.puts "error: #{e.message}"
-      1
     end
 
-    def sign_in(env, stdout, stdin, session_factory, store:)
-      identifier_hint = nil_if_empty(env["TEMPEST_IDENTIFIER"])
-      pds_host_hint = nil_if_empty(env["TEMPEST_PDS_HOST"])
+    VALID_FEED_MODES = Tempest::Commands::Tui::VALID_FEED_MODES
 
-      if (existing = store.load(identifier: identifier_hint, pds_host: pds_host_hint))
-        attach_store(existing, store, existing.identifier || identifier_hint)
-        begin
-          existing.refresh!
-          return existing
-        rescue Tempest::Error => e
-          existing.on_change = nil
-          stdout.puts "[tempest] cached session refresh failed: #{e.message}"
-          stdout.puts "[tempest] cache kept at #{store.path}; falling back to TEMPEST_IDENTIFIER/TEMPEST_APP_PASSWORD"
-        end
-      end
+    # Forwarding delegates — keep Tempest::CLI.* callable so existing tests
+    # do not need modification. All logic lives in Tempest::Commands::Tui.
 
-      config = Tempest::Config.from_env(env)
-      session = create_with_2fa(config, env, stdout, stdin, session_factory)
-      attach_store(session, store, config.identifier)
-      store.save(session, identifier: config.identifier)
-      session
+    def sign_in(env, stdout, stdin, session_factory, store:)
+      Tempest::Commands::Tui.sign_in(env, stdout, stdin, session_factory, store: store)
     end
 
     def nil_if_empty(value)
-      value.nil? || value.empty? ? nil : value
+      Tempest::Commands::Tui.nil_if_empty(value)
     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)
-    rescue Tempest::AuthenticationError => e
-      raise unless e.code == "AuthFactorTokenRequired" && token.nil?
-
-      stdout.puts "Bluesky sent a sign-in code to your email. Enter it below."
-      stdout.print "code: "
-      stdout.flush
-      code = stdin.gets&.strip
-      raise Tempest::AuthenticationError.new("sign-in cancelled (no code entered)", code: e.code) if code.nil? || code.empty?
+    def build_reauth(env, stdout, stdin, session_factory)
+      Tempest::Commands::Tui.build_reauth(env, stdout, stdin, session_factory)
+    end
 
-      session_factory.call(config, auth_factor_token: code)
+    def create_with_2fa(config, env, stdout, stdin, session_factory)
+      Tempest::Commands::Tui.create_with_2fa(config, env, stdout, stdin, session_factory)
     end
 
     def stream_default_on?(argv, env)
-      return false if argv.include?("--no-stream")
-      return false if env["TEMPEST_NO_STREAM"] == "1"
-      true
+      Tempest::Commands::Tui.stream_default_on?(argv, env)
     end
 
     def cursor_store(env)
-      Tempest::CursorStore.new(path: Tempest::CursorStore.default_path(env))
+      Tempest::Commands::Tui.cursor_store(env)
     end
 
-    # Returns a Logger configured from TEMPEST_DEBUG_LOG (path) and
-    # TEMPEST_DEBUG_LOG_LEVEL. When TEMPEST_DEBUG_LOG is unset, the returned
-    # logger writes to IO::NULL at FATAL level so call sites can log
-    # unconditionally without producing files or output.
     def build_debug_logger(env)
-      Tempest::DebugLog.from_env(env)
+      Tempest::Commands::Tui.build_debug_logger(env)
     end
 
-    # Parses TEMPEST_WATCHDOG_THRESHOLD / TEMPEST_WATCHDOG_INTERVAL into the
-    # keyword-hash shape Watchdog expects. Raises ArgumentError on garbage so
-    # a typo in env config fails loudly rather than silently degrading.
     def watchdog_options(env)
-      threshold = env["TEMPEST_WATCHDOG_THRESHOLD"]
-      interval = env["TEMPEST_WATCHDOG_INTERVAL"]
-      {
-        threshold_seconds: threshold ? Integer(threshold) :
-          Tempest::Jetstream::Watchdog::DEFAULT_THRESHOLD_SECONDS,
-        interval_seconds: interval ? Integer(interval) :
-          Tempest::Jetstream::Watchdog::DEFAULT_INTERVAL_SECONDS,
-      }
+      Tempest::Commands::Tui.watchdog_options(env)
     end
 
     def timeline_store(env)
-      Tempest::TimelineStore.new(path: Tempest::TimelineStore.default_path(env))
+      Tempest::Commands::Tui.timeline_store(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")
+      Tempest::Commands::Tui.avatar_cache_dir(env)
     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?
-      ->(url) { system_proc.call(cmd, url) }
+      Tempest::Commands::Tui.opener_for(env: env, system_proc: system_proc)
     end
 
-    VALID_FEED_MODES = %i[home self].freeze
-
     def feed_mode(argv:, env: {})
-      flag = argv.find { |a| a.start_with?("--feed=") }&.split("=", 2)&.last
-      raw = flag || env["TEMPEST_FEED"] || "home"
-
-      mode = raw.to_sym
-      raise ArgumentError, "invalid --feed value: #{raw.inspect} (must be home|self)" \
-        unless VALID_FEED_MODES.include?(mode)
-      mode
+      Tempest::Commands::Tui.feed_mode(argv: argv, env: env)
     end
 
-    # Decides what the Jetstream subscription should look like for a freshly
-    # signed-in session. In :self mode we only watch the user's own DID (the
-    # historical earthquake-style "echo my posts" UX). In :home mode we fetch
-    # the user's follows from AppView and let Subscription decide between
-    # server-side wantedDids filtering and a firehose+client-filter fallback.
-    # When a handle_resolver is provided, follow handles are seeded so the
-    # live feed can render @handle without an extra getProfile roundtrip.
     def build_subscription(mode:, session:, client:, handle_resolver: nil, stdout: nil)
-      case mode
-      when :self
-        Tempest::Jetstream::Plan.new(wanted_dids: [session.did], filter: nil)
-      when :home
-        stdout&.puts "[tempest] fetching follows..."
-        follows = Tempest::Follows.fetch(client, actor: session.did)
-        follows.each { |f| handle_resolver&.seed(f[:did], f[:handle]) }
-        plan = Tempest::Jetstream::Subscription.build(self_did: session.did, follows: follows)
-        if plan.filter
-          stdout&.puts "[tempest] following #{follows.length} accounts (exceeds 10000 cap; using firehose+client-filter)"
-        else
-          stdout&.puts "[tempest] following #{follows.length} accounts"
-        end
-        plan
-      else
-        raise ArgumentError, "unknown feed mode: #{mode.inspect}"
-      end
+      Tempest::Commands::Tui.build_subscription(
+        mode: mode, session: session, client: client,
+        handle_resolver: handle_resolver, stdout: stdout,
+      )
     end
 
     def attach_store(session, store, identifier)
-      session.identifier ||= identifier
-      session.on_change = ->(s) { store.save(s, identifier: s.identifier || identifier) }
+      Tempest::Commands::Tui.attach_store(session, store, identifier)
     end
 
     def help_text
-      <<~HELP
-        Usage: tempest [options]
-
-        Options:
-          -h, --help       Show this help
-          -v, --version    Show version
-          --no-stream      Disable the auto-started Jetstream feed
-          --feed=MODE      Choose what the live feed subscribes to:
-                             home  (default) Your follows + your own posts
-                             self  Only your own posts (legacy echo mode)
-
-        Environment (required only when no cached session is available):
-          TEMPEST_IDENTIFIER     Your handle (e.g. asonas.bsky.social)
-          TEMPEST_APP_PASSWORD   An app password generated in Bluesky settings
-          TEMPEST_PDS_HOST       Override PDS host (default: https://bsky.social)
-          TEMPEST_AUTH_FACTOR_TOKEN
-                                 Pre-supply an email sign-in code (rarely needed; the CLI will
-                                 prompt interactively when Bluesky asks for one)
-          TEMPEST_NO_STREAM      Set to 1 to disable the auto-started Jetstream feed
-          TEMPEST_OPEN_CMD       Command used to open URLs when :open $LX is invoked
-                                 (default: "open"). The URL is passed as the single
-                                 argument after the command.
-          TEMPEST_SESSION_PATH   Override the session cache path (default:
-                                 $XDG_CONFIG_HOME/tempest/session.json or
-                                 ~/.config/tempest/session.json). The cache holds refreshed
-                                 tokens so the email sign-in code is only requested once.
-          TEMPEST_CURSOR_PATH    Override the Jetstream cursor cache path (default:
-                                 $XDG_CONFIG_HOME/tempest/cursor.json). Holds the last-seen
-                                 time_us so a restart can replay missed events.
-          TEMPEST_FEED           "home" (default) or "self"; equivalent to --feed.
-          TEMPEST_DEBUG_LOG      Path to a debug log file. When set, the live-stream
-                                 component writes timestamped state transitions to this
-                                 file (rotated daily). Unset by default — no file is
-                                 created and no output is produced.
-          TEMPEST_DEBUG_LOG_LEVEL
-                                 DEBUG | INFO (default) | WARN. Overrides the log
-                                 verbosity when TEMPEST_DEBUG_LOG is enabled.
-          TEMPEST_WATCHDOG_THRESHOLD
-                                 Seconds without a Jetstream event before the watchdog
-                                 forces a reconnect (default: 90).
-          TEMPEST_WATCHDOG_INTERVAL
-                                 Seconds between watchdog checks (default: 30).
-      HELP
-    end
-
-    # Wraps Reline to fit the input interface expected by REPL::Runner.
-    class RelineReader
-      def initialize
-        require "reline"
-        @reline = Reline
-      end
-
-      def readline(prompt)
-        @reline.readline(prompt, true)
-      end
+      Tempest::Commands::Tui.help_text
     end
   end
 end

data/lib/tempest/commands/base.rb

@@ -0,0 +1,69 @@
+require_relative "../commands"
+require_relative "../session_store"
+require_relative "../config"
+require_relative "../repl/formatter"
+
+module Tempest
+  module Commands
+    module Base
+      module_function
+
+      VALID_FORMATS = %i[line json raw].freeze
+
+      # Loads the cached session and refreshes it. Returns the session on
+      # success. On failure (no cache, refresh rejected) writes a single
+      # human-readable line to stderr and returns nil; callers translate the
+      # nil into exit code 3.
+      def authenticate(env:, stderr:, store: nil)
+        store ||= Tempest::SessionStore.new(path: Tempest::SessionStore.default_path(env))
+        session = store.load(identifier: env["TEMPEST_IDENTIFIER"], pds_host: env["TEMPEST_PDS_HOST"])
+        if session.nil?
+          stderr.puts "error: no cached session — run `tempest tui` once to sign in"
+          return nil
+        end
+        session.on_change = ->(s) { store.save(s, identifier: s.identifier) }
+        begin
+          session.refresh!
+        rescue Tempest::Error => e
+          stderr.puts "error: cached session refresh failed: #{e.message}"
+          return nil
+        end
+        session
+      end
+
+      # Returns one of :line, :json, :raw. Callers may override with --format.
+      def default_format(stdout:, env:)
+        stdout.respond_to?(:tty?) && stdout.tty? ? :line : :json
+      end
+
+      # Parses --format=NAME from argv (destructive: returns [format, argv_without_flag]).
+      # Raises ArgumentError on unknown format names.
+      def take_format(argv, default:)
+        out = []
+        chosen = default
+        argv.each do |arg|
+          if (m = arg.match(/\A--format=(\S+)\z/))
+            sym = m[1].to_sym
+            raise ArgumentError, "invalid --format: #{m[1].inspect}" unless VALID_FORMATS.include?(sym)
+            chosen = sym
+          elsif arg == "--no-color"
+            Tempest::REPL::Formatter.color = false if defined?(Tempest::REPL::Formatter)
+          else
+            out << arg
+          end
+        end
+        [chosen, out]
+      end
+
+      def exit_code_for(error)
+        case error
+        when Tempest::Config::MissingValue then 2
+        when Tempest::AuthenticationError  then 3
+        when Tempest::APIError             then 4
+        when ArgumentError                 then 64
+        else                                    1
+        end
+      end
+    end
+  end
+end

data/lib/tempest/commands/feed.rb

@@ -0,0 +1,137 @@
+require_relative "../commands"
+require_relative "../commands/base"
+require_relative "../post"
+require_relative "../post_view"
+require_relative "../date_filter"
+require_relative "../handle_lookup"
+require_relative "../output/json_writer"
+require_relative "../output/line_writer"
+
+module Tempest
+  module Commands
+    module Feed
+      DEFAULT_LIMIT = 50
+      MAX_LIMIT = 100
+
+      module_function
+
+      def call(argv:, session:, client:, stdout:, stderr:)
+        subcommand, rest = argv.first, argv.drop(1)
+        unless %w[me timeline author].include?(subcommand)
+          stderr.puts "usage: tempest feed me|timeline|author <handle> [opts]"
+          return 64
+        end
+
+        opts, positional = parse(rest, stderr: stderr)
+        return 64 if opts.nil?
+
+        nsid, base_query = endpoint_for(subcommand, session: session, positional: positional, client: client)
+        if nsid.nil?
+          stderr.puts "error: feed author requires a handle or DID"
+          return 64
+        end
+        if opts[:limit] > MAX_LIMIT
+          stderr.puts "error: --limit must be <= #{MAX_LIMIT}"
+          return 64
+        end
+
+        items = []
+        cursor = nil
+        max_pages = 5
+        pages = 0
+        loop do
+          query = base_query.merge("limit" => opts[:limit])
+          query["cursor"] = cursor if cursor
+          response = client.get(nsid, query: query)
+          page_items = Array(response["feed"]).map { |entry| entry["post"] }
+          items.concat(page_items)
+          pages += 1
+          cursor = response["cursor"]
+          break if cursor.nil? || cursor.empty?
+          break if pages >= max_pages
+          break unless opts[:since]
+          oldest = page_items.last && page_items.last.dig("record", "createdAt")
+          break if oldest.nil?
+          break if Time.iso8601(oldest) < opts[:since]
+        end
+        stderr.puts "warning: pagination cap of #{max_pages} pages reached; result truncated" if pages >= max_pages && !cursor.nil? && !cursor.empty?
+
+        items = filter_by_date(items, opts)
+        emit(items, format: opts[:format], stdout: stdout)
+        0
+      end
+
+      def parse(argv, stderr:)
+        opts = { limit: DEFAULT_LIMIT, since: nil, until_at: nil, format: nil }
+        positional = []
+        i = 0
+        while i < argv.length
+          case argv[i]
+          when /\A--limit=(\d+)\z/ then opts[:limit] = Regexp.last_match(1).to_i; i += 1
+          when "--limit"           then opts[:limit] = argv[i + 1].to_i; i += 2
+          when /\A--since=(.+)\z/  then opts[:since] = Tempest::DateFilter.parse(Regexp.last_match(1)); i += 1
+          when "--since"           then opts[:since] = Tempest::DateFilter.parse(argv[i + 1]); i += 2
+          when /\A--until=(.+)\z/  then opts[:until_at] = Tempest::DateFilter.parse(Regexp.last_match(1)); i += 1
+          when "--until"           then opts[:until_at] = Tempest::DateFilter.parse(argv[i + 1]); i += 2
+          when /\A--format=(\S+)\z/
+            sym = Regexp.last_match(1).to_sym
+            unless %i[line json raw].include?(sym)
+              stderr.puts "error: invalid --format: #{Regexp.last_match(1).inspect}"
+              return [nil, nil]
+            end
+            opts[:format] = sym
+            i += 1
+          when "--no-color"
+            Tempest::REPL::Formatter.color = false if defined?(Tempest::REPL::Formatter)
+            i += 1
+          else
+            positional << argv[i]; i += 1
+          end
+        end
+        [opts, positional]
+      rescue ArgumentError => e
+        stderr.puts "error: #{e.message}"
+        [nil, nil]
+      end
+
+      def endpoint_for(subcommand, session:, positional:, client:)
+        case subcommand
+        when "me"
+          ["app.bsky.feed.getAuthorFeed", { "actor" => session.did }]
+        when "timeline"
+          ["app.bsky.feed.getTimeline", {}]
+        when "author"
+          actor = positional.first
+          if actor.nil? || actor.empty?
+            return [nil, nil]
+          end
+          did = Tempest::HandleLookup.resolve(actor, client: client)
+          ["app.bsky.feed.getAuthorFeed", { "actor" => did }]
+        end
+      end
+
+      def filter_by_date(items, opts)
+        return items if opts[:since].nil? && opts[:until_at].nil?
+        items.select do |it|
+          ts = it.dig("record", "createdAt")
+          t = Time.iso8601(ts)
+          (opts[:since].nil? || t >= opts[:since]) && (opts[:until_at].nil? || t < opts[:until_at])
+        end
+      end
+
+      def emit(items, format:, stdout:)
+        format ||= stdout.respond_to?(:tty?) && stdout.tty? ? :line : :json
+        case format
+        when :json
+          views = items.map { |i| Tempest::PostView.from_feed_view(i) }
+          Tempest::Output::JsonWriter.new(stdout).write_posts(views)
+        when :line
+          posts = items.map { |i| Tempest::Post.from_feed_view(i) }
+          Tempest::Output::LineWriter.new(stdout).write_posts(posts)
+        when :raw
+          Tempest::Output::JsonWriter.new(stdout).write_raw({ "feed" => items.map { |i| { "post" => i } } })
+        end
+      end
+    end
+  end
+end