samagotchi 0.122.0 → 0.124.0

data/lib/samagotchi/web/update_check.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "time"
+require_relative "../atomic_file"
+require_relative "../config"
+require_relative "../gem_update"
+require_relative "../installed_gem"
+require_relative "../installed_versions"
+require_relative "../log"
+require_relative "../paths"
+require_relative "../version"
+
+module Samagotchi
+  module Web
+    # Checks RubyGems away from the session hub's Monitor and publishes the
+    # result as chi web's version state. The state file preserves cooldowns
+    # and version-level notice deduplication across chi web restarts.
+    class UpdateCheck
+      FIRST_CHECK = 30
+      # A failed check (offline at start) tries again this soon, not a whole check_hours later.
+      RETRY = 3600
+
+      def initialize(hub:, enabled: Config.get("update.notify") == "on",
+                     check_hours: Config.get("update.check_hours"),
+                     min_age_hours: Config.get("update.min_age_hours"),
+                     fetcher: -> { GemUpdate.new.releases }, clock: -> { Time.now },
+                     state_file: File.join(Paths.state_dir, "update_check.json"),
+                     gem_spec: InstalledGem.spec, bundler: nil, gem_dir: Gem.dir,
+                     installed_versions: InstalledVersions.new)
+        @hub = hub
+        @enabled = enabled
+        @check_seconds = [check_hours.to_i, 1].max * 3600
+        @min_age_seconds = [min_age_hours.to_i, 0].max * 3600
+        @fetcher = fetcher
+        @clock = clock
+        @state_file = state_file
+        @gem_spec = gem_spec
+        @bundler = bundler.nil? ? (defined?(::Bundler) || !ENV["BUNDLE_GEMFILE"].to_s.empty?) : bundler
+        @gem_dir = gem_dir
+        @installed_versions = installed_versions
+        @state = load_state
+        @blocked = blocked_reason
+        @checking = Mutex.new
+        @wakeup = Queue.new
+        @thread = nil
+        @stopped = false
+        @failed = false
+      end
+
+      def start
+        return self unless @enabled
+        return self if @thread&.alive?
+
+        @stopped = false
+        @hub.update_available(available: still_newer(@state[:available]), blocked: @blocked)
+        @thread = Thread.new { run_loop }
+        self
+      end
+
+      def stop
+        @stopped = true
+        @wakeup << :stop
+        thread = @thread
+        @thread = nil
+        thread&.join(11.0) # a fetch may take its 5 s open + 5 s read
+        nil
+      end
+
+      # @return [Boolean] whether a check was due and completed
+      def check
+        return false unless @enabled
+
+        @checking.synchronize do
+          now = @clock.call
+          return false unless due?(now)
+
+          releases = @fetcher.call
+          available = available_release(releases, now)&.version
+          notified = @state[:notified]
+          notify = available && !notified.include?(available)
+          next_state = { checked_at: now.iso8601, available: available,
+                         notified: notify ? (notified + [available]) : notified }
+          persist(next_state)
+          @hub.update_available(available: available, blocked: @blocked, notify: !!notify)
+          @failed = false
+          true
+        rescue StandardError => e
+          Log.warn(:web, "update_check_failed", error: e.class.name, msg: e.message)
+          @failed = true
+          false
+        end
+      end
+
+      # Why chi web can't install a gem here (the notice's and POST /api/update's
+      # one answer), or nil: a source checkout, a Bundler run, a gem dir it
+      # can't write.
+      # @return [String, nil]
+      def self.blocked_reason(gem_spec: InstalledGem.spec, bundler: nil, gem_dir: Gem.dir)
+        bundler = defined?(::Bundler) || !ENV["BUNDLE_GEMFILE"].to_s.empty? if bundler.nil?
+        return "checkout" unless gem_spec
+        return "bundler" if bundler
+        return "gem_dir_not_writable" unless File.writable?(gem_dir)
+
+        nil
+      end
+
+      private
+
+      def run_loop
+        wait = FIRST_CHECK
+        until @stopped
+          break if @wakeup.pop(timeout: wait) == :stop
+
+          check
+          wait = next_wait(@clock.call)
+        end
+      rescue StandardError => e
+        Log.warn(:web, "update_check_failed", error: e.class.name, msg: e.message)
+      end
+
+      # Until the check is due again (at least FIRST_CHECK), or RETRY after a failure.
+      def next_wait(now)
+        return [RETRY, @check_seconds].min if @failed
+
+        checked_at = parsed_time(@state[:checked_at])
+        return FIRST_CHECK unless checked_at
+
+        [checked_at + @check_seconds - now, FIRST_CHECK].max
+      end
+
+      def due?(now)
+        checked_at = parsed_time(@state[:checked_at])
+        checked_at.nil? || now >= checked_at + @check_seconds
+      end
+
+      def available_release(releases, now)
+        floor = version_floor
+        releases.select do |release|
+          version = Gem::Version.new(release.version)
+          !release.prerelease && version > floor && now - release.created_at >= @min_age_seconds
+        end.max_by { |release| Gem::Version.new(release.version) }
+      end
+
+      # The newest of this chi and the installed ones: a release counts only above it.
+      def version_floor
+        [VERSION, @installed_versions.newest].compact.select { |version| Gem::Version.correct?(version) }
+                                             .map { |version| Gem::Version.new(version) }.max
+      end
+
+      # A saved answer the owner has since installed (or passed) is no longer available.
+      def still_newer(version)
+        version if version && Gem::Version.correct?(version) && Gem::Version.new(version) > version_floor
+      end
+
+      def blocked_reason = self.class.blocked_reason(gem_spec: @gem_spec, bundler: @bundler, gem_dir: @gem_dir)
+
+      def load_state
+        return { checked_at: nil, available: nil, notified: [] } unless File.file?(@state_file)
+
+        data = JSON.parse(File.read(@state_file))
+        {
+          checked_at: data["checked_at"],
+          available: data["available"],
+          notified: Array(data["notified"]).select { |version| version.is_a?(String) }
+        }
+      rescue JSON::ParserError, SystemCallError => e
+        Log.warn(:web, "update_check_failed", error: e.class.name, msg: e.message)
+        { checked_at: nil, available: nil, notified: [] }
+      end
+
+      def persist(state)
+        FileUtils.mkdir_p(File.dirname(@state_file))
+        AtomicFile.write(@state_file, JSON.generate(state), perm: 0o600)
+        @state = state
+      end
+
+      def parsed_time(value)
+        Time.iso8601(value) if value
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/samagotchi/worker.rb

