samagotchi 0.111.1 → 0.113.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.
@@ -150,6 +163,10 @@ module Samagotchi
           []
         end
 
+        # As #subscriptions, but a corrupt file raises (chi web push says so).
+        # @raise [Corrupt]
+        def subscriptions! = read
+
         # The subscriptions for +origin+ (the ones chi web sends to now).
         def for_origin(origin) = subscriptions.select { |sub| sub.origin == origin }
 
@@ -193,6 +210,31 @@ module Samagotchi
           end
         end
 
+        # Removes the device with this short id, only one subscribed on
+        # +origin+ (nil: any; chi web push rm).
+        # @return [Sub, nil] the one removed
+        def remove_device(id, origin: nil)
+          update do |subs|
+            gone = subs.find { |sub| sub.id == id && (origin.nil? || sub.origin == origin) }
+            [subs - [gone], gone]
+          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 +248,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,17 @@ 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
+
+      # The test push (POST /api/push/test, chi web push test): no badge
+      # (it would clear the app's) and no open list (no cleanup).
+      TEST_PAYLOAD = { v: 1, kind: "show", tag: "chi:test", title: "chi", body: "test notification", url: "/" }.freeze
+      TEST_TTL = 600
 
       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,37 @@ 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 unknown_device(id) unless sub
+
+        Log.info(:web, "push_prefs", device: sub.id, done: sub.done?)
+        json_response(200, sub.public_h)
+      end
+
+      # DELETE …/subscriptions/ID → 204: the devices list's Remove for
+      # another device (this device's row turns the bell off instead, so
+      # the page and the store agree).
+      def handle_push_remove(_req, id)
+        return push_off unless @push
+
+        sub = Push::Store.short_id?(id) && @push.store.remove_device(id, origin: @push.origin)
+        return unknown_device(id) unless sub
+
+        Log.info(:web, "push_removed", device: sub.id)
+        [204, { "Cache-Control" => "no-store" }, []]
+      end
+
       # {endpoint} → 204: this device's bell turned off.
       def handle_push_unsubscribe(req)
         return push_off unless @push
@@ -70,9 +108,8 @@ module Samagotchi
         endpoint = body["endpoint"] if body.is_a?(Hash)
         subs = @push.store.for_origin(@push.origin)
         subs = subs.select { |sub| sub.endpoint == endpoint } if endpoint.is_a?(String) && !endpoint.empty?
-        payload = { v: 1, kind: "show", tag: "chi:test", title: "chi", body: "test notification", url: "/" }
         results = subs.map do |sub|
-          result = @push.client.deliver(sub, payload, ttl: 600, urgency: "high")
+          result = @push.client.deliver(sub, Push::TEST_PAYLOAD, ttl: Push::TEST_TTL, urgency: "high")
           Log.info(:web, "push_test", device: sub.id, code: result.code, ms: result.ms)
           @push.store.remove(sub.id) if result.status == :gone
           { id: sub.id, label: sub.label, status: result.status.to_s, code: result.code, ms: result.ms }
@@ -80,6 +117,19 @@ 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 unknown_device(id) = error_response(404, "unknown_device", "no device #{id[0, 16]} pushes from this origin")
+
       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

@@ -130,7 +130,9 @@ module Samagotchi
                       annotate_presets: annotate_presets, editor: editor, lan: lan, working_set: working_set,
                       public_url: public_url }
           started = if plan
-                      with_tunnel(provider, plan) { start(**options, public_notes: provider.start_lines(plan)) }
+                      with_tunnel(provider, plan) do |up|
+                        start(**options, public_notes: provider.start_lines(plan), on_bound: up)
+                      end
                     else
                       start(**options)
                     end
@@ -147,25 +149,43 @@ module Samagotchi
       end
 
       # The tunnel on while the block runs (the server), off after it
-      # whatever ends it (Ctrl-C, SIGTERM, SIGHUP, a port taken), and only
-      # once #up succeeded: a refusal before it, or a failed #up, turns off
-      # nothing (a live tunnel of another chi web stays).
+      # whatever ends it (Ctrl-C, SIGTERM, SIGHUP), once #up may have taken
+      # effect: a refusal before it turns off nothing (a live tunnel of
+      # another chi web stays). The block gets #up to call once the port is
+      # bound (start's on_bound), so Serve never forwards the tailnet to a
+      # listener that took the port first. A signal during #up waits for it
+      # (its command runs in its own process group, and Serve keeps what it
+      # set even if chi stopped waiting), so it can't land between the serve
+      # going on and the teardown being due; #up is bounded by its timeout.
       def self.with_tunnel(provider, plan)
-        provider.up(plan)
-        upped = true
-        yield
+        attempted = false
+        yield(lambda do
+          Thread.handle_interrupt(SignalException => :never) do
+            attempted = true
+            provider.up(plan)
+          end
+        end)
       ensure
