pocket_phone 0.1.0

data/lib/pocket_phone/store.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "securerandom"
+
+module PocketPhone
+  # The database on disk: one JSON file under tmp/, guarded by a lock file so
+  # the web server, its background threads and anything else that loads the
+  # gem can all read and write it safely.
+  class Store
+    attr_reader :path
+
+    def initialize(path)
+      @path = path.to_s
+    end
+
+    def read
+      locked(File::LOCK_SH) { Database.new(load) }
+    end
+
+    # Yields the database for changes and saves it. Returns the block's value.
+    def write
+      locked(File::LOCK_EX) do
+        database = Database.new(load)
+        seed(database)
+        result = yield database
+        database.data["version"] = database.version + 1
+        dump(database.data)
+        result
+      end
+    end
+
+    # Forget every conversation. People and lines are kept, so a number you
+    # set up once stays set up.
+    def clear!
+      write do |database|
+        database.conversations.clear
+        database.messages.clear
+        database.previews.clear
+      end
+      FileUtils.rm_rf(media_dir)
+    end
+
+    # Everything, people included.
+    def reset!
+      locked(File::LOCK_EX) { FileUtils.rm_f(file) }
+      FileUtils.rm_rf(media_dir)
+    end
+
+    # --- attachments --------------------------------------------------------
+
+    def media_dir = File.join(path, "media")
+
+    def save_media(io, filename)
+      FileUtils.mkdir_p(media_dir)
+      name = "#{SecureRandom.hex(8)}#{File.extname(filename.to_s).downcase[/\A\.[a-z0-9]{1,8}\z/]}"
+      File.binwrite(File.join(media_dir, name), io.read)
+      name
+    end
+
+    def media_file(name)
+      candidate = File.join(media_dir, File.basename(name.to_s))
+      candidate if File.file?(candidate)
+    end
+
+    private
+
+    def file = File.join(path, "store.json")
+
+    def locked(mode)
+      FileUtils.mkdir_p(path)
+      File.open(File.join(path, "store.lock"), File::RDWR | File::CREAT, 0o644) do |lock|
+        lock.flock(mode)
+        yield
+      end
+    end
+
+    def load
+      File.exist?(file) ? JSON.parse(File.read(file)) : nil
+    rescue JSON::ParserError
+      nil
+    end
+
+    # Written beside the real file and renamed over it, so a reader never sees
+    # half a database.
+    def dump(data)
+      temporary = "#{file}.#{Process.pid}.#{Thread.current.object_id}.tmp"
+      File.write(temporary, JSON.generate(data))
+      File.rename(temporary, file)
+    end
+
+    def seed(database)
+      return if database.data["seeded"]
+
+      database.data["seeded"] = true
+      Array(PocketPhone.config.people).each do |person|
+        person = person.transform_keys(&:to_s)
+        number = Numbers.normalize(person["number"])
+        next if number.empty?
+
+        database.ensure_person(number, person.slice("name", "service", "outcome"))
+      end
+    end
+  end
+end

data/lib/pocket_phone/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module PocketPhone
+  VERSION = "0.1.0"
+end

data/lib/pocket_phone/webhook.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "openssl"
+require "uri"
+
+module PocketPhone
+  # One webhook delivery to the app, signed the way Sendblue signs them.
+  #
+  # Sendblue sends two things when a signing secret is set: the secret itself
+  # in a header (`sb-signing-secret` unless you renamed it), and
+  # `x-sendblue-signature: t=<unix>,v1=<hex>`, an HMAC-SHA256 of
+  # "<t>.<raw body>" keyed by the secret. Both are sent here so that either
+  # check can be exercised.
+  module Webhook
+    module_function
+
+    # Returns a record of what happened, for the message's details:
+    # { "type", "url", "status" or "error", "at" }.
+    def deliver(type:, url:, payload:)
+      settings = Runner.with_app do
+        config = PocketPhone.config
+        { secret: config.signing_secret.to_s, header: config.secret_header.to_s,
+          timeout: config.webhook_timeout }
+      end
+      uri = absolute(url)
+      body = JSON.generate(payload)
+      response = post(uri, body, headers(body, settings), settings[:timeout])
+      record(type, uri, "status" => response.code.to_i)
+    rescue StandardError => e
+      record(type, url, "error" => "#{e.class.name}: #{e.message}")
+    end
+
+    def signature(secret, body, timestamp = Time.now.to_i)
+      "t=#{timestamp},v1=#{OpenSSL::HMAC.hexdigest("SHA256", secret, "#{timestamp}.#{body}")}"
+    end
+
+    def headers(body, settings)
+      headers = { "Content-Type" => "application/json", "Accept" => "application/json",
+                  "User-Agent" => "pocket_phone/#{VERSION}" }
+      return headers if settings[:secret].empty?
+
+      headers["x-sendblue-signature"] = signature(settings[:secret], body)
+      headers[settings[:header]] = settings[:secret] unless settings[:header].empty?
+      headers
+    end
+
+    def absolute(url)
+      uri = URI.parse(url.to_s)
+      return uri if uri.is_a?(URI::HTTP)
+      raise ArgumentError, "webhook URL #{url.inspect} is a path and no request has been served yet" if PocketPhone.base_url.to_s.empty?
+
+      URI.join(PocketPhone.base_url, url.to_s)
+    end
+
+    def post(uri, body, headers, timeout)
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https",
+        open_timeout: 5, read_timeout: timeout) do |http|
+        http.post(uri.request_uri, body, headers)
+      end
+    end
+
+    def record(type, url, outcome)
+      { "type" => type, "url" => url.to_s, "at" => PocketPhone.now }.merge(outcome)
+    end
+  end
+end