@@ -386,6 +386,9 @@ module Samagotchi
       # the background, shown by the UIs; a turn waits only for the ones
       # that bring tools.
       @engine.start_init_tasks!
+      # Toolkit suggestion's on mode: System 1's question, asked once with a
+      # stand-in prompt so its prefix is cached before the first prompt.
+      @engine.warm_toolkit_suggestion!
       # Attached context's commands, in the background; a new text wakes
       # the loop to absorb it. Not activity: the idle exit stops it.
       @context_poller = ContextPoller.new(session_id: @session_id, state_dir: @state_dir,
@@ -564,6 +567,8 @@ module Samagotchi
       # The attached TUI and the web answer approvals; with none attached
       # one waits, like ask_user_question.
       engine.interface = :worker
+      # A pair turn stops mid-turn at its participant's cap.
+      engine.participant_stop = ->(author) { participant_turn_stop(author) }
       engine.guardrail_state_dir = @state_dir if @state_dir
       engine.session_state_dir = @state_dir if @state_dir
       engine
@@ -699,28 +704,61 @@ module Samagotchi
       entry = Participants.read(@session_id, state_dir: @state_dir).find { |e| Steer.author_for(e.id) == author }
       return "revoked" unless entry&.active?(Time.now)
 
-      cap = entry.cap.is_a?(Numeric) ? entry.cap.to_f : Web::Grants.default_cap
+      cap = participant_cap(entry)
       return nil if @engine.metrics.spend(author) < cap
 
-      cap_notice(author, entry.name, cap)
+      cap_notice(author, entry, cap)
       "cap_reached"
     end
 
+    # Why a participant's running pair turn stops (Engine#participant_stop,
+    # asked before each of its generations): their link ended (revoked,
+    # expired, the session archived) or their cap reached
+    # (#participant_refusal, which gives the owner the cap notice), else nil.
+    def participant_turn_stop(author)
+      reason = participant_refusal(author) or return nil
+
+      entry = Participants.read(@session_id, state_dir: @state_dir).find { |e| Steer.author_for(e.id) == author }
+      name = participant_label(author, entry&.name)
+      return format(REVOKED_STOP, name: name) if reason == "revoked"
+
+      format(CAP_STOP, name: name, cap: participant_cap(entry))
+    end
+
+    # A participant's cap in dollars: their own, else the config's.
+    def participant_cap(entry) = entry&.cap.is_a?(Numeric) ? entry.cap.to_f : Web::Grants.default_cap
+
+    # A participant's cleaned name, else their id.
+    def participant_label(author, name)
+      who = ParticipantName.clean(name)
+      who.empty? ? Steer.participant_id(author) : who
+    end
+
     # The owner's notice that a participant reached their cap: once per
     # participant and cap (a raised cap that is reached again says so again).
-    def cap_notice(author, name, cap)
+    # A pair participant's says turns (their turns act), a review one's
+    # comments.
+    def cap_notice(author, entry, cap)
       key = [author, cap]
       return if (@cap_noticed ||= Set.new).include?(key)
 
       @cap_noticed << key
       id = Steer.participant_id(author)
-      who = ParticipantName.clean(name)
-      @engine.announce(type: :hook_notice, hook: "participants", level: :warn, between_turns: true,
-                       text: format(CAP_NOTICE, name: who.empty? ? id : who, cap: cap, session: @session_id[0, 8], id: id))
+      text = ParticipantMode.for_turn(@session, entry) == ParticipantMode::PAIR ? PAIR_CAP_NOTICE : CAP_NOTICE
+      @engine.announce(type: :hook_notice, hook: Engine::PARTICIPANTS_HOOK, level: :warn, between_turns: true,
+                       text: format(text, name: participant_label(author, entry.name), cap: cap, session: @session_id[0, 8], id: id))
     end
 
     CAP_NOTICE = "%<name>s reached their $%<cap>.2f review cap: their comments are refused until you raise it " \
                  "(chi share cap %<session>s %<id>s AMOUNT)."
+    PAIR_CAP_NOTICE = "%<name>s reached their $%<cap>.2f cap: their turns stop and are refused until you raise it " \
+                      "(chi share cap %<session>s %<id>s AMOUNT)."
+    # The reason a pair turn stopped at its participant's cap (the turn's
+    # "stopped the turn: …" notice).
+    CAP_STOP = "%<name>s reached their $%<cap>.2f cap"
+    # The reason a pair turn stopped because its participant's link ended
+    # (revoked, expired, or the session archived).
+    REVOKED_STOP = "%<name>s's link was revoked or expired"
 
     # A participant's queued turn that may not start (#participant_refusal):
     # taken off the queue (:turn_dequeued, so every UI drops its bubble)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.122.0
+  version: 0.124.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -321,6 +321,7 @@ files:
 - lib/samagotchi/desktop/macos/Models.swift
 - lib/samagotchi/desktop/macos/Panel.swift
 - lib/samagotchi/desktop/macos/ProcessRunner.swift
+- lib/samagotchi/desktop/macos/Sessions.swift
 - lib/samagotchi/desktop/macos/Tmux.swift
 - lib/samagotchi/desktop_command.rb
 - lib/samagotchi/edit_preview.rb
@@ -348,6 +349,8 @@ files:
 - lib/samagotchi/guardrails/load_failures.rb
 - lib/samagotchi/guardrails/model_size.rb
 - lib/samagotchi/guardrails/outside.rb
+- lib/samagotchi/guardrails/pair_boundary.rb
+- lib/samagotchi/guardrails/pair_command.rb
 - lib/samagotchi/guardrails/parent_approvals.rb
 - lib/samagotchi/guardrails/parent_levels.rb
 - lib/samagotchi/guardrails/parent_policy.rb
@@ -855,12 +858,14 @@ files:
 - lib/samagotchi/web/public/token_fragment.js
 - lib/samagotchi/web/public/tokens.css
 - lib/samagotchi/web/public/toolkit_chip.js
+- lib/samagotchi/web/public/tools_overview.js
 - lib/samagotchi/web/public/turn_events.js
 - lib/samagotchi/web/public/turn_html.js
 - lib/samagotchi/web/public/turn_model.js
 - lib/samagotchi/web/public/turn_view.js
 - lib/samagotchi/web/public/unqueue.js
 - lib/samagotchi/web/public/update_notice.js
+- lib/samagotchi/web/public/update_sheet.js
 - lib/samagotchi/web/public/vendor/directive-helpers.js
 - lib/samagotchi/web/public/vendor/directive.js
 - lib/samagotchi/web/public/vendor/directives/repeat.js
@@ -891,6 +896,7 @@ files:
 - lib/samagotchi/web/token.rb
 - lib/samagotchi/web/tunnel.rb
 - lib/samagotchi/web/tunnel/tailscale.rb
+- lib/samagotchi/web/update_check.rb
 - lib/samagotchi/worker.rb
 - lib/samagotchi/worker_idle_exit.rb
 - lib/samagotchi/worker_inbound.rb