samagotchi 0.111.1 → 0.112.0

data/lib/samagotchi/web/push/notifier.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require "time"
 require_relative "attention"
 require_relative "../../log"
 
@@ -10,9 +11,11 @@ module Samagotchi
       # chi web's one sender of pushes: a SessionHub subscriber that keeps
       # the summaries the page's trackAttention keeps (seeded by the
       # subscribe's snapshot, so what was open before never pushes), turns
-      # each new approval or question (Attention.for) into a show, and
-      # hands it to its own sender thread through a Queue; one answered
-      # anywhere (Attention.closed_keys) only cancels its show's hold.
+      # each new attention (Attention.for: a question, an approval, a
+      # step-limit continue, a card with actions, a failed or done turn)
+      # into a show, and hands it to its own sender thread through a Queue;
+      # one answered anywhere (Attention.closed_keys) only cancels its
+      # show's hold.
       #
       # Every push it sends shows a notification: WebKit removes a
       # subscription after a few pushes that show none (its silent-push
@@ -25,33 +28,57 @@ module Samagotchi
       # tick thread and on chi web's request threads (SessionHub#touch), so
       # it only enqueues; a push is a 0.5 s https call, made on the sender
       # thread. There a show waits its hold (HOLD, or the event's own) and
-      # is pushed only while still open, to every device subscribed on this
-      # run's public origin. See docs/internals/web-push.md.
+      # is pushed, a waiting one only while still open, to the devices
+      # subscribed on this run's public origin (a done turn only to those
+      # that asked for it), unless a chi web page is in front (Presence):
+      # then the owner is looking, and the key is never pushed. At most CAP
+      # shows an hour; a 429 or 5xx is retried once (Client::Result
+      # #retry_after) without the sender ever sleeping. Each key handled
+      # (pushed, skipped or capped) goes in the store's sent.json, so after
+      # a restart the seed pushes an approval asked meanwhile (open, under
+      # CATCH_UP old) and nothing pushed already. See
+      # docs/internals/web-push.md.
       class Notifier
         HOLD = 3.0
         # Waiting kinds: kept 12 h for an offline phone, delivered at once.
         SHOW_TTL = 12 * 3600
+        # A failed or done turn: stale soon, no need to wake the phone.
+        EVENT_TTL = 600
         # A show carries +open+ only while its JSON stays this small: one
         # aes128gcm record leaves 3993 bytes of plaintext under Web Push's
         # 4096 (86 header, 1 delimiter, 16 tag). Longer, it goes without
         # (and the worker cleans up nothing).
         OPEN_LIMIT = 3000
         STOP_JOIN = 2.0
+        # Shows (one event, however many devices) per rolling CAP_WINDOW.
+        CAP = 30
+        CAP_WINDOW = 3600
+        # A question open at a restart is pushed if it was asked this
+        # recently and isn't in sent.json.
+        CATCH_UP = 3600
 
         Show = Data.define(:attention, :title, :body, :at)
         Close = Data.define(:keys)
+        # One device's show, again at +at+ (the push service said when).
+        Retry = Data.define(:show, :sub_id, :at)
 
         # @param store [Store] the devices (and the key the client signs with)
         # @param client [#deliver] Client
         # @param origin [String] this run's public origin: only the
         #   subscriptions made on it are sent to
+        # @param presence [Presence, nil] the pages' reports (nil: nobody is
+        #   ever in front)
         # @param now [#call] monotonic seconds (specs move it)
-        def initialize(store:, client:, origin:, hold: HOLD, now: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
+        # @param clock [#call] the Time now (a question's created_at)
+        def initialize(store:, client:, origin:, presence: nil, hold: HOLD,
+                       now: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }, clock: -> { Time.now })
           @store = store
           @client = client
           @origin = origin
+          @presence = presence
           @hold = hold
           @now = now
+          @clock = clock
           @queue = Queue.new
           # The sink's side (under @mutex): the last summary per session.
           @mutex = Mutex.new
@@ -60,6 +87,9 @@ module Samagotchi
           @early = []
           # The sender's side (its thread only, or #pump in a spec).
           @pending = {} # key → Show waiting its hold
+          @retries = {} # [key, device id] → Retry
+          @shown = [] # when each counted show went, oldest first
+          @capped_warned_at = nil
           @refused = false
           @thread = nil
           @handle = nil