-        tunnel_down(provider, plan) if upped
+        tunnel_down(provider, plan) if attempted
       end
 
       # The tunnel's teardown, before any line (a hung-up terminal can't
       # write): a failure is one warning line, never a crash or another exit
-      # status, and a second Ctrl-C during it only cuts it short.
+      # status. A second Ctrl-C (SIGTERM, SIGHUP) during it waits for it
+      # (bounded by its commands' timeouts) and is then dropped: the run
+      # already ends the way the first signal ends it.
       def self.tunnel_down(provider, plan)
-        line = begin
-          provider.down_line(plan, provider.down(plan))
-        rescue Tunnel::Refused, SignalException => e
-          provider.down_warning(plan, e)
+        line = nil
+        begin
+          Thread.handle_interrupt(SignalException => :never) do
+            line = begin
+              provider.down_line(plan, provider.down(plan))
+            rescue Tunnel::Refused => e
+              provider.down_warning(plan, e)
+            end
+          end
+        rescue SignalException
+          nil
         end
         say(line) if line
       end
@@ -187,11 +207,14 @@ module Samagotchi
       #   (web.public_url, or --tunnel's): every request needs the access token
       # @param public_notes [Array<String>] lines after the proxied link's
       #   (the tunnel's)
+      # @param on_bound [#call, nil] run once the port is bound, before any
+      #   line (the tunnel's #up); what it raises ends the run
       # @return [Boolean] false when the port was taken (said so on stderr)
       def self.start(port: nil, host: nil, url: nil, open_browser: false, state_dir: nil, manager: nil, markdown: false,
                      view: Config::BY_KEY["web.view"].default, annotate_presets: Config::BY_KEY["web.annotate_presets"].default, hub: nil, lan: nil,
                      editor: Config::BY_KEY["web.editor"].default, token_path: Token.path,
-                     working_set: Config::BY_KEY["web.working_set"].default, public_url: nil, public_notes: [])
+                     working_set: Config::BY_KEY["web.working_set"].default, public_url: nil, public_notes: [],
+                     on_bound: nil)
         config_restart_unsubscribe = ConfigFile.watch_restart_settings!(process: :web) do |message|
           Samagotchi::Log.warn(:config, "restart_required", echo: "Warning: config: #{message}")
         end
@@ -219,14 +242,19 @@ 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
         # Said once the port is bound: a second chi web racing for it gets
         # the in-use line instead.
         running_path = Running.path(state_dir: state_dir)
+        webrick = nil
+        callback_unfinished = false
         started = lambda do
+          callback_unfinished = true
+          on_bound&.call
           record_running(running_path, port, public_url)
           puts "Chi Web on #{url} (public: #{File.expand_path("public", __dir__)})"
           puts lan_lines(ip: lan.ip, port: port, token: Token.read(token_path), others: lan.others, public: lan.public) if lan
@@ -243,12 +271,14 @@ module Samagotchi
               open_url(open_target)
             end
           end
+          callback_unfinished = false
         end
 
         # The event loops (GET /api/events) end once WEBrick leaves
         # :Running: it joins every request thread before run returns.
         Rackup::Handler::WEBrick.run(app, Host: host, Port: port, AccessLog: [], Logger: Log.new($stderr, WEBrick::Log::WARN),
                                           StartCallback: started) do |server|
+          webrick = server
           app.server_running = -> { server.status == :Running }
           listen_lan(server, lan, port) if lan
         end
@@ -260,6 +290,9 @@ module Samagotchi
         warn "Error: can't listen on #{lan.ip}:#{port} (#{e.message}); did the address change? Run chi web again"
         false
       ensure
+        # A start callback that raised (on_bound's refusal, a Ctrl-C) leaves
+        # WEBrick :Running with its sockets open.
+        webrick&.listeners&.each { |socket| socket.close unless socket.closed? } if callback_unfinished
         Running.clear(path: running_path) if running_path
         config_restart_unsubscribe&.call
         notifier&.stop

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.111.1
+  version: 0.113.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -503,6 +503,7 @@ files:
 - lib/samagotchi/prompt_note.rb
 - lib/samagotchi/prompt_warmup.rb
 - lib/samagotchi/proxy_trace.rb
+- lib/samagotchi/push_command.rb
 - lib/samagotchi/question_answer.rb
 - lib/samagotchi/question_asked.rb
 - lib/samagotchi/question_desk.rb
@@ -780,6 +781,7 @@ files:
 - lib/samagotchi/web/public/plain_line.js
 - lib/samagotchi/web/public/prompt_history.js
 - lib/samagotchi/web/public/push.js
+- lib/samagotchi/web/public/push_devices.js
 - lib/samagotchi/web/public/question_card.js
 - lib/samagotchi/web/public/question_cards.js
 - lib/samagotchi/web/public/read_view.js
@@ -843,6 +845,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