data/lib/pocket_phone.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "pocket_phone/version"
+require "pocket_phone/configuration"
+require "pocket_phone/numbers"
+require "pocket_phone/database"
+require "pocket_phone/store"
+require "pocket_phone/payloads"
+require "pocket_phone/runner"
+require "pocket_phone/webhook"
+require "pocket_phone/link_preview"
+require "pocket_phone/carrier"
+require "pocket_phone/engine"
+
+# A fake Sendblue for development: your app sends to it instead of to
+# api.sendblue.com, and you answer from a phone in the browser.
+module PocketPhone
+  # The line a phone texts when nothing has told us the app's real number yet.
+  FALLBACK_LINE = "+15555550100"
+
+  class << self
+    # The scheme and host of the last request the engine served. Webhook URLs
+    # may be configured as paths ("/webhooks/sendblue/token"); this is what
+    # they are resolved against.
+    attr_accessor :base_url
+
+    def config
+      @config ||= Configuration.new
+    end
+
+    def configure
+      yield config
+    end
+
+    def reset_config!
+      @config = nil
+    end
+
+    def store
+      Store.new(config.storage_path)
+    end
+
+    def now
+      Time.now.utc.iso8601(3)
+    end
+  end
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: pocket_phone
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- hmk
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: actionview
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+description: Like letter_opener, but for iMessage and SMS, and in both directions.
+  pocket_phone is a mountable Rails engine that answers the Sendblue API, shows what
+  your app sent in an iMessage-style inbox, and lets you text back through signed
+  webhooks.
+email:
+- hmk@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- app/controllers/pocket_phone/api/sendblue_controller.rb
+- app/controllers/pocket_phone/application_controller.rb
+- app/controllers/pocket_phone/conversations_controller.rb
+- app/controllers/pocket_phone/media_controller.rb
+- app/controllers/pocket_phone/messages_controller.rb
+- app/controllers/pocket_phone/people_controller.rb
+- app/helpers/pocket_phone/application_helper.rb
+- app/views/layouts/pocket_phone/_script.html.erb
+- app/views/layouts/pocket_phone/_styles.html.erb
+- app/views/layouts/pocket_phone/application.html.erb
+- app/views/pocket_phone/conversations/_head.html.erb
+- app/views/pocket_phone/conversations/_message.html.erb
+- app/views/pocket_phone/conversations/_messages.html.erb
+- app/views/pocket_phone/conversations/_new_dialog.html.erb
+- app/views/pocket_phone/conversations/_sidebar.html.erb
+- app/views/pocket_phone/conversations/show.html.erb
+- config/routes.rb
+- lib/pocket_phone.rb
+- lib/pocket_phone/carrier.rb
+- lib/pocket_phone/configuration.rb
+- lib/pocket_phone/database.rb
+- lib/pocket_phone/engine.rb
+- lib/pocket_phone/link_preview.rb
+- lib/pocket_phone/numbers.rb
+- lib/pocket_phone/payloads.rb
+- lib/pocket_phone/runner.rb
+- lib/pocket_phone/store.rb
+- lib/pocket_phone/version.rb
+- lib/pocket_phone/webhook.rb
+homepage: https://github.com/hmk/pocket_phone
+licenses:
+- BSD-3-Clause
+metadata:
+  source_code_uri: https://github.com/hmk/pocket_phone
+  changelog_uri: https://github.com/hmk/pocket_phone/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/hmk/pocket_phone/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: 'A fake Sendblue for development: text your app from a phone in the browser.'
+test_files: []