samagotchi 0.138.0 → 0.139.0

data/lib/samagotchi/web/auto_update.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+require "rubygems/version"
+require "time"
+require_relative "../config"
+require_relative "../log"
+require_relative "../version"
+
+module Samagotchi
+  module Web
+    # With update.auto: install, installs the release UpdateCheck found when
+    # no turn runs anywhere, and tells the owner's phone how it went. Its own
+    # thread beside the checker; every POLL it takes the next step, so what
+    # stops it (a turn, another operation) only delays it.
+    #
+    # The gate: the install isn't blocked (a checkout, Bundler, an unwritable
+    # gem dir), no update operation runs, no session's turn runs or waits on
+    # a question (`chi update` merges shipped bundles that live workers
+    # read), and the release isn't one this already failed on (one automatic
+    # try per release: the Update button or a newer release tries again).
+    #
+    # With update.restart: idle (the default) the install is followed by:
+    # 1. the stale workers, only those idle and quiet for QUIET seconds (the
+    #    worker still refuses atomically when it isn't), the left ones tried
+    #    again each step for RETRY_FOR;
+    # 2. chi web itself, once no operation and no turn runs: a preflight
+    #    (the newest chi must start and say its version) first, then the
+    #    exec. The restarted chi web's own AutoUpdate sees phase `web`,
+    #    counts the workers once more and says "chi updated": the process
+    #    that survives is the one that speaks, and that proves it is up.
+    # A preflight that fails leaves chi web as it is and says so.
+    # update.restart: never stops after the install.
+    #
+    # The run's record lives in update_check.json (UpdateCheck#save_auto),
+    # so a chi web restart finds it. See docs/architecture.md.
+    class AutoUpdate
+      # Seconds between steps, and before the first (the checker's first
+      # check is at 30).
+      POLL = 300
+      FIRST = 60
+      # The first step of a chi web restarted by this run (it only has to finish).
+      FIRST_RESTARTED = 5
+      # A worker restarts unattended only when its session was idle and quiet
+      # this long (someone may be about to type), by its updated_at.
+      QUIET = 600
+      # The workers a run couldn't restart are tried again this long.
+      RETRY_FOR = 24 * 3600
+      # The phases a run is still in.
+      OPEN_PHASES = %w[installed workers web].freeze
+
+      # @param hub [SessionHub]
+      # @param ops [UpdateOps]
+      # @param check [UpdateCheck] the answer and the record
+      # @param auto [String] update.auto
+      # @param restart [String] update.restart (idle or never)
+      # @param preflight [#call, nil] `(version) → nil | String`: whether the
+      #   newest chi starts (nil result), or why not (nil: no check)
+      # @param clock [#call] the Time now
+      # @param poll [Numeric] seconds between steps
+      def initialize(hub:, ops:, check:, auto: Config.get("update.auto"), restart: Config.get("update.restart"),
+                     preflight: nil, clock: -> { Time.now }, poll: POLL, first: FIRST)
+        @hub = hub
+        @ops = ops
+        @check = check
+        @auto = auto
+        @restart = restart
+        @preflight = preflight
+        @clock = clock
+        @poll = poll
+        @first = first
+        @wakeup = Queue.new
+        @thread = nil
+        @stopped = false
+      end
+
+      def start
+        return self unless @auto == "install"
+        return self if @thread&.alive?
+
+        @stopped = false
+        @thread = Thread.new { run_loop }
+        self
+      end
+
+      def stop
+        @stopped = true
+        @wakeup << :stop
+        thread = @thread
+        @thread = nil
+        thread&.join(5.0)
+        nil
+      end
+
+      # One look at what to do next (the thread's step; specs call it).
+      def step
+        return unless @auto == "install"
+
+        record = @check.auto_state
+        return carry_on(record) if record && OPEN_PHASES.include?(record[:phase])
+
+        version = @check.available
+        return unless version
+        return if @check.auto_failed?(version) || tried?(version)
+        return if @ops.blocked_reason || @ops.running? || busy_turn?
+
+        install(version)
+      end
+
+      private
+
+      def run_loop
+        wait = restarted? ? FIRST_RESTARTED : @first
+        until @stopped
+          break if @wakeup.pop(timeout: wait) == :stop
+
+          step
+          wait = @poll
+        end
+      rescue StandardError => e
+        Log.exception(:web, "auto_update_failed", e)
+      end
+
+      # A run that this chi web's start finds on its way to the web restart.
+      def restarted?
+        @check.auto_state&.dig(:phase) == "web"
+      end
+
+      # This release's run is already on record (installed, or given up on).
+      def tried?(version)
+        @check.auto_state&.dig(:version) == version
+      end
+
+      # A turn runs, or a question waits for its answer, in any session.
+      def busy_turn?
+        @hub.snapshot.any? do |summary|
+          summary[:status] == "running" || !summary[:pending_question].nil?
+        end
+      end
+
+      def install(version)
+        Log.info(:web, "auto_update_start", version: version, from: VERSION)
+        result = @ops.install(version, wait: true, auto: true)
+        return Log.info(:web, "auto_update_deferred", version: version, why: result) if result.is_a?(Symbol)
+
+        rows = result[:rows]
+        record = { version: version, from: VERSION, at: @clock.call.iso8601, kept: kept_files(rows) }
+        if result[:state] == "done"
+          Log.info(:web, "auto_update_installed", version: version, kept: record[:kept].size)
+          installed(record)
+        else
+          failed(record, rows)
+        end
+      end
+
+      # Installed. With restart: never the phone is told and the owner's
+      # toast and idle exit carry chi web and the workers over; else the
+      # restarts follow, here and now when nothing holds them.
+      def installed(record)
+        return carry_on(save(record.merge(phase: "installed"))) unless @restart == "never"
+
+        @hub.publish_notice(kind: "installed", version: record[:version], kept: record[:kept].size)
+        save(record.merge(phase: "done", pushed: true))
+      end
+
+      # The next step of a run on record.
+      def carry_on(record)
+        case record[:phase]
+        when "installed", "workers" then workers_then_web(record)
+        when "web" then finish(record)
+        end
+      end
+
+      def workers_then_web(record)
+        return if @ops.running?
+
+        record = restart_workers(record) if record[:phase] == "installed" || workers_left?(record)
+        return unless record
+
+        restart_web(record)
+      end
+
+      def workers_left?(record)
+        record.dig(:workers, :left).to_i.positive? && @clock.call - recorded_at(record) < RETRY_FOR
+      end
+
+      def recorded_at(record)
+        Time.iso8601(record[:at].to_s)
+      rescue ArgumentError
+        @clock.call
+      end
+
+      # A pass over the stale workers that are idle and quiet; the counts
+      # add up over passes. nil when another operation took the turn.
+      def restart_workers(record)
+        result = @ops.restart_workers(wait: true, auto: true, select: quiet_filter)
+        return if result.is_a?(Symbol)
+
+        states = result[:rows].map { |row| row["state"] }
+        restarted = record.dig(:workers, :restarted).to_i + states.count("restarted")
+        save(record.merge(phase: "workers", workers: { restarted: restarted, left: states.size - states.count("restarted") }))
+      end
+
+      # Idle and quiet: no turn, no question, untouched for QUIET seconds.
+      def quiet_filter
+        summaries = @hub.snapshot.to_h { |summary| [summary[:id], summary] }
+        now = @clock.call
+        lambda do |worker|
+          summary = summaries[worker.session_id]
+          next false unless summary && summary[:status] == "idle" && summary[:pending_question].nil?
+
+          touched = parse_time(summary[:updated_at])
+          !touched.nil? && now - touched >= QUIET
+        end
+      end
+
+      def parse_time(value)
+        Time.iso8601(value.to_s)
+      rescue ArgumentError
+        nil
+      end
+
+      # chi web itself, once no turn runs anywhere and the newest chi is
+      # known to start. The record says `web` before the exec: the process
+      # that comes up finishes the run.
+      def restart_web(record)
+        return if busy_turn?
+
+        problem = @preflight&.call(record[:version])
+        return restart_failed(record, problem, "auto_restart_preflight_failed") if problem
+
+        save(record.merge(phase: "web"))
+        Log.info(:web, "auto_update_restart", version: record[:version])
+        case (answer = @ops.restart_web)
+        when :started then nil
+        when :busy then save(record.merge(phase: "workers"))
+        else restart_failed(record, "chi web can't restart itself here (#{answer})", "auto_restart_refused")
+        end
+      end
+
+      def restart_failed(record, detail, event)
+        Log.warn(:web, event, version: record[:version], detail: detail)
+        @hub.publish_notice(kind: "restart_failed", version: record[:version], detail: detail)
+        save(record.merge(phase: "failed", detail: detail, pushed: true))
+      end
+
+      # In the restarted chi web: on the version, the workers counted once
+      # more, "chi updated" said.
+      def finish(record)
+        if Gem::Version.new(VERSION) < Gem::Version.new(record[:version])
+          return restart_failed(record, "chi web came back on #{VERSION}", "auto_restart_wrong_version")
+        end
+
+        @hub.scan
+        record = restart_workers(record) || record
+        workers = record[:workers] || {}
+        Log.info(:web, "auto_update_done", version: record[:version], restarted: workers[:restarted], left: workers[:left])
+        @hub.publish_notice(kind: "updated", version: record[:version], kept: record[:kept].to_a.size,
+                            restarted: workers[:restarted].to_i, left: workers[:left].to_i)
+        save(record.merge(phase: "done", pushed: true))
+      end
+
+      def save(record)
+        @check.save_auto(record)
+        record
+      end
+
+      def failed(record, rows)
+        row = rows.find { |candidate| candidate["failed"] } || rows.first || {}
+        detail = row["status"].to_s.lines.first.to_s.strip
+        Log.warn(:web, "auto_update_failed_install", version: record[:version], detail: detail)
+        gem_installed = rows.any? { |candidate| candidate["component"] == "chi (gem)" && !candidate["failed"] }
+        @hub.publish_notice(kind: "failed", version: record[:version], detail: detail.empty? ? nil : detail,
+                            installed: gem_installed)
+        @check.save_auto(record.merge(phase: "failed", detail: detail, pushed: true), failed: record[:version])
+      end
+
+      def kept_files(rows)
+        rows.flat_map { |row| Array(row["kept"]).map(&:to_s) }.uniq
+      end
+    end
+  end
+end