@@ -97,10 +127,13 @@ module Samagotchi
         end
 
         # The seed: the summaries as the subscribe saw them. Events that came
-        # before it (newer than the snapshot) are applied after it.
+        # before it (newer than the snapshot) are applied after it. An open
+        # question asked under CATCH_UP ago that no earlier run handled
+        # (sent.json) is shown: it came while chi web was down.
         def seed(summaries)
           @mutex.synchronize do
             summaries.each { |summary| @by_id[summary[:id]] = summary if summary[:id] }
+            catch_up(summaries)
             @seeded = true
             @early.each { |event| notice(event) }
             @early.clear
@@ -142,6 +175,32 @@ module Samagotchi
           end
         end
 
+        # Cards carry no time: they seed as they are.
+        def catch_up(summaries)
+          sent = nil
+          at = @clock.call
+          summaries.each do |summary|
+            question = summary[:pending_question]
+            next unless summary[:id] && question.is_a?(Hash) && question[:id] && !question[:relayed_to]
+
+            asked = asked_at(question[:created_at])
+            next unless asked && at - asked < CATCH_UP
+
+            sent ||= @store.sent_keys
+            attention = Attention.for(nil, summary)
+            next if attention.nil? || sent.key?(attention.key)
+
+            Log.info(:web, "push_catch_up", kind: attention.reason)
+            enqueue_show(attention, summary)
+          end
+        end
+
+        def asked_at(text)
+          text.is_a?(String) ? Time.iso8601(text) : nil
+        rescue ArgumentError
+          nil
+        end
+
         def enqueue_show(attention, summary)
           title, body = Attention.text(summary, attention.reason)
           @queue << Show.new(attention: attention, title: title, body: body, at: @now.call)
@@ -149,7 +208,7 @@ module Samagotchi
 
         def run
           loop do
-            due = @pending.values.map { |show| due_at(show) }.min
+            due = (@pending.values.map { |show| due_at(show) } + @retries.values.map(&:at)).min
             wait = due && [due - @now.call, 0].max
             message = @queue.pop(timeout: wait)
             break if message == :stop
@@ -175,16 +234,70 @@ module Samagotchi
         def flush
           now = @now.call
           due = @pending.values.select { |show| due_at(show) <= now }
-          return if due.empty?
+          retries = @retries.values.select { |again| again.at <= now }
+          return if due.empty? && retries.empty?
 
           due.each { |show| @pending.delete(show.attention.key) }
+          retries.each { |again| @retries.delete([again.show.attention.key, again.sub_id]) }
           open = @mutex.synchronize { Attention.open_keys(@by_id) }
-          due.each do |show|
-            key = show.attention.key
-            next unless open.include?(key)
+          due.each { |show| send_show(show, open) if still_due?(show, open) }
+          retries.each { |again| send_retry(again, open) if still_due?(again.show, open) }
+        end
+
+        # A waiting show while its key is open; a failed or done turn's as
+        # is (nothing to answer).
+        def still_due?(show, open) = !Attention.waiting?(show.attention.reason) || open.include?(show.attention.key)
+
+        # A due show to its devices, unless a page is in front (the in-tab
+        # notification and badge have it) or the hour's cap is reached:
+        # either way the key is handled, never pushed later.
+        def send_show(show, open)
+          return if @refused
 
-            deliver(show_payload(show, open), kind: show.attention.reason)
+          subs = targets(show.attention.reason)
+          return if subs.empty?
+
+          key = show.attention.key
+          if @presence&.present?
+            Log.info(:web, "push_skipped", reason: "present", kind: show.attention.reason)
+            return handled(key)
           end
