rocksky 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e48d42415ab7937416c2e008a6b637b4e2aef4474f60aae824cf1e089a3814f3
+  data.tar.gz: eefc4a0023800e5f0d03a4fd41837589b9fc02bd49e4244bcd7a260bc88895a6
+SHA512:
+  metadata.gz: 11773d9ea99df5d975d9c81636a3cd0058ea69a4a2cfcb9aa7b2579fbdcd0350f7b7c80ef34e4dadadd5b55232fd4d458773a319449d034118e7f436fafab71b
+  data.tar.gz: 94cf1dba5ddb40fb27781044b27bf3cbe1e3cea3720e522541f4db5ab85d1431b1992af384db625128f13c3971a7a543f22f2747e0e011b936d4de3092219a57

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## 0.1.0
+
+- Initial release. Coverage for all `app.rocksky.*` XRPC endpoints across the
+  actor, album, apikey, artist, charts, feed, graph, like, mirror, player,
+  playlist, scrobble, shout, song, spotify, and stats namespaces.
+- `rocksky-console` and `bin/console` IRB entrypoints.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Tsiry Sandratraina <tsiry.sndr@rocksky.app>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,224 @@
+# rocksky (Ruby)
+
+Idiomatic Ruby client for the [Rocksky](https://rocksky.app) XRPC API.
+
+```ruby
+client = Rocksky.new(token: ENV["ROCKSKY_TOKEN"])
+
+client.actor.get_profile(did: "tsiry-sandratraina.com")
+client.charts.get_top_artists(limit: 10, start_date: "2025-01-01")
+client.scrobble.create_scrobble(title: "In Bloom", artist: "Nirvana")
+```
+
+Every XRPC NSID maps to a method on a resource object. `app.rocksky.actor.getProfile`
+becomes `client.actor.get_profile(...)`. `app.rocksky.scrobble.createScrobble`
+becomes `client.scrobble.create_scrobble(...)`. No magic — just kwargs in,
+parsed JSON out.
+
+## Installation
+
+Add it to your `Gemfile`:
+
+```ruby
+gem "rocksky"
+```
+
+Or install directly:
+
+```bash
+gem install rocksky
+```
+
+Requires Ruby 3.0+. The SDK depends only on Ruby's stdlib (`net/http`, `json`, `uri`).
+
+## Quick start
+
+```ruby
+require "rocksky"
+
+# Reads ROCKSKY_BASE_URL and ROCKSKY_TOKEN from the env when omitted.
+client = Rocksky.new
+
+profile = client.actor.get_profile(did: "tsiry-sandratraina.com")
+puts profile["displayName"]
+```
+
+For authenticated calls, pass a Bluesky-issued Bearer token (see
+[lexicons documentation](https://github.com/rocksky/rocksky/blob/main/LEXICONS.md)):
+
+```ruby
+client = Rocksky.new(token: "eyJ...")
+client.scrobble.create_scrobble(title: "In Bloom", artist: "Nirvana")
+```
+
+`with_token` derives a new client without mutating the original — useful in
+web apps that share one base client across users:
+
+```ruby
+base = Rocksky.new
+def for_user(base, token) = base.with_token(token)
+```
+
+## Resources
+
+| Resource | Methods |
+|----------|---------|
+| `client.actor`    | `get_profile`, `get_actor_albums/artists/songs/scrobbles/playlists/loved_songs`, `get_actor_neighbours`, `get_actor_compatibility` |
+| `client.album`    | `get_album`, `get_albums`, `get_album_tracks` |
+| `client.apikey`   | `get_apikeys`, `create_apikey`, `update_apikey`, `remove_apikey` *(auth)* |
+| `client.artist`   | `get_artist`, `get_artists`, `get_artist_albums/tracks/listeners/recent_listeners` |
+| `client.charts`   | `get_scrobbles_chart`, `get_top_artists`, `get_top_tracks` |
+| `client.feed`     | `search`, `get_feed_generators/generator/feed`, `get_stories`, `get_recommendations`, `get_artist_recommendations`, `get_album_recommendations` |
+| `client.graph`    | `follow_account`, `unfollow_account`, `get_followers`, `get_follows`, `get_known_followers` *(auth)* |
+| `client.like`     | `like_song`, `dislike_song`, `like_shout`, `dislike_shout` *(auth)* |
+| `client.mirror`   | `get_mirror_sources`, `put_mirror_source` *(auth)* |
+| `client.player`   | `play`, `pause`, `next`, `previous`, `seek`, `play_file`, `play_directory`, `add_items_to_queue`, `get_currently_playing`, `get_playback_queue` |
+| `client.playlist` | `get_playlist`, `get_playlists`, `create_playlist`, `remove_playlist`, `start_playlist`, `insert_files`, `insert_directory` |
+| `client.scrobble` | `create_scrobble`, `get_scrobble`, `get_scrobbles` |
+| `client.shout`    | `create_shout`, `reply_shout`, `remove_shout`, `report_shout`, `get_*_shouts`, `get_shout_replies` |
+| `client.song`     | `get_song`, `get_songs`, `get_song_recent_listeners`, `match_song`, `create_song` |
+| `client.spotify`  | `play`, `pause`, `next`, `previous`, `seek`, `get_currently_playing` *(auth)* |
+| `client.stats`    | `get_stats`, `get_wrapped` |
+
+For anything not covered, drop down to the raw transport:
+
+```ruby
+client.query("app.rocksky.actor.getProfile", did: "did:plc:7vdlgi2bflelz7mmuxoqjfcr")
+client.procedure("app.rocksky.like.likeSong", body: { uri: "at://..." })
+```
+
+## Conventions
+
+- **Keyword args** for every parameter. Ruby `snake_case` names map to the
+  lexicon's `camelCase` (e.g. `start_date:` → `startDate`).
+- **`nil` is dropped.** Pass `nil` for any optional param and it won't be sent.
+- **Arrays are CSV-joined.** Lexicon list params like `names:` accept Ruby arrays:
+  `client.artist.get_artists(names: %w[Nirvana Pixies])`.
+- **Hashes in, Hashes out.** Responses come back as plain `Hash` (string keys) —
+  no DSL, no model classes. Match the shape of the lexicon JSON 1:1.
+
+## Error handling
+
+Every non-2xx response raises a subclass of `Rocksky::Error`:
+
+```ruby
+begin
+  client.song.get_song(uri: "at://does-not-exist")
+rescue Rocksky::NotFound => e
+  puts "missing: #{e.message} (status=#{e.status}, nsid=#{e.nsid})"
+rescue Rocksky::RateLimited
+  sleep 5; retry
+rescue Rocksky::Error => e
+  warn "rocksky failure: #{e.class}: #{e.message}"
+end
+```
+
+| Class | Status |
+|-------|--------|
+| `Rocksky::BadRequest`     | 400 |
+| `Rocksky::Unauthorized`   | 401 |
+| `Rocksky::Forbidden`      | 403 |
+| `Rocksky::NotFound`       | 404 |
+| `Rocksky::RateLimited`    | 429 |
+| `Rocksky::ServerError`    | 5xx |
+| `Rocksky::HTTPError`      | any other non-2xx |
+| `Rocksky::TransportError` | DNS/TCP/timeouts |
+
+## IRB console
+
+The gem ships with a `rocksky-console` executable: an IRB session
+pre-loaded with a `client` bound to your environment.
+
+```bash
+$ gem install rocksky
+$ ROCKSKY_TOKEN=eyJ... rocksky-console
+Rocksky 0.1.0 — interactive console
+  base_url : https://api.rocksky.app
+  token    : present (set via ROCKSKY_TOKEN)
+
+A client is bound to `client`. Try:
+  client.actor.get_profile(did: "did:plc:7vdlgi2bflelz7mmuxoqjfcr")
+  client.charts.get_top_artists(limit: 10)
+
+irb> client.actor.get_profile(did: "did:plc:7vdlgi2bflelz7mmuxoqjfcr")
+=> {"did"=>"did:plc:...", "handle"=>"tsiry-sandratraina.com", ...}
+```
+
+### From a checkout (development)
+
+If you've cloned the repo, use `bin/console` instead. It loads the local
+source tree, so edits to `lib/` are picked up on the next `reload!`-style
+restart:
+
+```bash
+$ cd sdk/ruby
+$ bundle install
+$ bin/console
+```
+
+### Ad-hoc IRB (no script)
+
+You can always launch IRB yourself:
+
+```bash
+$ irb -rrocksky
+irb> client = Rocksky.new(token: ENV["ROCKSKY_TOKEN"])
+irb> client.charts.get_top_tracks(limit: 5)
+```
+
+### Useful IRB recipes
+
+```ruby
+# Pretty-print responses
+require "json"
+puts JSON.pretty_generate(client.actor.get_profile(did: "did:plc:7vdlgi2bflelz7mmuxoqjfcr"))
+
+# Inspect what the SDK is about to send
+client = Rocksky.new(headers: { "X-Debug" => "1" })
+
+# Try things against staging without touching prod
+client = Rocksky.new(base_url: "https://api.staging.rocksky.app")
+
+# Tighter timeouts in a script
+client = Rocksky.new(open_timeout: 2, read_timeout: 5)
+```
+
+## Configuration
+
+| Option         | Default                       | Env var               |
+|----------------|-------------------------------|-----------------------|
+| `base_url`     | `https://api.rocksky.app`     | `ROCKSKY_BASE_URL`    |
+| `token`        | `nil`                         | `ROCKSKY_TOKEN`       |
+| `headers`      | `{}`                          | —                     |
+| `user_agent`   | `rocksky-ruby/<version>`      | —                     |
+| `open_timeout` | `10` seconds                  | —                     |
+| `read_timeout` | `30` seconds                  | —                     |
+
+## Examples
+
+The `examples/` directory contains runnable scripts:
+
+```bash
+bundle exec ruby examples/01_profile.rb tsiry-sandratraina.com
+bundle exec ruby examples/03_charts.rb
+ROCKSKY_TOKEN=... bundle exec ruby examples/02_scrobble.rb
+```
+
+See [examples/README.md](examples/README.md) for the full list.
+
+## Development
+
+```bash
+$ bundle install
+$ bundle exec rake test    # run the suite
+$ bin/console              # IRB with the local source tree
+```
+
+Tests use Minitest + WebMock — no live network access needed. Add a new
+resource by dropping a file in `lib/rocksky/resources/`, wiring it into
+`lib/rocksky.rb` and `lib/rocksky/client.rb`, and adding tests under
+`test/resources/`.
+
+## License
+
+[MIT](LICENSE) © Tsiry Sandratraina.

data/exe/rocksky-console

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+# rocksky-console — IRB session pre-loaded with a `client` bound to your env.
+#
+#   $ ROCKSKY_TOKEN=... rocksky-console
+#   irb> client.actor.get_profile(did: "alice.bsky.social")
+#
+# Without ROCKSKY_TOKEN, the client is unauthenticated (read-only endpoints
+# still work).
+
+require "irb"
+require "rocksky"
+
+client = Rocksky.new
+
+puts <<~BANNER
+  Rocksky #{Rocksky::VERSION} — interactive console
+    base_url : #{client.base_url}
+    token    : #{client.token ? "present (set via ROCKSKY_TOKEN)" : "none — set ROCKSKY_TOKEN for auth"}
+
+  A client is bound to `client`. Try:
+    client.actor.get_profile(did: "alice.bsky.social")
+    client.charts.get_top_artists(limit: 10)
+
+BANNER
+
+IRB.setup(nil)
+IRB.conf[:USE_MULTILINE] = false if IRB.conf.key?(:USE_MULTILINE)
+
+workspace = IRB::WorkSpace.new(binding)
+workspace.main.instance_variable_set(:@client, client)
+workspace.main.define_singleton_method(:client) { @client }
+
+IRB::Irb.new(workspace).run(IRB.conf)

data/lib/rocksky/client.rb

@@ -0,0 +1,84 @@
+module Rocksky
+  # Top-level client for the Rocksky XRPC API.
+  #
+  #   client = Rocksky.new(token: ENV["ROCKSKY_TOKEN"])
+  #   client.actor.get_profile(did: "alice.bsky.social")
+  #
+  # Resources are lazily instantiated and memoised: `client.actor`, `client.album`,
+  # `client.artist`, `client.scrobble`, etc.
+  class Client
+    DEFAULT_BASE_URL = "https://api.rocksky.app".freeze
+
+    attr_reader :base_url, :token, :headers, :user_agent,
+                :open_timeout, :read_timeout
+
+    def initialize(
+      base_url: nil,
+      token: nil,
+      headers: {},
+      user_agent: "rocksky-ruby/#{Rocksky::VERSION}",
+      open_timeout: HTTP::DEFAULT_OPEN_TIMEOUT,
+      read_timeout: HTTP::DEFAULT_READ_TIMEOUT
+    )
+      @base_url = normalize_base_url(base_url || ENV["ROCKSKY_BASE_URL"] || DEFAULT_BASE_URL)
+      @token = token || ENV["ROCKSKY_TOKEN"]
+      @headers = headers.dup
+      @user_agent = user_agent
+      @open_timeout = open_timeout
+      @read_timeout = read_timeout
+      @http = HTTP.new(self)
+    end
+
+    # Return a derived client that uses the given token (everything else copied).
+    # Handy for sharing one client across users in a request-scoped server.
+    def with_token(new_token)
+      self.class.new(
+        base_url: base_url,
+        token: new_token,
+        headers: headers,
+        user_agent: user_agent,
+        open_timeout: open_timeout,
+        read_timeout: read_timeout
+      )
+    end
+
+    # ---- Raw XRPC access ---------------------------------------------------
+
+    def query(nsid, **params)
+      @http.query(nsid, params)
+    end
+
+    def procedure(nsid, params: {}, body: nil)
+      @http.procedure(nsid, params, body)
+    end
+
+    # ---- Resource accessors ------------------------------------------------
+
+    def actor;    @actor    ||= Resources::Actor.new(@http); end
+    def album;    @album    ||= Resources::Album.new(@http); end
+    def apikey;   @apikey   ||= Resources::Apikey.new(@http); end
+    def artist;   @artist   ||= Resources::Artist.new(@http); end
+    def charts;   @charts   ||= Resources::Charts.new(@http); end
+    def feed;     @feed     ||= Resources::Feed.new(@http); end
+    def graph;    @graph    ||= Resources::Graph.new(@http); end
+    def like;     @like     ||= Resources::Like.new(@http); end
+    def mirror;   @mirror   ||= Resources::Mirror.new(@http); end
+    def player;   @player   ||= Resources::Player.new(@http); end
+    def playlist; @playlist ||= Resources::Playlist.new(@http); end
+    def scrobble; @scrobble ||= Resources::Scrobble.new(@http); end
+    def shout;    @shout    ||= Resources::Shout.new(@http); end
+    def song;     @song     ||= Resources::Song.new(@http); end
+    def spotify;  @spotify  ||= Resources::Spotify.new(@http); end
+    def stats;    @stats    ||= Resources::Stats.new(@http); end
+
+    def inspect
+      "#<Rocksky::Client base_url=#{base_url.inspect} token=#{token ? "[FILTERED]" : nil.inspect}>"
+    end
+
+    private
+
+    def normalize_base_url(url)
+      url.to_s.sub(%r{/+\z}, "")
+    end
+  end
+end

data/lib/rocksky/error.rb

@@ -0,0 +1,58 @@
+module Rocksky
+  class Error < StandardError
+    attr_reader :status, :body, :nsid
+
+    def initialize(message, status: nil, body: nil, nsid: nil)
+      super(message)
+      @status = status
+      @body = body
+      @nsid = nsid
+    end
+
+    def self.from_response(status, body, nsid: nil)
+      message = extract_message(body) || "request failed"
+      klass = klass_for(status)
+      klass.new(message, status: status, body: body, nsid: nsid)
+    end
+
+    def self.from_transport(cause, nsid: nil)
+      TransportError.new(
+        "transport error: #{cause.class}: #{cause.message}",
+        body: nil,
+        nsid: nsid
+      )
+    end
+
+    def self.klass_for(status)
+      case status
+      when 400 then BadRequest
+      when 401 then Unauthorized
+      when 403 then Forbidden
+      when 404 then NotFound
+      when 429 then RateLimited
+      when 500..599 then ServerError
+      else HTTPError
+      end
+    end
+    private_class_method :klass_for
+
+    def self.extract_message(body)
+      case body
+      when Hash
+        body["message"] || body["error"] || body[:message] || body[:error]
+      when String
+        body unless body.empty?
+      end
+    end
+    private_class_method :extract_message
+  end
+
+  class HTTPError < Error; end
+  class BadRequest < HTTPError; end
+  class Unauthorized < HTTPError; end
+  class Forbidden < HTTPError; end
+  class NotFound < HTTPError; end
+  class RateLimited < HTTPError; end
+  class ServerError < HTTPError; end
+  class TransportError < Error; end
+end

data/lib/rocksky/http.rb

@@ -0,0 +1,123 @@
+require "json"
+require "net/http"
+require "uri"
+
+module Rocksky
+  # Low-level XRPC transport. Most users should go through the resource
+  # accessors on {Rocksky::Client} (e.g. `client.actor.get_profile(...)`).
+  class HTTP
+    DEFAULT_OPEN_TIMEOUT = 10
+    DEFAULT_READ_TIMEOUT = 30
+
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+    end
+
+    # GET /xrpc/<nsid>?...
+    def query(nsid, params = {})
+      request(method: :get, nsid: nsid, params: params)
+    end
+
+    # POST /xrpc/<nsid>?... with optional JSON body.
+    def procedure(nsid, params = {}, body = nil)
+      request(method: :post, nsid: nsid, params: params, body: body)
+    end
+
+    private
+
+    def request(method:, nsid:, params: {}, body: nil)
+      uri = build_uri(nsid, params)
+      req = build_request(method, uri, body)
+      apply_headers(req)
+
+      response = perform(uri, req)
+      handle_response(response, nsid)
+    rescue Timeout::Error, Errno::ECONNREFUSED, SocketError, IOError,
+           Net::OpenTimeout, Net::ReadTimeout => e
+      raise Error.from_transport(e, nsid: nsid)
+    end
+
+    def build_uri(nsid, params)
+      url = "#{client.base_url}/xrpc/#{nsid}"
+      uri = URI.parse(url)
+      encoded = encode_params(params)
+      uri.query = URI.encode_www_form(encoded) unless encoded.empty?
+      uri
+    end
+
+    def build_request(method, uri, body)
+      req =
+        case method
+        when :get  then Net::HTTP::Get.new(uri.request_uri)
+        when :post then Net::HTTP::Post.new(uri.request_uri)
+        else raise ArgumentError, "unsupported method: #{method}"
+        end
+
+      if body && !body.empty?
+        req["content-type"] = "application/json"
+        req.body = JSON.generate(body)
+      end
+
+      req
+    end
+
+    def apply_headers(req)
+      req["accept"] = "application/json"
+      req["user-agent"] = client.user_agent if client.user_agent
+      req["authorization"] = "Bearer #{client.token}" if client.token
+      client.headers.each { |name, value| req[name] = value }
+    end
+
+    def perform(uri, req)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == "https")
+      http.open_timeout = client.open_timeout
+      http.read_timeout = client.read_timeout
+      http.request(req)
+    end
+
+    def handle_response(response, nsid)
+      status = response.code.to_i
+      body = parse_body(response)
+
+      return body if status.between?(200, 299)
+
+      raise Error.from_response(status, body, nsid: nsid)
+    end
+
+    def parse_body(response)
+      return nil if response.body.nil? || response.body.empty?
+
+      content_type = response["content-type"].to_s
+      if content_type.include?("application/json")
+        JSON.parse(response.body)
+      else
+        response.body
+      end
+    rescue JSON::ParserError
+      response.body
+    end
+
+    # Drop nil values; convert symbol keys to strings; join arrays with commas
+    # (matches the lexicon-defined array encoding used by other SDKs).
+    def encode_params(params)
+      return {} if params.nil?
+
+      Hash(params).each_with_object({}) do |(key, value), out|
+        next if value.nil?
+
+        out[key.to_s] = encode_value(value)
+      end
+    end
+
+    def encode_value(value)
+      case value
+      when Array then value.join(",")
+      when true, false then value.to_s
+      else value
+      end
+    end
+  end
+end

data/lib/rocksky/resources/actor.rb

@@ -0,0 +1,60 @@
+module Rocksky
+  module Resources
+    # `app.rocksky.actor.*` endpoints.
+    class Actor < Base
+      # Fetch a profile by DID or handle.
+      def get_profile(did:)
+        query("app.rocksky.actor.getProfile", did: did)
+      end
+
+      # Albums an actor has scrobbled.
+      def get_actor_albums(did:, limit: nil, offset: nil, start_date: nil, end_date: nil)
+        query("app.rocksky.actor.getActorAlbums",
+              did: did, limit: limit, offset: offset,
+              startDate: start_date, endDate: end_date)
+      end
+
+      # Artists an actor has scrobbled.
+      def get_actor_artists(did:, limit: nil, offset: nil, start_date: nil, end_date: nil)
+        query("app.rocksky.actor.getActorArtists",
+              did: did, limit: limit, offset: offset,
+              startDate: start_date, endDate: end_date)
+      end
+
+      # Songs an actor has scrobbled.
+      def get_actor_songs(did:, limit: nil, offset: nil, start_date: nil, end_date: nil)
+        query("app.rocksky.actor.getActorSongs",
+              did: did, limit: limit, offset: offset,
+              startDate: start_date, endDate: end_date)
+      end
+
+      # Songs an actor has loved.
+      def get_actor_loved_songs(did:, limit: nil, offset: nil)
+        query("app.rocksky.actor.getActorLovedSongs",
+              did: did, limit: limit, offset: offset)
+      end
+
+      # Scrobbles for an actor.
+      def get_actor_scrobbles(did:, limit: nil, offset: nil)
+        query("app.rocksky.actor.getActorScrobbles",
+              did: did, limit: limit, offset: offset)
+      end
+
+      # Playlists for an actor.
+      def get_actor_playlists(did:, limit: nil, offset: nil)
+        query("app.rocksky.actor.getActorPlaylists",
+              did: did, limit: limit, offset: offset)
+      end
+
+      # Musical neighbours of an actor.
+      def get_actor_neighbours(did:)
+        query("app.rocksky.actor.getActorNeighbours", did: did)
+      end
+
+      # Compatibility score between the authenticated user and another actor.
+      def get_actor_compatibility(did:)
+        query("app.rocksky.actor.getActorCompatibility", did: did)
+      end
+    end
+  end
+end

data/lib/rocksky/resources/album.rb

@@ -0,0 +1,22 @@
+module Rocksky
+  module Resources
+    # `app.rocksky.album.*` endpoints.
+    class Album < Base
+      # Fetch an album by AT-URI.
+      def get_album(uri:)
+        query("app.rocksky.album.getAlbum", uri: uri)
+      end
+
+      # List albums.
+      def get_albums(limit: nil, offset: nil, genre: nil)
+        query("app.rocksky.album.getAlbums",
+              limit: limit, offset: offset, genre: genre)
+      end
+
+      # Tracks belonging to an album.
+      def get_album_tracks(uri:)
+        query("app.rocksky.album.getAlbumTracks", uri: uri)
+      end
+    end
+  end
+end

data/lib/rocksky/resources/apikey.rb

@@ -0,0 +1,28 @@
+module Rocksky
+  module Resources
+    # `app.rocksky.apikey.*` endpoints. All require an authenticated client.
+    class Apikey < Base
+      # List your API keys.
+      def get_apikeys(limit: nil, offset: nil)
+        query("app.rocksky.apikey.getApikeys", limit: limit, offset: offset)
+      end
+
+      # Create a new API key.
+      def create_apikey(name:, description: nil)
+        body = { name: name, description: description }.compact
+        procedure("app.rocksky.apikey.createApikey", body: body)
+      end
+
+      # Update an API key.
+      def update_apikey(id:, name: nil, description: nil)
+        body = { id: id, name: name, description: description }.compact
+        procedure("app.rocksky.apikey.updateApikey", body: body)
+      end
+
+      # Remove an API key.
+      def remove_apikey(id:)
+        procedure("app.rocksky.apikey.removeApikey", params: { id: id })
+      end
+    end
+  end
+end