ratproto 0.0.1 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1495c9728dd1630d8f9b62e14187dd7066c16afbbc31161deac5697ee67f5d0
-  data.tar.gz: dbfa95dd48889d5c1a5fd06489ea316aeb2e4ec475cf54fe922bd3f31ca28aa8
+  metadata.gz: a51437de2f57f2f70c839165f4721e3b9fc05ffced806ce652971d7bfe4d5e01
+  data.tar.gz: 6fd9738bde5c0c366a28f36e79c496e18f0686331af7b2f2b8385f60e8827024
 SHA512:
-  metadata.gz: 6119eda973e4279d58dfad1bc1f35aabd42de1dcbc892808b649593fb09a0a063cfdfec239e4af6c83ec203833c108201a36b4d08fbe2631b0e2c1bbf0ce4b49
-  data.tar.gz: e7feeeb64a73705722cf5f4fc457617349c846b310815f6d2bddbb985a171c1c9e1017fb3070a949c7e994eb4cc33f1857b189529e218aeae6303557cc954dfe
+  metadata.gz: 38410b341c5c79fad987cea4e4d6430cda0c63735f58f204497ac8e240525729ab00e01e894512c2d57b55a1da1e913a233da977d084f1f23d909be2f55f1ffb
+  data.tar.gz: 0264f915d70d891447af5e87bc7b88635a1b530fd91e50eebcf9c9902c8037a21c2ab8d2e135ecf9519280dfe2d4ae765819f45c04341c81422709588efe42c7

data/CHANGELOG.md

@@ -1 +1,11 @@
-## [Unreleased]
+## [0.1.1] - 2026-01-03
+
+- fixed rat emoji in the help output :D
+
+## [0.1] - 2026-01-03
+
+- cleaned up / rewritten the code
+
+## [0.0.1] - 2026-01-02
+
+- first working proof of concept

data/README.md

@@ -1,35 +1,175 @@
-# Ratproto
+# RatProto – Ruby ATProto Tool 🐀
 