+          return handled(key) if capped?(show.attention.reason)
+
+          @shown << @now.call
+          handled(key) if deliver(subs, show_payload(show, open), show)
+        end
+
+        # The retry of one device's show: to that device, if it is still
+        # there; not counted against the cap again.
+        def send_retry(again, open)
+          return if @refused
+
+          sub = @store.for_origin(@origin).find { |candidate| candidate.id == again.sub_id }
+          return unless sub
+
+          handled(again.show.attention.key) if deliver([sub], show_payload(again.show, open), again.show, final: true)
+        end
+
+        # Over CAP shows in the last CAP_WINDOW: one warning per window.
+        def capped?(kind)
+          at = @now.call
+          @shown.shift while @shown.any? && at - @shown.first >= CAP_WINDOW
+          return false if @shown.size < CAP
+
+          if @capped_warned_at.nil? || at - @capped_warned_at >= CAP_WINDOW
+            @capped_warned_at = at
+            Log.warn(:web, "push_capped", cap: CAP, kind: kind,
+                                          echo: "[chi web] #{CAP} pushes in the last hour: holding the rest back")
+          end
+          true
+        end
+
+        # In sent.json: a restart's catch-up skips it.
+        def handled(key)
+          @store.mark_sent(key)
+        rescue SystemCallError => e
+          Log.warn(:web, "push_sent_unwritten", error: e.class.name)
         end
 
         def show_payload(show, open)
@@ -194,18 +307,37 @@ module Samagotchi
           JSON.generate(with_open).bytesize <= OPEN_LIMIT ? with_open : payload
         end
 
-        # @param kind [String] the reason, for the log line
+        # @param show [Show] its reason: the TTL and urgency, the log
+        #   line's kind
+        # @param final [Boolean] this is the one retry: a failure is final
         # @return [Boolean] whether any device took it
-        def deliver(payload, kind:)
-          return false if @refused
-
-          @store.for_origin(@origin).map do |sub|
-            result = @client.deliver(sub, payload, ttl: SHOW_TTL, urgency: "high")
-            record(sub, result, kind)
+        def deliver(subs, payload, show, final: false)
+          reason = show.attention.reason
+          waiting = Attention.waiting?(reason)
+          subs.map do |sub|
+            result = @client.deliver(sub, payload, ttl: waiting ? SHOW_TTL : EVENT_TTL, urgency: waiting ? "high" : "normal")
+            if result.retry_after && !final
+              retry_later(show, sub, result)
+              next false
+            end
+            record(sub, result, reason)
             result.ok?
           end.any?
         end
 
+        def retry_later(show, sub, result)
+          Log.info(:web, "push_retry", device: sub.id, code: result.code, ms: result.ms, kind: show.attention.reason,
+                                       after: result.retry_after)
+          @retries[[show.attention.key, sub.id]] = Retry.new(show: show, sub_id: sub.id, at: @now.call + result.retry_after)
+        end
+
+        # This origin's devices; a done turn only to those whose prefs ask
+        # for it (off by default).
+        def targets(reason)
+          subs = @store.for_origin(@origin)
+          reason == "done" ? subs.select(&:done?) : subs
+        end
+
         def record(sub, result, kind)
           fields = { device: sub.id, code: result.code, ms: result.ms, kind: kind }
           case result.status

