good_audible_story_sync 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 25bf4c07587019619d34e8daab5729bc3e6e62863475dc827ad5cc265ccce7b6
+  data.tar.gz: b95565652c0913a34c624aef5d00d0ba6351e59e5c895fc9faf0853bc85c9ea7
+SHA512:
+  metadata.gz: 23aff0e8f660a9661c771a8f031e23a3e2d95b70790ccbfdd08de55e7c799e882345c996b3d8242a80e2c31a99181cdf7aa122b11bbd870e45625aed4f277ab2
+  data.tar.gz: b1293d14b8bbde5a0d4ec4dc6a7d1059f637b052b1bbbf9bc0502405026fddd10c584740c64bf93d9155e19d02cd77e19b60ee5d1beed597a488d26f7a12dff1

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Sarah Vessels
+
+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,113 @@
+# good-audible-story-sync
+
+Script to sync your read books from Audible to Goodreads and StoryGraph.
+
+## How to use
+
+> [!NOTE]
+> This is intended to be run from macOS.
+
+Download the [latest release](https://github.com/cheshire137/good-audible-story-sync/releases/latest) of the gem. Install it via:
+
+```sh
+gem install good-audible-story-sync.gem
+```
+
+There should now be a `good-audible-story-sync` executable in your path. Run it via:
+
+```sh
+good-audible-story-sync
+```
+
+You will be prompted to log in to Audible and Storygraph. The tool saves your encrypted login
+credentials in a SQLite database and stores the encryption key in the macOS keychain, under the name
+'good_audible_story_sync_encryption_key'.
+
+After signing into Audible, it will create a new device that you can see on your Amazon
+[Installed on Devices](https://www.amazon.com/hz/mycd/digital-console/devicedetails?deviceFamily=AUDIBLE_APP)
+page for Audible. This allows accessing your Audible library information, such as which books
+you finished reading and when.
+
+### Options
+
+```sh
+Usage: good-audible-story-sync [options]
+    -d DATABASE_FILE,                Path to Sqlite database file. Defaults to good_audible_story_sync.db.
+        --database-file
+    -e EXPIRATION_DAYS,              Max number of days to use cached data, such as Audible library, before refreshing. Defaults to 1.
+        --expiration-days
+```
+
+### Sample output
+
+```sh
+% good-audible-story-sync
+🔐 Looking for 'good_audible_story_sync_encryption_key' in cheshire137's keychain...
+ℹ️ Using GoodAudibleStorySync encryption key from keychain
+⚙️ Parsing options...
+ℹ️ Ensuring table audible_books exists...
+ℹ️ Ensuring table storygraph_books exists...
+ℹ️ Ensuring table goodreads_books exists...
+ℹ️ Ensuring table credentials exists...
+ℹ️ Ensuring table sync_times exists...
+a) display Audible library
+p) display Audible user profile
+g) display Goodreads library
+s) display Storygraph library
+l) look up book on Storygraph
+c) update Storygraph library cache
+f) mark finished books on Storygraph
+q) quit
+Choose an option:
+```
+
+## How to develop
+
+Built using Ruby version 3.3.6 on macOS.
+
+```sh
+bundle install
+bin/good-audible-story-sync
+```
+
+Run `srb tc` to run the [Sorbet type checker](https://sorbet.org/).
+
+You can also run `irb` to get an interactive Ruby console with some convenient methods available for debugging, including:
+
+- #load_db_client
+- #load_options
+- #get_audible_auth
+- #get_audible_client
+- #get_audible_library
+- #get_storygraph_auth
+- #get_storygraph_client
+- #get_goodreads_auth
+- #get_goodreads_client
+
+### Creating a tag
+
+Update `VERSION` in [version.rb](./lib/good_audible_story_sync/version.rb).
+
+```sh
+git tag v0.0.x main # use the same version string as in `VERSION`
+git push origin tag v0.0.x
+```
+
+This will trigger a workflow that builds the gem and creates a new release.
+
+### Building the gem
+
+```sh
+gem build good_audible_story_sync.gemspec
+```
+
+This will create a file like project_pull_mover-0.0.1.gem which you can then install:
+
+```sh
+gem install good_audible_story_sync-0.0.1.gem
+```
+
+## Thanks
+
+- [mkb79's Python Audible library](https://github.com/mkb79/Audible) for providing an example of how to authenticate with Audible and use its API, including the [unofficial API docs](https://audible.readthedocs.io/en/master/misc/external_api.html).
+- [mechanize gem](https://github.com/sparklemotion/mechanize) for letting me automate Storygraph and Goodreads even without an API.

data/bin/good-audible-story-sync

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require_relative "../lib/good_audible_story_sync"
+
+GoodAudibleStorySync::InputLoop.run(script_name: __FILE__)

data/lib/good_audible_story_sync/audible/auth.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+# typed: true
+
+require "base64"
+require "digest"
+require "httparty"
+require "json"
+require "securerandom"
+require "uri"
+
+module GoodAudibleStorySync
+  module Audible
+    class Auth
+      extend T::Sig
+
+      US_MARKETPLACE_ID = "AF2M0KC94RCEA"
+      US_DOMAIN = "com"
+      CREDENTIALS_DB_KEY = "audible"
+
+      class InvalidTokenError < StandardError; end
+      class ForbiddenError < StandardError; end
+
+      sig { params(action: String, response: HTTParty::Response).void }
+      def self.handle_http_error(action:, response:)
+        code = response.code
+        raise ForbiddenError if code == 403
+
+        json = begin
+          JSON.parse(response.body)
+        rescue JSON::ParserError
+          raise "Failed to #{action} (#{code}):\n#{response.body}"
+        end
+
+        error_type = json["error"]
+        raise InvalidTokenError if error_type == "invalid_token"
+
+        if error_type
+          error_description = json["error_description"]
+          raise "Failed to #{action} (#{code}): #{error_type} #{error_description}"
+        end
+
+        message = json["message"]
+        if message
+          raise "Failed to #{action} (#{code}): #{message}"
+        end
+
+        raise "Failed to #{action} (#{code}):\n#{response.body}"
+      end
+
+      sig { params(expires_s: Integer).returns(Time) }
+      def self.expiration_time_from_seconds(expires_s)
+        Time.now.utc + (expires_s/86400.0)
+      end
+
+      sig { params(source_token: String).returns([String, Time]) }
+      def self.refresh_token(source_token)
+        raise "No source token provided to refresh" if source_token.size < 1
+
+        body = {
+          "requested_token_type" => "access_token",
+          "source_token_type" => "refresh_token",
+          "app_name" => "Audible",
+          "app_version" => "3.56.2",
+          "source_token" => source_token,
+        }
+        url = "https://api.amazon.#{US_DOMAIN}/auth/token"
+        puts "POST #{url}"
+        response = HTTParty.post(url, body: body)
+        handle_http_error(action: "refresh token", response: response) unless response.code == 200
+
+        json = JSON.parse(response.body)
+        expires_s = json["expires_in"].to_i
+        expires = expiration_time_from_seconds(expires_s)
+        access_token = json["access_token"]
+        [access_token, expires]
+      end
+
+      attr_reader :adp_token, :device_private_key, :refresh_token, :website_cookies,
+        :store_authentication_cookie, :device_info, :customer_info
+
+      sig { returns T.nilable(String) }
+      attr_accessor :access_token
+
+      sig { returns T.nilable(Time) }
+      attr_accessor :expires
+
+      sig { void }
+      def initialize
+        verifier = SecureRandom.random_bytes(32)
+        @code_verifier = Base64.urlsafe_encode64(verifier).delete_suffix("=")
+        @device_serial = SecureRandom.uuid.upcase.delete('-')
+        @client_id = "#{device_serial}#A2CZJZGLK2JJVM".unpack1('H*')
+        @auth_code = nil
+        @adp_token = nil
+        @device_private_key = nil
+        @access_token = nil
+        @refresh_token = nil
+        @expires = nil
+        @website_cookies = nil
+        @store_authentication_cookie = nil
+        @device_info = nil
+        @customer_info = nil
+        @loaded_from_database = T.let(false, T::Boolean)
+      end
+
+      sig { returns String }
+      def oauth_url
+        m = Digest::SHA256.digest(code_verifier)
+        s256_code_challenge = Base64.urlsafe_encode64(m).delete_suffix("=")
+        base_url = "https://www.amazon.#{US_DOMAIN}/ap/signin"
+        return_to = "https://www.amazon.#{US_DOMAIN}/ap/maplanding"
+        assoc_handle = "amzn_audible_ios_us"
+        page_id = "amzn_audible_ios"
+        params = {
+          "openid.oa2.response_type" => "code",
+          "openid.oa2.code_challenge_method" => "S256",
+          "openid.oa2.code_challenge" => s256_code_challenge,
+          "openid.return_to" => return_to,
+          "openid.assoc_handle" => assoc_handle,
+          "openid.identity" => "http://specs.openid.net/auth/2.0/identifier_select",
+          "pageId" => page_id,
+          "accountStatusPolicy" => "P1",
+          "openid.claimed_id" => "http://specs.openid.net/auth/2.0/identifier_select",
+          "openid.mode" => "checkid_setup",
+          "openid.ns.oa2" => "http://www.amazon.com/ap/ext/oauth/2",
+          "openid.oa2.client_id" => "device:#{client_id}",
+          "openid.ns.pape" => "http://specs.openid.net/extensions/pape/1.0",
+          "marketPlaceId" => US_MARKETPLACE_ID,
+          "openid.oa2.scope" => "device_auth_access",
+          "forceMobileLayout" => "true",
+          "openid.ns" => "http://specs.openid.net/auth/2.0",
+          "openid.pape.max_auth_age" => "0",
+        }
+        "#{base_url}?#{URI.encode_www_form(params)}"
+      end
+
+      sig { params(url: String).void }
+      def set_authorization_code_from_oauth_redirect_url(url)
+        uri = URI.parse(url)
+        query = uri.query
+        if query
+          redirect_params = URI.decode_www_form(query).to_h
+          @auth_code = redirect_params["openid.oa2.authorization_code"]
+        end
+      end
+
+      sig { returns T::Boolean }
+      def register_device
+        raise "No authorization code has been set" if auth_code.nil? || auth_code.size < 1
+
+        body = {
+          "requested_token_type" => ["bearer", "mac_dms", "website_cookies",
+            "store_authentication_cookie"],
+          "cookies" => {"website_cookies" => [], "domain" => ".amazon.#{US_DOMAIN}"},
+          "registration_data" => {
+            "domain" => "Device",
+            "app_version" => "3.56.2",
+            "device_serial" => device_serial,
+            "device_type" => "A2CZJZGLK2JJVM",
+            "device_name" => "GoodAudibleStorySync",
+            "os_version" => "15.0.0",
+            "software_version" => "35602678",
+            "device_model" => "iPhone",
+            "app_name" => "Audible",
+          },
+          "auth_data" => {
+            "client_id" => client_id,
+            "authorization_code" => auth_code,
+            "code_verifier" => code_verifier,
+            "code_algorithm" => "SHA-256",
+            "client_domain" => "DeviceLegacy",
+          },
+          "requested_extensions" => ["device_info", "customer_info"],
+        }
+
+        url = "https://api.amazon.#{US_DOMAIN}/auth/register"
+        puts "POST #{url}"
+        response = HTTParty.post(url, body: body.to_json)
+        unless response.code == 200
+          self.class.handle_http_error(action: "register device", response: response)
+        end
+
+        resp_json = JSON.parse(response.body)
+        success_data = resp_json.dig("response", "success")
+        raise "Failed to register device:\n#{response.body}" unless success_data
+
+        tokens = success_data["tokens"]
+        @adp_token = tokens.dig("mac_dms", "adp_token")
+        @device_private_key = tokens.dig("mac_dms", "device_private_key")
+        @store_authentication_cookie = tokens["store_authentication_cookie"]
+        @access_token = tokens.dig("bearer", "access_token")
+        @refresh_token = tokens.dig("bearer", "refresh_token")
+        expires_s = tokens.dig("bearer", "expires_in").to_i
+        @expires = self.class.expiration_time_from_seconds(expires_s)
+
+        extensions = success_data["extensions"]
+        @device_info = extensions["device_info"]
+        @customer_info = extensions["customer_info"]
+
+        @website_cookies = {}
+        tokens["website_cookies"].each do |cookie|
+          value = cookie["Value"]
+          @website_cookies[cookie["Name"]] = if value
+            value.gsub('"', '')
+          end
+        end
+
+        !@access_token.nil? && !@access_token.strip.empty?
+      end
+
+      sig { returns T::Hash[String, T.untyped] }
+      def to_h
+        {
+          "adp_token" => adp_token,
+          "device_private_key" => device_private_key,
+          "access_token" => access_token,
+          "refresh_token" => refresh_token,
+          "expires" => expires,
+          "website_cookies" => website_cookies,
+          "store_authentication_cookie" => store_authentication_cookie,
+          "device_info" => device_info,
+          "customer_info" => customer_info,
+        }
+      end
+
+      sig { params(cred_client: Database::Credentials).void }
+      def save_to_database(cred_client)
+        cred_client.upsert(key: CREDENTIALS_DB_KEY, value: to_h)
+      end
+
+      sig { returns T::Boolean }
+      def loaded_from_database?
+        @loaded_from_database
+      end
+
+      sig { params(creds_db: Database::Credentials).returns(T::Boolean) }
+      def load_from_database(creds_db)
+        audible_data = creds_db.find(key: CREDENTIALS_DB_KEY)
+        unless audible_data
+          puts "#{Util::INFO_EMOJI} No Audible credentials found in database"
+          return false
+        end
+
+        @adp_token = audible_data["adp_token"]
+        @device_private_key = audible_data["device_private_key"]
+        @access_token = audible_data["access_token"]
+        @refresh_token = audible_data["refresh_token"]
+        @expires = audible_data["expires"]
+        @website_cookies = audible_data["website_cookies"]
+        @store_authentication_cookie = audible_data["store_authentication_cookie"]
+        @device_info = audible_data["device_info"]
+        @customer_info = audible_data["customer_info"]
+
+        @loaded_from_database = !!(!@access_token.nil? && !@access_token.strip.empty?)
+      end
+
+      private
+
+      attr_reader :code_verifier, :device_serial, :client_id, :auth_code
+    end
+  end
+end

data/lib/good_audible_story_sync/audible/auth_flow.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+# typed: true
+
+require "uri"
+
+module GoodAudibleStorySync
+  module Audible
+    class AuthFlow
+      extend T::Sig
+
+      sig { params(db_client: Database::Client).returns(T.nilable(Auth)) }
+      def self.run(db_client:)
+        new(db_client: db_client).run
+      end
+
+      sig { params(db_client: Database::Client).void }
+      def initialize(db_client:)
+        @audible_auth = Auth.new
+        @credentials_db = db_client.credentials
+      end
+
+      sig { returns T.nilable(Auth) }
+      def run
+        success = load_from_database || log_in_via_oauth
+        success ? audible_auth : nil
+      end
+
+      private
+
+      sig { returns Auth }
+      attr_reader :audible_auth
+
+      sig { returns T::Boolean }
+      def load_from_database
+        puts "#{Util::INFO_EMOJI} Looking for saved Audible credentials in database..."
+        success = audible_auth.load_from_database(@credentials_db)
+        puts "#{Util::SUCCESS_EMOJI} Found saved Audible credentials." if success
+        success
+      end
+
+      sig { returns T::Boolean }
+      def log_in_via_oauth
+        puts "Please authenticate with Audible via: #{audible_auth.oauth_url}"
+        puts "\nEnter the URL you were redirected to after logging in:"
+        url_after_login = gets.chomp
+        audible_auth.set_authorization_code_from_oauth_redirect_url(url_after_login)
+
+        puts "\n#{Util::INFO_EMOJI} Registering Audible device..."
+        success = begin
+          audible_auth.register_device
+        rescue => err
+          puts "#{Util::ERROR_EMOJI} Error registering device: #{err}"
+          return false
+        end
+
+        unless success
+          puts "\n#{Util::ERROR_EMOJI} Failed to authenticate with Audible"
+          return false
+        end
+
+        device_name = audible_auth.device_info["device_name"]
+        puts "\n#{Util::SUCCESS_EMOJI} Successfully authenticated with Audible and " \
+          "registered device: #{device_name}"
+
+        audible_auth.save_to_database(@credentials_db)
+        true
+      end
+    end
+  end
+end