data/lib/samagotchi/web/public/app.js

@@ -578,7 +578,7 @@ function noticeVersions(data) {
   Object.assign(versions, mergeVersionState(versions, data));
   const notice = versionNotice({ loaded: document.body.dataset.version, served: versions.served,
                                  installed: versions.installed, available: versions.available,
-                                 updateBlocked: versions.updateBlocked, shown: versionNoticesShown });
+                                 updateBlocked: versions.updateBlocked, auto: versions.auto, shown: versionNoticesShown });
   store.touch("infoBar"); // the worker badge compares with the newest installed
   if (!notice) return;
   versionNoticesShown.add(notice.key);
@@ -608,12 +608,12 @@ function updateFrame(data, { snapshot = false } = {}) {
   const wasOpen = updateSheet.isOpen();
   if (!updateSheet.receive(data)) return;
   if (data.operation === "install" && data.state === "done" && data.version) noticeVersions({ installed: data.version });
+  const label = `${data.auto ? "Automatic " : ""}${data.operation === "install" ? "chi update" : "worker restart"}`
+    .replace(/^./, (c) => c.toUpperCase());
   if (!wasOpen && data.state === "running") {
-    const label = data.operation === "install" ? "Chi update" : "Worker restart";
     showToast(`${label} in progress`, { label: "View", run: () => updateSheet.view() }, { sticky: true });
   } else if (!snapshot && !wasOpen && ["done", "failed"].includes(data.state)
     && !(data.operation === "install" && data.state === "done")) {
-    const label = data.operation === "install" ? "Chi update" : "Worker restart";
     showToast(`${label} ${data.state}`, { label: "View", run: () => updateSheet.view() }, { sticky: true });
   }
 }