data/lib/samagotchi/web/push/presence.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  module Web
+    module Push
+      # Whether the owner is at a chi web page now (the plan's D3: no push
+      # while they look): each page reports {page, front} (POST
+      # /api/push/presence; front = visible, focused and touched in the last
+      # 2 min) when that changes and every 30 s while front. The iPhone's
+      # service worker can't see the app in front, so this is decided here.
+      # In memory only (a restart forgets it: a page reports again within
+      # 30 s), shared by the route and the Notifier through Push::Runtime.
+      class Presence
+        # A front report counts this long: a page that stopped reporting (a
+        # closed laptop, a lost network) quiets the phone no longer.
+        TTL = 45.0
+        # Pages remembered (one per page load): the oldest report goes.
+        MAX_PAGES = 64
+        PAGE_MAX = 64
+
+        Report = Data.define(:front, :at)
+
+        # @param now [#call] monotonic seconds (specs move it)
+        def initialize(now: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
+          @now = now
+          @mutex = Mutex.new
+          @pages = {} # page id → Report, oldest first
+        end
+
+        # A page's report: +page+ its id for this load, +front+ whether the
+        # user is at it.
+        def report(page, front)
+          @mutex.synchronize do
+            @pages.delete(page)
+            @pages[page] = Report.new(front: front == true, at: @now.call)
+            @pages.shift while @pages.size > MAX_PAGES
+          end
+          nil
+        end
+
+        # Some page is in front, reported in the last TTL seconds.
+        def present?
+          at = @now.call
+          @mutex.synchronize { @pages.each_value.any? { |r| r.front && at - r.at < TTL } }
+        end
+
+        # A report's body as the page sends it: {page: id, front: bool}.
+        # @return [Array(String, Boolean), nil] nil when it isn't one
+        def self.parse(body)
+          return nil unless body.is_a?(Hash)
+
+          page, front = body.values_at("page", "front")
+          return nil unless page.is_a?(String) && !page.empty? && page.bytesize <= PAGE_MAX && [true, false].include?(front)
+
+          [page, front]
+        end
+      end
+    end
+  end
+end

data/lib/samagotchi/web/push/store.rb

@@ -8,6 +8,7 @@ require "time"
 require "uri"
 require_relative "crypto"
 require_relative "../private_files"
+require_relative "../../log"
 require_relative "../../atomic_file"
 require_relative "../../session"
 
@@ -16,8 +17,10 @@ module Samagotchi
     module Push
       # This machine's Web Push state, in $XDG_STATE_HOME/samagotchi/web-push/
       # (next to web-token and web-grants/; a 0700 folder, 0600 files, never
-      # in config.yml): vapid.pem, chi web's one VAPID key, and
-      # subscriptions.json, the devices that turned the bell on. A
+      # in config.yml): vapid.pem, chi web's one VAPID key,
+      # subscriptions.json, the devices that turned the bell on, and
+      # sent.json, the attention keys already handled (a restart pushes
+      # none of them again). A
       # subscription holds no personal data (an opaque endpoint and two
       # keys); the endpoint and keys never leave this store but for the push
       # itself: what the page and the log show is Sub#public_h (the short
@@ -29,7 +32,11 @@ module Samagotchi
         DIR = "web-push"
         KEY_FILE = "vapid.pem"
         SUBS_FILE = "subscriptions.json"
+        SENT_FILE = "sent.json"
         LOCK = "store.lock"
+        # A handled key is kept this long (a restart catches up questions
+        # under an hour old).
+        SENT_KEEP = 24 * 3600
 
         # The push services a subscription's endpoint may name: the
         # browsers' (Apple, Google, Mozilla, Microsoft). chi web POSTs to
@@ -87,9 +94,12 @@ module Samagotchi
           # Never the endpoint or the keys: what the page, the CLI and the log show.
           def public_h
             { id: id, label: label, origin: origin, created_at: created_at, last_ok_at: last_ok_at,
-              last_error: last_error }
+              last_error: last_error, prefs: { done: done? } }
           end
 
+          # The device wants a push for a long turn done (off by default).
+          def done? = prefs["done"] == true
+
           def inspect = "#<Sub #{id} #{label.inspect}>"
           alias_method :to_s, :inspect
         end
@@ -101,6 +111,7 @@ module Samagotchi
         end
 
         def self.short_id(endpoint) = Digest::SHA256.hexdigest(endpoint.to_s)[0, 8]
+        def self.short_id?(text) = text.is_a?(String) && text.match?(/\A[0-9a-f]{8}\z/)
 
         attr_reader :dir
 
@@ -113,6 +124,7 @@ module Samagotchi
           @clock = clock
           @key_mutex = Mutex.new
           @key = nil
+          @sent_corrupt_logged = false
         end
 
         # Never the key.
@@ -121,11 +133,12 @@ module Samagotchi
 
         def key_path = File.join(@dir, KEY_FILE)
         def subs_path = File.join(@dir, SUBS_FILE)
+        def sent_path = File.join(@dir, SENT_FILE)
 
         # Refuses a store others could read (PrivateFiles).
         # @raise [Insecure]
         def check_permissions!
-          PrivateFiles.check!(@dir, [key_path, subs_path], holds: "chi's push key and devices", error: Insecure)
+          PrivateFiles.check!(@dir, [key_path, subs_path, sent_path], holds: "chi's push key and devices", error: Insecure)
         end
 
         # chi web's VAPID key: vapid.pem, made (0600) the first time.
@@ -193,6 +206,21 @@ module Samagotchi
           end
         end
 
+        # Sets the device's prefs (+done+: a push for a long turn done).
+        # @param origin [String, nil] only a device subscribed there
+        # @return [Sub, nil] the device as it is now, nil when there is none
+        def set_prefs(id, done:, origin: nil)
+          update do |subs|
+            found = nil
+            subs = subs.map do |sub|
+              next sub unless sub.id == id && (origin.nil? || sub.origin == origin)
+
+              found = sub.with(prefs: sub.prefs.merge("done" => done == true))
+            end
+            [subs, found]
+          end
+        end
+
         # Records a delivery: +ok+ true stamps last_ok_at (and clears the
         # error), else +error+ (a short word: "410", "timeout") is kept.
         def mark(id, ok: false, error: nil)
