samagotchi 0.111.0 → 0.112.0

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.
@@ -158,20 +171,30 @@ module Samagotchi
         # Adds the subscription a page's pushManager.subscribe gave (its
         # JSON: endpoint, keys {p256dh, auth}); the same endpoint again
         # replaces the old entry (a device subscribing again).
+        # +replaces+ is the short id this device had before (the page keeps
+        # it): that entry on +origin+ goes too, before the cap is counted,
+        # since the device has a new endpoint and the old one is dead (iOS
+        # revokes silently: its push service keeps answering 201). Yields
+        # the entry dropped that way, if any; an unknown id is ignored.
         # @return [Sub]
         # @raise [Invalid] one message per refusal
-        def add(subscription, origin:, label:)
+        def add(subscription, origin:, label:, replaces: nil)
           endpoint, p256dh, auth = validate(subscription)
           at = stamp(now)
           sub = Sub.new(id: Store.short_id(endpoint), endpoint: endpoint, p256dh: p256dh, auth: auth, origin: origin,
                         label: label.to_s[0, LABEL_MAX], created_at: at, last_ok_at: nil, last_error: nil,
                         prefs: { "done" => false })
-          update do |subs|
+          replaced = nil
+          added = update do |subs|
             kept = subs.reject { |old| old.endpoint == endpoint }
+            replaced = kept.find { |old| old.id == replaces && old.origin == origin } if replaces.is_a?(String)
+            kept -= [replaced] if replaced
             raise Invalid, "chi web already pushes to #{MAX_SUBS} devices: turn the bell off on one first" if kept.size >= MAX_SUBS
 
             [kept + [sub], sub]
           end
+          yield replaced if replaced && block_given?
+          added
         end
 
         # Removes the subscription with this short id or endpoint.
@@ -183,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)
@@ -196,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,32 +18,61 @@ 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}}} → 201 {id, label}.
+      # {subscription: {endpoint, keys: {p256dh, auth}}, replaces?: id} →
+      # 201 {id, label}. +replaces+ is the id this device was given before
+      # (the page keeps it): that entry goes (Store#add).
       def handle_push_subscribe(req)
         return push_off unless @push
 
         body = push_body(req)
         return error_response(400, "invalid_json", "invalid JSON body") unless body.is_a?(Hash)
 
-        sub = @push.store.add(body["subscription"], origin: @push.origin, label: device_label(req))
+        sub = @push.store.add(body["subscription"], origin: @push.origin, label: device_label(req),
+                                                    replaces: body["replaces"]) do |old|
+          Log.info(:web, "push_replaced", device: old.id)
+        end
         Log.info(:web, "push_subscribed", device: sub.id)
         json_response(201, { id: sub.id, label: sub.label })
       rescue Push::Store::Invalid => e
         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
@@ -75,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

data/lib/samagotchi/web/session_access_routes.rb

@@ -171,13 +171,16 @@ module Samagotchi
       # (SessionAccess::Local#wait_reply). Body: cursor, baseline
       # ({messages, question_id, last_turn}, as the prepare route gave it),
       # turn, queued, ended_before, owner_grace (seconds, null: wait for
-      # whatever wakes a worker), timeout (seconds, capped). 200: the
-      # ReplyWait::Result's fields (status: done, waiting_for_answer,
-      # no_reply, error, stopped, timeout or worker_gone; text, file,
-      # question, outcome, …; never the Session) and parent_strategy, what
-      # a parent may pick on the session's questions here
-      # (ParentReport.strategy_for). A timeout status: ask again. 503
-      # server_stopping when chi web stops mid-wait.
+      # whatever wakes a worker), timeout (seconds, capped), running_look
+      # (the last timeout's, as it came). 200: the ReplyWait::Result's
+      # fields (status: done, waiting_for_answer, no_reply, error, stopped,
+      # timeout or worker_gone; text, file, question, outcome, …; never the
+      # Session) and parent_strategy, what a parent may pick on the
+      # session's questions here (ParentReport.strategy_for). A timeout
+      # status: ask again, with its running_look ({last_end, claimed}, or
+      # null: the running turn this slice saw, so a settle between two
+      # slices still ends the wait). 503 server_stopping when chi web stops
+      # mid-wait.
       def handle_wait(req, id)
         body = body_hash(req) or return error_response(400, "invalid_json", "invalid JSON body")
         options, error = wait_options(body)
@@ -209,8 +212,15 @@ module Samagotchi
         end
 
         timeout = [numbers["timeout"] || WAIT_MAX_SECONDS, WAIT_MAX_SECONDS].min
+        look = body["running_look"]
+        running_look = look.nil? ? nil : ReplyWait::RunningLook.from_h(look)
+        if !look.nil? && running_look.nil?
+          return [nil, error_response(400, "invalid_wait", "running_look is {last_end, claimed: [file names]}")]
+        end
+
         [{ cursor: strings["cursor"], turn: strings["turn"], baseline: baseline, timeout: timeout,
-           owner_grace: numbers["owner_grace"], queued: body["queued"] == true, ended_before: body["ended_before"] == true }, nil]
+           owner_grace: numbers["owner_grace"], queued: body["queued"] == true, ended_before: body["ended_before"] == true,
+           running_look: running_look }, nil]
       end
 
       def wait_baseline(raw)
@@ -231,6 +241,7 @@ module Samagotchi
         RESULT_FIELDS.each { |key| json[key] = result[key] }
         json[:text] = json[:text]&.dup&.force_encoding(Encoding::UTF_8)&.scrub
         json[:question] = result.question&.to_file
+        json[:running_look] = result.running_look&.to_h
         json[:parent_strategy] = strategy_json(strategy)
         json
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.111.0
+  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