-TODO: Delete this and the text below, and describe your gem
+RatProto (`rat`) is a small command-line tool in Ruby for accessing the Bluesky API / AT Protocol.
+
+It builds on top of the existing ATProto Ruby gems:
+
+- [`minisky`](https://tangled.org/mackuba.eu/minisky/) — XRPC client
+- [`skyfall`](https://tangled.org/mackuba.eu/skyfall/) — firehose & Jetstream streaming
+- [`didkit`](https://tangled.org/mackuba.eu/didkit/) — DID & handle resolution
+
+> [!NOTE]
+> Part of ATProto Ruby SDK: [ruby.sdk.blue](https://ruby.sdk.blue)
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/ratproto`. To experiment with that code, run `bin/console` for an interactive prompt.
 
 ## Installation
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+To run this tool, you need some reasonably recent version of Ruby installed – it should run on Ruby 2.6 and above, although it's recommended to use a version that still gets maintainance updates, i.e. currently 3.2+.
+
+An older version of Ruby (2.6.x) that should work is shipped with macOS versions 11.0 or later, a recent version of Ruby is also likely to be already installed on most Linux systems, or at least available through the OS's package manager. More installation options can be found on [ruby-lang.org](https://www.ruby-lang.org/en/downloads/).
+
+To install `rat`, run:
+
+```
+[sudo] gem install ratproto
+```
+
+## Features
+
+Currently implemented features/commands:
+
+- resolving DIDs & handles (`rat resolve`)
+- fetching & printing ATProto records (`rat fetch`)
+- streaming firehose / Jetstream events with optional filters (`rat stream`)
+
+
+## Resolving a DID or handle
+
+```
+rat resolve <did>|<handle>
+```
+
+Pass a DID or a handle (@ optional) to look up the given account's identity & print the DID document:
+
+```
+$ rat resolve atproto.com
+
+{
+  "@context": [
+    "https://www.w3.org/ns/did/v1",
+    "https://w3id.org/security/multikey/v1",
+    "https://w3id.org/security/suites/secp256k1-2019/v1"
+  ],
+  "id": "did:plc:ewvi7nxzyoun6zhxrhs64oiz",
+  "alsoKnownAs": [
+    "at://atproto.com"
+  ],
+  "verificationMethod": [
+    {
+      "id": "did:plc:ewvi7nxzyoun6zhxrhs64oiz#atproto",
+      "type": "Multikey",
+      "controller": "did:plc:ewvi7nxzyoun6zhxrhs64oiz",
+      "publicKeyMultibase": "zQ3shunBKsXixLxKtC5qeSG9E4J5RkGN57im31pcTzbNQnm5w"
+    }
+  ],
+  "service": [
+    {
+      "id": "#atproto_pds",
+      "type": "AtprotoPersonalDataServer",
+      "serviceEndpoint": "https://enoki.us-east.host.bsky.network"
+    }
+  ]
+}
+```
 
-Install the gem and add to the application's Gemfile by executing:
 
-```bash
-bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+## Fetching a record
+
+```
+rat fetch at://<did>/<collection>/<rkey>
 ```
 
-If bundler is not being used to manage dependencies, install the gem by executing:
+Pass an at:// URI as the argument to fetch a single record from the user’s PDS:
+
+```
+% rat fetch at://did:plc:ragtjsm2j2vknwkz3zp4oxrd/app.bsky.feed.post/3lxxmboqmf22j
 
-```bash
-gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+{
+  "text": "a gatinha gorda",
+  "$type": "app.bsky.feed.post",
+  "embed": {
+    "$type": "app.bsky.embed.images",
+    "images": [
+      {
+        "alt": "Kit lying on the ground under the chair ",
+        "image": {
+          "$type": "blob",
+          "ref": {
+            "$link": "bafkreiebzsetrrvymvq6dvwma77zqprnv73ovgeqilanzi453dm6xart4q"
+          },
+          "mimeType": "image/jpeg",
+          "size": 963750
+        },
+        "aspectRatio": {
+          "width": 2000,
+          "height": 1500
+        }
+      }
+    ]
+  },
+  "langs": [
+    "en"
+  ],
+  "createdAt": "2025-09-03T21:48:05.910Z"
+}
 ```
 
-## Usage
+## Streaming commit events
+
+```
+rat stream <firehose-host> [-j] [-r cursor] [-c collections] [-d dids]
+```
 
-TODO: Write usage instructions here
+Rat can connect to either a relay/PDS firehose:
+
+```
+rat stream bsky.network
+```
+
+or a Jetstream service (use `-j`):
+
+```
+rat stream -j jetstream2.us-east.bsky.network
+```
+
+You can also pass a cursor to connect with using `-r` / `--cursor` (tip: pass `-r0` to rewind as far back as the buffer allows).
+
+Once connected, you’ll see output like:
+
+```
+[2025-01-02T12:34:56+01:00] did:plc:xwnehmdpjluz2kv3oh2mfi47 :create app.bsky.feed.post 3mbjs5rgtin2z {"text":"hi", ...}
+[2025-01-02T12:34:57+01:00] did:plc:3mfkuhmjxd2wvz2e7nhl4poi :delete app.bsky.graph.follow 3mbjs5rghri23
+```
+
+Press Ctrl-C to disconnect.
+
+You can also apply the filtering options below (for Jetstream, these are passed to the server to apply filtering server-side via `wantedCollections` / `wantedDids` parameters):
+
+
+### Filtering by DID
+
+To print only events from given DID(s):
+
+```
+rat stream bsky.network -d did:plc:abcd1234,did:plc:xyz9999,...
+```
+
+You can either pass a comma-separated list as one parameter, or repeat `-d val` more than once.
+
+
+### Filtering by collection
+
+To print only records from given collection(s):
+
+```
+rat stream bsky.network -c app.bsky.feed.post -c app.bsky.actor.profile
+```
 
-## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+## Credits
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+Copyright © 2026 Kuba Suder ([@mackuba.eu](https://bsky.app/profile/did:plc:oio4hkxaop4ao4wz2pp3f4cr)).
 
-## Contributing
+The code is available under the terms of the [zlib license](https://choosealicense.com/licenses/zlib/) (permissive, similar to MIT).
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/ratproto.
+Bug reports and pull requests are welcome 😎

data/exe/rat

@@ -1,59 +1,39 @@
 #!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# rat – Ruby ATProto Tool
-#
-# Simple CLI for Bluesky AT Protocol using:
-# - Minisky  (XRPC client)
-# - Skyfall  (firehose / Jetstream streaming)
-# - DIDKit   (DID / handle resolution)
-#
-# Usage:
-#   rat fetch at://<did-or-handle>/<collection-nsid>/<rkey>
-#   rat stream <relay.host> [-j|--jetstream] [-r|--cursor CURSOR] \
-#                [-d|--did DID,...] [-c|--collection NSID,...]
-#   rat resolve <did-or-handle>
-#   rat help | --help
-#   rat version | --version
 
-require 'optparse'
-require 'json'
-require 'time'
-require 'uri'
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
 
+require 'didkit'
+require 'json'
 require 'minisky'
+require 'optparse'
 require 'skyfall'
-require 'didkit'   # defines DIDKit::DID and top-level DID alias
+require 'time'
+require 'uri'
 
-VERSION = '0.0.1'
+require 'ratproto/version'
 
-DID_REGEX       = /\Adid:[a-z0-9]+:[a-zA-Z0-9.\-_:]+\z/
-DOMAIN_REGEX    = /\A[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)+\z/i
-HOST_PORT_REGEX = /\A#{DOMAIN_REGEX.source}(?::\d+)?\z/i
+DID_REGEXP = /\Adid:[a-z]+:[a-zA-Z0-9.\-_]+\z/
+NSID_REGEXP = /\A[a-z0-9]+(\.[a-z0-9]+)+\z/
 
-def global_help
-  <<~HELP
-    rat #{VERSION}
+def print_help
+  puts <<~HELP
+    rat #{RatProto::VERSION} 🐀
 
     Usage:
-      rat fetch at://<did-or-handle>/<collection-nsid>/<rkey>
-      rat stream <relay.host> [options]
-      rat resolve <did-or-handle>
-      rat help | --help
-      rat version | --version
+      rat fetch at://uri
+      rat stream <firehose-host> [options]
+      rat resolve <did>|<handle>
 
     Commands:
       fetch     Fetch a single record given its at:// URI
-      stream    Stream commit events from a relay / PDS firehose
-      resolve   Resolve a DID or @handle using DIDKit
+      stream    Stream events from a relay / PDS firehose
+      resolve   Resolve a DID or @handle
       help      Show this help
       version   Show version
 
     Stream options:
-      -j, --jetstream                  Use Skyfall::Jetstream (JSON)
-                                       (uses Jetstream wanted_dids / wanted_collections
-                                       when -d/-c are provided)
-      -r, --cursor CURSOR              Start from cursor (seq or time_us)
+      -j, --jetstream                  Use a Jetstream source instead of a CBOR firehose
+      -r, --cursor CURSOR              Start from a given cursor
       -d, --did DID[,DID...]           Filter only events from given DID(s)
                                        (can be passed multiple times)
       -c, --collection NSID[,NSID...]  Filter only events of given collection(s)
@@ -61,313 +41,199 @@ def global_help
   HELP
 end
 
-def abort_with_help(message = nil)
-  warn "Error: #{message}" if message
-  warn
-  warn global_help
+def abort_with_error(message)
+  puts message
   exit 1
 end
 
-def valid_did?(s)
-  DID_REGEX.match?(s)
-end
-
-def valid_handle?(s)
-  DOMAIN_REGEX.match?(s)
-end
-
-def valid_nsid?(s)
-  # NSIDs look like domain names (reverse DNS), so reuse DOMAIN_REGEX
-  DOMAIN_REGEX.match?(s)
-end
-
-def validate_handle!(s, context: 'handle')
-  unless valid_handle?(s)
-    abort_with_help("#{s.inspect} doesn't look like a valid #{context}")
+def validate_did(did)
+  unless did =~ DID_REGEXP
+    abort_with_error "Error: #{did.inspect} is not a valid DID"
   end
-  s
 end
 
-def validate_did!(s)
-  unless valid_did?(s)
-    abort_with_help("#{s.inspect} doesn't look like a valid DID")
+def validate_nsid(collection)
+  unless collection =~ NSID_REGEXP
+    abort_with_error "Error: #{collection.inspect} is not a valid collection NSID"
   end
-  s
 end
 
-def validate_nsid!(nsid)
-  unless valid_nsid?(nsid)
-    abort_with_help("#{nsid.inspect} doesn't look like a valid collection NSID")
-  end
-  nsid
-end
-
-def parse_at_uri(str)
-  unless str.start_with?('at://')
-    abort_with_help("not an at:// URI: #{str.inspect}")
+def parse_at_uri(uri)
+  unless uri.start_with?('at://')
+    abort_with_error "Error: not an at:// URI: #{uri.inspect}"
   end
 
-  m = /\Aat:\/\/([^\/]+)\/([^\/]+)\/([^\/]+)\z/.match(str)
-  unless m
-    abort_with_help("invalid at:// URI: expected at://<repo>/<collection>/<rkey>")
+  unless uri =~ /\Aat:\/\/([^\/]+)\/([^\/]+)\/([^\/]+)\z/
+    abort_with_error "Error: invalid at:// URI: #{uri.inspect}"
   end
 
-  repo, collection, rkey = m.captures
-  [repo, collection, rkey]
+  [$1, $2, $3]
 end
 
-def resolve_repo_to_did_and_pds(repo_str)
-  if repo_str.start_with?('did:')
-    validate_did!(repo_str)
-    did_obj = DID.new(repo_str)
-  else
-    handle = repo_str.sub(/\A@/, '')
-    validate_handle!(handle, context: 'handle in at:// URI')
-    did_obj = DID.resolve_handle(handle)
-  end
+def run_fetch(args)
+  uri = args.shift
 
-  doc = did_obj.document
-  pds_host = doc.pds_host
-  unless pds_host && !pds_host.empty?
-    abort_with_help("DID document for #{did_obj} does not contain a pds_host")
+  if uri.nil?
+    abort_with_error "Usage: #{$PROGRAM_NAME} fetch <at://uri>"
   end
 
-  [did_obj.to_s, pds_host]
-rescue StandardError => e
-  warn "Error resolving repo #{repo_str.inspect}: #{e.class}: #{e.message}"
-  exit 1
-end
-
-def do_fetch(argv)
-  uri = argv.shift or abort_with_help("fetch requires an at:// URI")
-  unless argv.empty?
-    abort_with_help("unexpected extra arguments for fetch: #{argv.join(' ')}")
+  if !args.empty?
+    abort_with_error "Error: Unexpected arguments for fetch: #{args.join(' ')}"
   end
 
-  repo_str, collection, rkey = parse_at_uri(uri)
-
-  # basic validation of collection (NSID-ish)
-  validate_nsid!(collection)
-
-  did, pds_host = resolve_repo_to_did_and_pds(repo_str)
-
-  client = Minisky.new(pds_host, nil)
-  params = { repo: did, collection: collection, rkey: rkey }
+  repo, collection, rkey = parse_at_uri(uri)
 
   begin
-    res = client.get_request('com.atproto.repo.getRecord', params)
+    pds = DID.new(repo).document.pds_host
+    sky = Minisky.new(pds, nil)
+
+    response = sky.get_request('com.atproto.repo.getRecord', {
+      repo: repo, collection: collection, rkey: rkey
+    })
   rescue StandardError => e
-    warn "Error calling com.atproto.repo.getRecord: #{e.class}: #{e.message}"
-    exit 1
+    abort_with_error "Error loading record: #{e.class}: #{e.message}"
   end
 
-  value = res['value']
-  if value.nil?
-    warn "Warning: response did not contain a 'value' field"
-    puts JSON.pretty_generate(res)
-  else
-    puts JSON.pretty_generate(value)
-  end
+  puts JSON.pretty_generate(response['value'])
 end
 
-def do_resolve(argv)
-  target = argv.shift or abort_with_help("resolve requires a DID or handle")
-  unless argv.empty?
-    abort_with_help("unexpected extra arguments for resolve: #{argv.join(' ')}")
+def run_resolve(args)
+  target = args.shift
+
+  if target.nil?
+    abort_with_error "Usage: #{$PROGRAM_NAME} resolve <did>|<handle>"
   end
 
-  if target.start_with?('did:')
-    validate_did!(target)
-    begin
-      did_obj = DID.new(target)
-      doc = did_obj.document
-      json = doc.respond_to?(:json) ? doc.json : doc
-      puts did_obj.to_s
-      puts JSON.pretty_generate(json)
-    rescue StandardError => e
-      warn "Error resolving DID #{target.inspect}: #{e.class}: #{e.message}"
-      exit 1
-    end
-  else
-    handle = target.sub(/\A@/, '')
-    validate_handle!(handle)
-    begin
-      did_obj = DID.resolve_handle(handle)
-      doc = did_obj.document
-      json = doc.respond_to?(:json) ? doc.json : doc
-      puts did_obj.to_s
-      puts JSON.pretty_generate(json)
-    rescue StandardError => e
-      warn "Error resolving handle #{target.inspect}: #{e.class}: #{e.message}"
-      exit 1
-    end
+  if !args.empty?
+    abort_with_error "Error: Unexpected arguments for resolve: #{args.join(' ')}"
   end
-end
 
-def validate_relay_host!(host)
-  # Accept:
-  #   - bare hostname or hostname:port
-  #   - ws://host[:port]
-  #   - wss://host[:port]
-  if host =~ /\Aws:\/\//i || host =~ /\Awss:\/\//i
-    uri = URI(host)
-    if uri.path && uri.path != '' && uri.path != '/'
-      abort_with_help("relay URL must not contain a path: #{host.inspect}")
-    end
-    unless uri.host && DOMAIN_REGEX.match?(uri.host)
-      abort_with_help("invalid relay hostname in URL: #{host.inspect}")
-    end
-  else
-    unless HOST_PORT_REGEX.match?(host)
-      abort_with_help("invalid relay hostname: #{host.inspect}")
-    end
+  did = DID.resolve_handle(target)
+
+  if did.nil?
+    abort_with_error "Couldn't resolve #{target}"
   end
 
-  host
-rescue URI::InvalidURIError
-  abort_with_help("invalid relay URL: #{host.inspect}")
+  puts JSON.pretty_generate(did.document.json)
+rescue StandardError => e
+  abort_with_error "Error resolving #{target.inspect}: #{e.class}: #{e.message}"
 end
 
-def parse_stream_options(argv)
-  options = {
-    use_jetstream: false,
-    cursor:        nil,
-    dids:          [],
-    collections:   []
-  }
+def parse_stream_options(args)
+  options = {}
 
   parser = OptionParser.new do |opts|
-    opts.banner = "Usage: rat stream <relay.host> [options]"
+    opts.banner = "Usage: #{$PROGRAM_NAME} stream <relay.host> [options]"
 
-    opts.on('-j', '--jetstream', 'Use Skyfall::Jetstream (JSON)') do
-      options[:use_jetstream] = true
+    opts.on('-j', '--jetstream', 'Use a Jetstream source') do
+      options[:jetstream] = true
     end
 
-    opts.on('-rCURSOR', '--cursor=CURSOR', 'Start from cursor (seq or time_us)') do |cursor|
+    opts.on('-rCURSOR', '--cursor=CURSOR', 'Start from a given cursor') do |cursor|
       options[:cursor] = cursor
     end
 
-    opts.on('-dLIST', '--did=LIST',
-            'Filter only events from DID(s) (comma-separated or repeated)') do |list|
+    opts.on('-dLIST', '--did=LIST', 'Filter only events from given DID(s) (comma-separated or repeated)') do |list|
       items = list.split(',').map(&:strip).reject(&:empty?)
+
       if items.empty?
-        abort_with_help("empty argument to -d/--did")
+        abort_with_error "Error: empty argument to -d/--did"
       end
-      options[:dids].concat(items)
+
+      options[:dids] ||= []
+      options[:dids] += items
     end
 
-    opts.on('-cLIST', '--collection=LIST',
-            'Filter only events of given collection NSID(s)') do |list|
+    opts.on('-cLIST', '--collection=LIST', 'Filter only events of given collections') do |list|
       items = list.split(',').map(&:strip).reject(&:empty?)
+
       if items.empty?
-        abort_with_help("empty argument to -c/--collection")
+        abort_with_error "Error: empty argument to -c/--collection"
       end
-      options[:collections].concat(items)
+
+      options[:collections] ||= []
+      options[:collections] += items
     end
 
     opts.on('-h', '--help', 'Show stream-specific help') do
       puts opts
-      exit 0
+      exit
     end
   end
 
   remaining = []
+
   begin
-    parser.order!(argv) { |nonopt| remaining << nonopt }
+    parser.order!(args) { |other| remaining << other }
   rescue OptionParser::InvalidOption, OptionParser::MissingArgument => e
-    warn "Error: #{e.message}"
-    warn parser
+    puts "Error: #{e.message}"
+    puts parser
     exit 1
   end
 
   [options, remaining]
 end
 
-def do_stream(argv)
-  options, remaining = parse_stream_options(argv)
+def run_stream(args)
+  options, arguments = parse_stream_options(args)
 
-  host = remaining.shift or abort_with_help("stream requires a relay hostname")
-  validate_relay_host!(host)
+  service = arguments.shift
 
-  unless remaining.empty?
-    abort_with_help("unexpected extra arguments for stream: #{remaining.join(' ')}")
+  if service.nil?
+    abort_with_error "Usage: #{$PROGRAM_NAME} stream <firehose-host> [options]"
+  end
+
+  if !arguments.empty?
+    abort_with_error "Error: Unexpected arguments for stream: #{arguments.join(' ')}"
   end
 
-  # validate cursor (if given)
   if options[:cursor] && options[:cursor] !~ /\A\d+\z/
-    abort_with_help("cursor must be a decimal integer, got #{options[:cursor].inspect}")
+    abort_with_error "Error: cursor must be a decimal integer, got: #{options[:cursor].inspect}"
   end
 
-  # validate DIDs
-  options[:dids].each do |did|
-    validate_did!(did)
+  if options[:dids]
+    options[:dids].each { |did| validate_did(did) }
   end
 
-  # validate collections
-  options[:collections].each do |nsid|
-    validate_nsid!(nsid)
+  if options[:collections]
+    options[:collections].each { |collection| validate_nsid(collection) }
   end
 
-  # Build Skyfall client
-  if options[:use_jetstream]
+  if options[:jetstream]
     jet_opts = {}
     jet_opts[:cursor] = options[:cursor].to_i if options[:cursor]
 
-    # Pass filters through to Jetstream server-side
-    jet_opts[:wanted_dids] = options[:dids] unless options[:dids].empty?
-    jet_opts[:wanted_collections] = options[:collections] unless options[:collections].empty?
+    # pass DID/collection filters to Jetstream to filter events server-side
+    jet_opts[:wanted_dids] = options[:dids] if options[:dids]
+    jet_opts[:wanted_collections] = options[:collections] if options[:collections]
 
-    sky = Skyfall::Jetstream.new(host, jet_opts)
+    sky = Skyfall::Jetstream.new(service, jet_opts)
   else
     cursor = options[:cursor]&.to_i
-    sky = Skyfall::Firehose.new(host, :subscribe_repos, cursor)
+    sky = Skyfall::Firehose.new(service, :subscribe_repos, cursor)
   end
 
-  # Lifecycle logging
   sky.on_connecting { |url| puts "Connecting to #{url}..." }
   sky.on_connect    { puts "Connected" }
   sky.on_disconnect { puts "Disconnected" }
   sky.on_reconnect  { puts "Connection lost, trying to reconnect..." }
-  sky.on_timeout    { puts "Connection stalled, triggering a reconnect..." } if sky.respond_to?(:on_timeout)
-  sky.on_error      { |e| warn "ERROR: #{e}" }
+  sky.on_timeout    { puts "Connection stalled, triggering a reconnect..." }
+  sky.on_error      { |e| puts "ERROR: #{e}" }
 
-  # Message handler
   sky.on_message do |msg|
     next unless msg.type == :commit
+    next if options[:dids] && !options[:dids].include?(msg.repo)
 
-    did = if msg.respond_to?(:repo) && msg.repo
-            msg.repo
-          elsif msg.respond_to?(:did)
-            msg.did
-          else
-            nil
-          end
-
-    if !options[:dids].empty? && (!did || !options[:dids].include?(did))
-      next
-    end
-
-    ts = msg.time ? msg.time.getlocal.iso8601 : 'unknown-time'
+    time = msg.time.getlocal.iso8601
 
     msg.operations.each do |op|
-      # collection filter (still applied client-side, in case server doesn't)
-      if !options[:collections].empty? &&
-         !options[:collections].include?(op.collection)
-        next
-      end
-
-      line = "[#{ts}] #{did || '-'} :#{op.action} #{op.collection} #{op.rkey}"
+      next if options[:collections] && !options[:collections].include?(op.collection)
 
-      if op.respond_to?(:raw_record) && op.raw_record && !op.raw_record.empty?
-        # compact JSON on one line
-        line << " " << JSON.generate(op.raw_record)
-      end
-
-      puts line
+      json = op.raw_record && JSON.generate(op.raw_record)
+      puts "[#{time}] #{msg.repo} #{op.action.inspect} #{op.collection} #{op.rkey} #{json}"
     end
   end
 
-  # Clean disconnect on Ctrl+C
   trap('SIGINT') do
     puts 'Disconnecting...'
     sky.disconnect
@@ -376,28 +242,24 @@ def do_stream(argv)
   sky.connect
 end
 
-# ---- main dispatcher ----
-
 if ARGV.empty?
-  puts global_help
-  exit 0
+  print_help
+  exit
 end
 
 cmd = ARGV.shift
 
 case cmd
 when 'help', '--help', '-h'
-  puts global_help
-  exit 0
+  print_help
 when 'version', '--version'
-  puts VERSION
-  exit 0
+  puts "RatProto #{RatProto::VERSION} 🐀"
 when 'fetch'
-  do_fetch(ARGV)
+  run_fetch(ARGV)
 when 'resolve'
-  do_resolve(ARGV)
+  run_resolve(ARGV)
 when 'stream'
-  do_stream(ARGV)
+  run_stream(ARGV)
 else
-  abort_with_help("unknown command: #{cmd}")
+  abort_with_error "Error: unknown command: #{cmd}"
 end

data/lib/ratproto/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RatProto
-  VERSION = "0.0.1"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ratproto
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.1
 platform: ruby
 authors:
 - Kuba Suder