@@ -206,10 +234,50 @@ module Samagotchi
           end
         end
 
+        # The attention keys already handled (pushed to a device, or
+        # skipped while the owner looked, or over the cap): key → iso8601
+        # time. None when sent.json is missing; one that doesn't read is
+        # logged once and read as none (the next #mark_sent rewrites it:
+        # it only spares a restart's repeat).
+        # @return [Hash{String => String}]
+        def sent_keys = read_sent
+
+        # Records +key+ as handled now; keys older than SENT_KEEP go.
+        def mark_sent(key)
+          locked do
+            at = now
+            keys = read_sent.reject { |_, time| stale_sent?(time, at) }
+            keys[key.to_s] = stamp(at)
+            body = JSON.pretty_generate({ "version" => 1, "keys" => keys })
+            AtomicFile.write(sent_path, "#{body}\n", perm: 0o600)
+          end
+          nil
+        end
+
         private
 
         def now = @clock.call
 
+        def read_sent
+          data = JSON.parse(File.read(sent_path))
+          keys = data["keys"] if data.is_a?(Hash)
+          raise JSON::ParserError, "no keys" unless keys.is_a?(Hash) && keys.all? { |k, v| k.is_a?(String) && v.is_a?(String) }
+
+          keys
+        rescue Errno::ENOENT
+          {}
+        rescue JSON::ParserError
+          Log.warn(:web, "push_sent_corrupt", path: sent_path) unless @sent_corrupt_logged
+          @sent_corrupt_logged = true
+          {}
+        end
+
+        def stale_sent?(time, at)
+          at - Time.iso8601(time) > SENT_KEEP
+        rescue ArgumentError
+          true
+        end
+
         def stamp(time) = time.utc.iso8601
 
         # @return [Array(String, String, String)] endpoint, p256dh, auth

data/lib/samagotchi/web/push.rb

@@ -4,13 +4,14 @@ require_relative "push/crypto"
 require_relative "push/store"
 require_relative "push/client"
 require_relative "push/attention"
+require_relative "push/presence"
 require_relative "push/notifier"
 require_relative "../config"
 
 module Samagotchi
   module Web
     # Web Push: chi web reaches the owner's phone (a Home Screen app that
-    # turned the bell on) when a session waits on an approval or a question.
+    # turned the bell on) when a session needs the user or a turn failed.
     # It needs an https public origin (web.public_url or chi web --tunnel
     # tailscale) and web.push.enabled (on by default); without a subscribed
     # device it does nothing. See docs/configuration.md (Phone
@@ -21,9 +22,12 @@ module Samagotchi
       class Refused < StandardError; end
 
       # What chi web's push routes and its Notifier share for one run: the
-      # store, the client that signs with its key, and the public origin
-      # the devices subscribe on.
-      Runtime = Data.define(:store, :client, :origin)
+      # store, the client that signs with its key, the public origin the
+      # devices subscribe on, and the pages' presence (the route writes it,
+      # the Notifier reads it).
+      Runtime = Data.define(:store, :client, :origin, :presence) do
+        def initialize(presence: Presence.new, **) = super
+      end
 
       module_function
 

data/lib/samagotchi/web/push_routes.rb

@@ -7,7 +7,8 @@ module Samagotchi
   module Web
     # The owner's Web Push routes (App::ROUTES, all :owner rows: a
     # participant gets no pushes): what the page's bell asks (GET /api/push),
-    # subscribing this device and unsubscribing it, and a test push.
+    # subscribing this device and unsubscribing it, a test push, and the
+    # pages' presence (no push while the owner looks at one).
     # Included in App: its helpers (json_response, error_response,
     # parse_json, request_body) and @push (a Push::Runtime, nil when push is
     # off: no https public_url, or web.push.enabled false) answer. See
@@ -17,16 +18,22 @@ module Samagotchi
 
       private
 