data/lib/samagotchi/web/public/task_stop.js

@@ -23,12 +23,12 @@ export function stopTarget(row, features) {
 // A task_wait row's title without its wait ("npm test · up to 600s").
 const WAIT_SUFFIX = / · up to \d+s$/;
 
-// The first line of an execute that was still running at its limit and
-// went on as a task (Tools::Execute::HANDED_OVER), then its task_id line.
+// The first line of an execute that was still running at its limit (or when
+// a message from the user waited: "4s mark") and went on as a task (Tools::Execute::HANDED_OVER), then its task_id line.
 // Anchored at the start, an optional "ran as: …" line and "[execute]" lead
 // before it: a "task_id:" line anywhere else is the command's own output.
 // The twin of TaskRuntime.handed_over_id.
-const HANDED_OVER = /^(?:ran as: [^\n]*\n)?(?:\[execute\]\n)?Still running at the \d+s limit:[^\n]*\ntask_id: (\S+)/;
+const HANDED_OVER = /^(?:ran as: [^\n]*\n)?(?:\[execute\]\n)?Still running at the \d+s (?:limit|mark):[^\n]*\ntask_id: (\S+)/;
 
 // The task id an execute row's output hands over, else null.
 export function handedOverId(output) {

data/lib/samagotchi/web/public/update_notice.js

@@ -15,6 +15,7 @@ export function mergeVersionState(current = {}, frame = {}) {
   if (has(frame, "installed")) next.installed = known(frame.installed) ? frame.installed : null;
   if (has(frame, "available")) next.available = known(frame.available) ? frame.available : null;
   if (has(frame, "update_blocked")) next.updateBlocked = known(frame.update_blocked) ? frame.update_blocked : null;
+  if (has(frame, "auto")) next.auto = frame.auto === "install" ? "install" : "off";
   return next;
 }
 
@@ -46,11 +47,13 @@ export function newerVersion(a, b) {
 // - loaded ≠ served: chi web restarted on another version; reload the page;
 // - installed newer than served: chi web runs an older chi than installed;
 //   restart its workers or chi web;
-// - available newer than served: install it, unless the install is blocked.
+// - available newer than served: install it, unless the install is blocked;
+//   with update.auto: install (and not blocked) chi web installs it by itself
+//   once no turn runs: the notice says so, with no Update button.
 // Each has a key; one in +shown+ (a Set: what this tab already showed, as
 // every reconnect's snapshot says it again) is not shown twice.
 // @return {{key, text, reload: boolean} | null}
-export function versionNotice({ loaded, served, installed, available, updateBlocked, shown = new Set() } = {}) {
+export function versionNotice({ loaded, served, installed, available, updateBlocked, auto, shown = new Set() } = {}) {
   let notice = null;
   if (known(loaded) && known(served) && loaded !== served) {
     notice = { key: `reload:${served}`, text: `chi was updated to ${served}`, reload: true };
@@ -68,13 +71,16 @@ export function versionNotice({ loaded, served, installed, available, updateBloc
       gem_dir_not_writable: ["the RubyGems directory is not writable", `gem install samagotchi -v ${available}`],
     };
     const blocked = commands[updateBlocked];
+    const automatic = auto === "install" && !blocked;
     const command = blocked?.[1] || "chi update";
     notice = {
       key: `available:${available}`,
       text: blocked
         ? `chi ${available} is available (you run ${served}); ${blocked[0]}. Run ${command}.`
-        : `chi ${available} is available (you run ${served}).`,
-      ...(blocked ? { command } : { updateVersion: available }),
+        : automatic
+          ? `chi ${available} is available (you run ${served}); it installs by itself once no turn is running.`
+          : `chi ${available} is available (you run ${served}).`,
+      ...(blocked ? { command } : automatic ? {} : { updateVersion: available }),
       releaseUrl: `https://rubygems.org/gems/samagotchi/versions/${encodeURIComponent(available)}`,
       reload: false,
     };

data/lib/samagotchi/web/public/update_sheet.js

@@ -25,8 +25,9 @@ function workerRow(row) {
 }
 
 function operationTitle(model) {
-  if (model.operation === "install") return `Update chi${model.version ? ` to ${model.version}` : ""}`;
-  if (model.operation === "workers") return "Restart workers";
+  const automatic = model.auto ? " (automatic)" : "";
+  if (model.operation === "install") return `Update chi${model.version ? ` to ${model.version}` : ""}${automatic}`;
+  if (model.operation === "workers") return `Restart workers${automatic}`;
   return "Restart chi web";
 }
 

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

@@ -48,6 +48,46 @@ module Samagotchi
         EVENT_TTL = 600
         # A newly available chi is useful for a day while the phone is away.
         UPDATE_TTL = 24 * 3600
+        # The kinds of AutoUpdate's notices: [key kind, title, body] from the version and the notice's notes.
+        AUTO_NOTICES = {
+          "installed" => lambda do |version, notes|
+            ["installed", "chi #{version} is installed",
+             "chi web and its sessions switch over when you restart them.#{kept_words(notes[:kept])}"]
+          end,
+          "updated" => lambda do |version, notes|
+            ["updated", "chi updated to #{version}", "#{restarted_words(notes[:restarted], notes[:left])}#{kept_words(notes[:kept])}"]
+          end,
+          "restart_failed" => lambda do |version, notes|
+            ["restart_failed", "chi #{version} is installed; chi web didn't restart",
+             "#{notes[:detail] || "chi web didn't restart"}. Restart chi web in its terminal."]
+          end,
+          "failed" => lambda do |version, notes|
+            ["update_failed", notes[:installed] ? "chi #{version} installed with a problem" : "chi #{version} didn't install",
+             "#{notes[:detail] || "chi update failed"}. Open chi web for details."]
+          end
+        }.freeze
+
+        # "chi web and 3 sessions restarted; 1 restarts when idle."
+        def self.restarted_words(restarted, left)
+          sessions = restarted.to_i
+          words = if sessions.positive?
+                    "chi web and #{sessions} #{sessions == 1 ? "session" : "sessions"} restarted"
+                  else
+                    "chi web restarted"
+                  end
+          words += "; #{left} #{left == 1 ? "restarts" : "restart"} when idle" if left.to_i.positive?
+          "#{words}."
+        end
+
+        # " Kept your edits in 2 files." ("" for none).
+        def self.kept_words(count)
+          if count.to_i.positive?
+            " Kept your edits in #{count} #{count == 1 ? "file" : "files"}."
+          else
+            ""
+          end
+        end
+
         # 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
@@ -191,19 +231,40 @@ module Samagotchi
             @queue << Close.new(keys: keys) unless keys.empty?
           when "chi"
             notice_update(event)
+          when "chi_notice"
+            notice_auto_update(event)
           end
         end
 
         def notice_update(event)
           return unless event.data[:update_notice]
+          # With update.auto: install (and an install that can run) the page says it will install on its own,
+          # and the result is what the phone hears: no "available" first.
+          return if event.data[:auto] == "install" && !event.data[:update_blocked]
 
           version = event.data[:available]
-          return unless version.is_a?(String) && !version.empty? && !@updates_seen[version]
+          return unless version.is_a?(String) && !version.empty?
+
+          enqueue_update("chi:update:#{version}", "chi #{version} is available", update_body(event.data[:update_blocked]))
+        end
+
+        # AutoUpdate's word (SessionHub#publish_notice): installed, updated, restart_failed or failed.
+        def notice_auto_update(event)
+          data = event.data
+          version = data[:version]
+          return unless version.is_a?(String) && !version.empty?
+
+          kind, title, body = AUTO_NOTICES.fetch(data[:kind], nil)&.call(version, data)
+          enqueue_update("chi:#{kind}:#{version}", title, body) if kind
+        end
+
+        # Once per key in this process (AutoUpdate keeps its own record across restarts).
+        def enqueue_update(key, title, body)
+          return if @updates_seen[key]
 
-          @updates_seen[version] = true
-          attention = Attention::Event.new(reason: "update", session_id: nil, key: "chi:update:#{version}", hold: nil)
-          @queue << Show.new(attention: attention, title: "chi #{version} is available",
-                             body: update_body(event.data[:update_blocked]), at: @now.call, url: "/")
+          @updates_seen[key] = true
+          attention = Attention::Event.new(reason: "update", session_id: nil, key: key, hold: nil)
+          @queue << Show.new(attention: attention, title: title, body: body, at: @now.call, url: "/")
         end
 
         # A blocked install (a checkout, Bundler, an unwritable gem dir) names its own command on the page.

data/lib/samagotchi/web/server.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
 require "json"
+require "open3"
 require "rack"
 require "rackup/handler/webrick"
 require "rbconfig"
+require "timeout"
 require "uri"
 require "webrick"
 
@@ -19,6 +21,7 @@ require_relative "running"
 require_relative "start_dir"
 require_relative "session_hub"
 require_relative "update_check"
+require_relative "auto_update"
 require_relative "token"
 require_relative "tunnel"
 require_relative "../config"
@@ -72,6 +75,8 @@ module Samagotchi
       PROBE_TIMEOUT = 0.3
       RESTARTED_ENV = "SAMAGOTCHI_WEB_RESTARTED"
       ADOPT_PIDS_ENV = "SAMAGOTCHI_WEB_ADOPT_PIDS"
+      # How long AutoUpdate's pre-restart `chi --version` may take.
+      PREFLIGHT_TIMEOUT = 20
 
       # The raw header names next to Rack's env (ProxyGate's identity check):
       # chi web is the only WEBrick server chi runs.
@@ -254,6 +259,39 @@ module Samagotchi
         program.to_s.empty? ? nil : [RbConfig.ruby, program, *argv]
       end
 
+      # Before an unattended restart (AutoUpdate): the command a restart would
+      # exec, run with --version, must print a chi at least +version+, so a
+      # broken install leaves chi web up instead of dead.
+      # @param version [String] the release installed
+      # @param timeout [Numeric] seconds the command may take
+      # @param runner [#call, nil] `(command, env, timeout) → String` its output (a spec's seam)
+      # @return [String, nil] nil when it starts, else why not
+      def self.restart_preflight(version, timeout: PREFLIGHT_TIMEOUT, runner: nil)
+        command = reexec_command(["--version"])
+        return "there is no chi to restart into" unless command
+
+        output = (runner || method(:run_preflight)).call(command, ChildEnv.unbundled, timeout).to_s
+        said = output[/\bchi (\S+)/, 1]
+        return nil if said && Gem::Version.correct?(said) && Gem::Version.new(said) >= Gem::Version.new(version)
+
+        "the new chi said #{output.strip.lines.first.to_s.strip[0, 120].inspect}, not #{version}"
+      rescue StandardError => e
+        "the new chi didn't start (#{e.class}: #{e.message.lines.first.to_s.strip[0, 120]})"
+      end
+
+      # The preflight's command, killed when it takes longer than +timeout+.
+      def self.run_preflight(command, env, timeout)
+        Open3.popen2e(env, *command) do |stdin, out, wait_thread|
+          stdin.close
+          reader = Thread.new { out.read }
+          unless wait_thread.join(timeout)
+            Process.kill("KILL", wait_thread.pid)
+            raise Timeout::Error, "took more than #{timeout} s"
+          end
+          reader.value
+        end
+      end
+
       # What a restart execs without a chi home: the installed gem's wrapper
       # (it activates the newest installed chi), this bin/chi in a checkout;
       # nil for a gem installed without one (--bindir).
@@ -342,13 +380,15 @@ module Samagotchi
       # @param on_bound [#call, nil] run once the port is bound, before any
       #   line (the tunnel's #up); what it raises ends the run
       # @param start_dir [String] the folder chi web starts in (App's)
+      # @param update_check [UpdateCheck, nil] the RubyGems checker (nil: built from config)
+      # @param auto_update [AutoUpdate, nil] update.auto: install's thread (nil: built from config)
       # @return [Boolean, :restart] false when the port was taken (said so on stderr);
       #   :restart when the owner requested an in-place process replacement
       def self.start(port: nil, host: nil, url: nil, open_browser: false, state_dir: nil, manager: nil, markdown: false,
                      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: [],
-                     on_bound: nil, start_dir: Dir.pwd, update_check: nil)
+                     on_bound: nil, start_dir: Dir.pwd, update_check: nil, auto_update: nil)
         config_restart_unsubscribe = ConfigFile.watch_restart_settings!(process: :web) do |message|
           Samagotchi::Log.warn(:config, "restart_required", echo: "Warning: config: #{message}")
         end
@@ -365,6 +405,8 @@ module Samagotchi
         app = App.new(manager: manager, state_dir: state_dir, markdown: markdown,
                       annotate_presets: annotate_presets, editor: editor, hub: hub, lan: lan_option, working_set: working_set,
                       public_url: public_url, public_token: public_token, push: push, start_dir: start_dir)
+        # update.auto: install; a stand-in app (a spec's) has no operations to run.
+        auto_update ||= AutoUpdate.new(hub: hub, ops: app.update_ops, check: update_check, preflight: method(:restart_preflight)) if app.respond_to?(:update_ops)
         webrick = nil
         restart_mutex = Mutex.new
         restart_requested = false
@@ -402,6 +444,7 @@ module Samagotchi
         end
         hub.start
         update_check.start
+        auto_update&.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)
@@ -458,6 +501,7 @@ module Samagotchi
         Running.clear(path: running_path) if running_path
         config_restart_unsubscribe&.call
         notifier&.stop
+        auto_update&.stop
         update_check&.stop
         hub&.stop
         Samagotchi::Log.info(:web, "stop") if app

data/lib/samagotchi/web/session_access_routes.rb

@@ -274,7 +274,7 @@ module Samagotchi
                              model_name: session_access.show(id).model_name,
                              default_model: ModelProfile.default_model_name,
                              parent_strategy: strategy_json(session_access.parent_strategy(id)),
-                             **(@hub&.chi_state || { version: VERSION, installed: nil, available: nil, update_blocked: nil }) })
+                             **(@hub&.chi_state || { version: VERSION, installed: nil, available: nil, update_blocked: nil, auto: "off" }) })
       rescue SessionManager::OwnedByTUI => e
         owned_by_tui(e)
       rescue SessionAccess::Refused => e

data/lib/samagotchi/web/session_hub.rb

@@ -8,6 +8,7 @@ require_relative "../session"
 require_relative "../session_manager"
 require_relative "../bridge_client"
 require_relative "../worker_link"
+require_relative "../config"
 require_relative "../log"
 require_relative "../installed_versions"
 require_relative "../version"
@@ -73,9 +74,12 @@ module Samagotchi
       #   or a stand-in
       # @param now [#call] a monotonic clock in seconds (specs drive it)
       # @param installed_versions [#newest] what is installed (InstalledVersions)
+      # @param update_auto [String] update.auto, said in the chi state (the page's wording)
       def initialize(state_dir:, manager: SessionManager, now: nil, scan_interval: SCAN_INTERVAL,
-                     full_probe_interval: FULL_PROBE_INTERVAL, installed_versions: InstalledVersions.new)
+                     full_probe_interval: FULL_PROBE_INTERVAL, installed_versions: InstalledVersions.new,
+                     update_auto: Config.get("update.auto"))
         @state_dir = state_dir
+        @update_auto = update_auto
         @installed_versions = installed_versions
         @installed = nil
         @available = nil
@@ -156,7 +160,8 @@ module Samagotchi
       # The complete chi version state used by event snapshots and info routes.
       def chi_state
         @monitor.synchronize do
-          { version: VERSION, installed: @installed, available: @available, update_blocked: @update_blocked }
+          { version: VERSION, installed: @installed, available: @available, update_blocked: @update_blocked,
+            auto: @update_auto }
         end
       end
 
@@ -174,9 +179,10 @@ module Samagotchi
 
       # Publish the owner-triggered update's progress or result for current
       # tabs, and retain the latest state for a reconnect's snapshot.
-      def publish_update(state:, rows:, progress: nil, operation: nil, version: nil)
+      def publish_update(state:, rows:, progress: nil, operation: nil, version: nil, auto: false)
         @monitor.synchronize do
           @update_state = { state: state, rows: rows }
+          @update_state[:auto] = true if auto
           @update_state[:operation] = operation unless operation.nil?
           @update_state[:version] = version unless version.nil?
           @update_state[:progress] = progress unless progress.nil?
@@ -189,6 +195,17 @@ module Samagotchi
         @monitor.synchronize { @update_state&.dup }
       end
 
+      # What the automatic update (AutoUpdate) has to tell the owner's phone:
+      # a `chi_notice` event for the Push::Notifier, not for the page (the
+      # `chi_update` frames are the page's), and not kept for a snapshot.
+      # @param kind [String] installed, updated or failed
+      # @param version [String] the release it is about
+      # @param notes [Hash] detail:, kept: (a count), restarted:, left:
+      def publish_notice(kind:, version:, **notes)
+        @monitor.synchronize { emit("chi_notice", { kind: kind, version: version, **notes }) }
+        nil
+      end
+
       # Rescan one session now (its file, its folder, its owner), for the
       # page's own actions: no waiting for the next tick.
       def touch(id)