-      # {enabled, public_key, origin, this}: +this+ is the device whose
-      # endpoint the page sends as ?endpoint= (its pushManager's), nil when
-      # this store doesn't have it for this origin.
+      # {enabled, public_key, origin, this, devices, stale}: +this+ is the
+      # device whose endpoint the page sends as ?endpoint= (its
+      # pushManager's), nil when this store doesn't have it for this
+      # origin; +devices+ this origin's (Sub#public_h, +this+ marked),
+      # +stale+ how many were made on another origin (never sent to).
       def handle_push_info(req)
         return json_response(200, { enabled: false, public_key: nil, origin: nil, this: nil }) unless @push
 
         endpoint = req.params["endpoint"].to_s
-        this = endpoint.empty? ? nil : @push.store.for_origin(@push.origin).find { |sub| sub.endpoint == endpoint }
+        subs = @push.store.subscriptions
+        mine = subs.select { |sub| sub.origin == @push.origin }
+        this = endpoint.empty? ? nil : mine.find { |sub| sub.endpoint == endpoint }
         json_response(200, { enabled: true, public_key: Push::Crypto.public_key_b64(@push.store.vapid_key),
-                             origin: @push.origin, this: this && { id: this.id, label: this.label } })
+                             origin: @push.origin, this: this && { id: this.id, label: this.label },
+                             devices: mine.map { |sub| sub.public_h.merge(this: sub.equal?(this)) },
+                             stale: subs.size - mine.size })
       end
 
       # {subscription: {endpoint, keys: {p256dh, auth}}, replaces?: id} →
@@ -48,6 +55,24 @@ module Samagotchi
         error_response(400, "invalid_subscription", e.message)
       end
 
+      # PATCH …/subscriptions/ID {prefs: {done: true|false}} → 200 the
+      # device (Sub#public_h): whether it gets a push for a long turn done.
+      def handle_push_prefs(req, id)
+        return push_off unless @push
+
+        body = push_body(req)
+        prefs = body["prefs"] if body.is_a?(Hash)
+        unless prefs.is_a?(Hash) && prefs.keys == ["done"] && [true, false].include?(prefs["done"])
+          return error_response(400, "invalid_prefs", "give {prefs: {done: true|false}}")
+        end
+
+        sub = Push::Store.short_id?(id) && @push.store.set_prefs(id, done: prefs["done"], origin: @push.origin)
+        return error_response(404, "unknown_device", "no device #{id[0, 16]} pushes from this origin") unless sub
+
+        Log.info(:web, "push_prefs", device: sub.id, done: sub.done?)
+        json_response(200, sub.public_h)
+      end
+
       # {endpoint} → 204: this device's bell turned off.
       def handle_push_unsubscribe(req)
         return push_off unless @push
@@ -80,6 +105,17 @@ module Samagotchi
         json_response(200, { devices: results })
       end
 
+      # {page, front} → 204: whether the user is at this page (visible,
+      # focused, touched lately; notifications.js reports it). Also with
+      # push off: a desk tab has nothing to be told.
+      def handle_push_presence(req)
+        page, front = Push::Presence.parse(push_body(req))
+        return error_response(400, "invalid_presence", "give {page: id, front: true|false}") unless page
+
+        @push&.presence&.report(page, front)
+        [204, { "Cache-Control" => "no-store" }, []]
+      end
+
       def push_off
         error_response(409, "push_off", "push needs an https public URL (chi web --tunnel tailscale, or web.public_url) " \
                                         "and web.push.enabled")

data/lib/samagotchi/web/server.rb

@@ -219,7 +219,8 @@ module Samagotchi
           # The Notifier seeds from the hub's snapshot, which is empty before
           # a scan: one now, so what is already open never pushes.
           hub.scan
-          notifier = Push::Notifier.new(store: push.store, client: push.client, origin: push.origin).start(hub)
+          notifier = Push::Notifier.new(store: push.store, client: push.client, origin: push.origin,
+                                        presence: push.presence).start(hub)
           Samagotchi::Log.info(:web, "push", devices: push.store.for_origin(push.origin).size)
         end
         hub.start

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.111.1
+  version: 0.112.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -843,6 +843,7 @@ files:
 - lib/samagotchi/web/push/client.rb
 - lib/samagotchi/web/push/crypto.rb
 - lib/samagotchi/web/push/notifier.rb
+- lib/samagotchi/web/push/presence.rb
 - lib/samagotchi/web/push/store.rb
 - lib/samagotchi/web/push_routes.rb
 - lib/samagotchi/web/qr.rb