samagotchi 0.107.0 → 0.109.0

data/lib/samagotchi/engine.rb

@@ -13,6 +13,7 @@ require_relative "context_note"
 require_relative "context_status"
 require_relative "steer"
 require_relative "turn_note"
+require_relative "turn_origin"
 require_relative "model_profile"
 require_relative "effective_model"
 require_relative "session_setting"
@@ -57,6 +58,7 @@ require_relative "hook_routes"
 require_relative "guardrails"
 require_relative "reminder_store"
 require_relative "reminder_queue"
+require_relative "memory_orphans"
 require_relative "tools/memory"
 require_relative "muted_memories"
 require_relative "used_memories"
@@ -623,7 +625,7 @@ module Samagotchi
     def side_author(kind)
       return nil unless turn_running? || kind.to_s == RECAP_SIDE_KIND
 
-      Steer.sender_author(@guardrail_wiring.turn_author)
+      @guardrail_wiring.turn_author
     end
 
     RECAP_SIDE_KIND = "recap"
@@ -631,7 +633,7 @@ module Samagotchi
     # The running turn's author when a participant wrote it, else nil
     # (ctx.turn_author, the hooks' author).
     # @return [String, nil]
-    def turn_author = turn_running? ? Steer.sender_author(@guardrail_wiring.turn_author) : nil
+    def turn_author = turn_running? ? @guardrail_wiring.turn_author : nil
 
     # @return [SessionMetrics] the per-session analytics collector
     attr_reader :metrics
@@ -984,7 +986,8 @@ module Samagotchi
 
     # Announce what failed to load and what plugins showed while loading,
     # once, as soon as the owner can show it (the worker's Bridge is up, the
-    # REPL renders events): the guardrail and plugin warnings, then the
+    # REPL renders events): the guardrail and plugin warnings, an orphaned
+    # project memory folder (label: "memory", MemoryOrphans), then the
     # held notices (between_turns) and cards (in_turn: false, so late
     # joiners get them). Without this call the first turn announces them
     # (#announce_guardrail_failures).
@@ -997,6 +1000,8 @@ module Samagotchi
         announce({ type: :guardrail_warning, message: message }) if message
         plugins = @plugin_failures.message
         announce({ type: :guardrail_warning, message: plugins, label: "plugins" }) if plugins
+        memory = MemoryOrphans.message
+        announce({ type: :guardrail_warning, message: memory, label: "memory" }) if memory
         @extension_load.held_events.each do |event|
           announce(event[:type] == :card ? event.merge(in_turn: false) : event.merge(between_turns: true))
         end
@@ -1448,8 +1453,8 @@ module Samagotchi
 
     # Once per Engine, on its first turn: what failed to load, so every UI
     # (REPL, attached TUI, web) shows it: the guardrails, then the plugins
-    # (label: "plugins"; the UIs say guardrails without one), then the
-    # notices and cards plugins showed as they loaded.
+    # (label: "plugins"; the UIs say guardrails without one), an orphaned
+    # project memory folder (label: "memory"), then the notices and cards plugins showed as they loaded.
     def announce_guardrail_failures(on_event)
       return if @guardrail_failures_announced
 
@@ -1458,6 +1463,8 @@ module Samagotchi
       emit_event(on_event, { type: :guardrail_warning, message: message }) if message
       plugins = @plugin_failures.message
       emit_event(on_event, { type: :guardrail_warning, message: plugins, label: "plugins" }) if plugins
+      memory = MemoryOrphans.message
+      emit_event(on_event, { type: :guardrail_warning, message: memory, label: "memory" }) if memory
       @extension_load.held_events.each { |event| emit_event(on_event, event) }
     end
     private :announce_guardrail_failures
@@ -1494,14 +1501,14 @@ module Samagotchi
     # @param limit [Integer, nil] the turn ran out of iterations at this
     #   limit: "exhausted" => true, "limit" => N, so a wait with nobody to
     #   answer the continue offer says so (ReplyWait, ParentReport "limit")
+    # @param origin [TurnOrigin] the turn's (TurnOrigin::NONE for no sender)
     # @param event [Hash] the turn's end event (#stop_facts)
     def record_last_turn(session, outcome, seconds, origin, event, limit: nil)
-      source = ClientId.origin(origin.is_a?(Hash) ? origin[:client_id] : nil)
-      enqueued_id = origin.is_a?(Hash) ? origin[:enqueued_id] : nil
+      enqueued_id = origin.enqueued_id
       session.last_turn = LastTurn.new(outcome: outcome, ended_at: Time.now.iso8601(3), seconds: seconds.round(1),
-                                       origin: source, exhausted: limit ? true : nil, limit: limit,
+                                       origin: origin.source, exhausted: limit ? true : nil, limit: limit,
                                        enqueued_id: enqueued_id.to_s.empty? ? nil : enqueued_id.to_s,
-                                       author: Steer.sender_author(origin.is_a?(Hash) ? origin[:author] : nil),
+                                       author: origin.participant_author,
                                        **stop_facts(event))
     end
 
@@ -1532,10 +1539,9 @@ module Samagotchi
     # author:, and author_name: from participants.json), {} for the owner.
     # The worker's drain names a participant's merged lines with it, and
     # its running save a participant's prompt.
-    # @param origin [Hash, String, nil] a turn's origin, or an author
+    # @param author [String, nil] a turn's or a line's author (TurnOrigin#author)
     # @param session [Session, nil] the session it is for (the turn's)
-    def author_fields(origin, session: @session)
-      author = origin.is_a?(Hash) ? origin[:author] : origin
+    def author_fields(author, session: @session)
       return {} unless Steer.participant_author?(author)
 
       Steer.author_fields(author, @participants.name_for(author, session: session))
@@ -1995,9 +2001,11 @@ module Samagotchi
                       :settings, :id, :limit, :resumed, :resume_from) do
       def resumed? = resumed ? true : false
 
-      # The turn's boundary events carry the origin only when there is one,
-      # so payloads stay unchanged for callers that don't pass it.
-      def tag(event) = origin ? event.merge(origin: origin) : event
+      # The turn's boundary events carry the origin only when it names a
+      # sender (not TurnOrigin::NONE), so payloads stay unchanged for callers
+      # that don't pass one; as its wire Hash (TurnOrigin#to_h), which the
+      # Bridge and the UIs read.
+      def tag(event) = origin.empty? ? event : event.merge(origin: origin.to_h)
 
       # Seconds since the turn started (the cancel note says how long it ran).
       def elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at
@@ -2032,11 +2040,13 @@ module Samagotchi
     #   run it resumes started (ModelResult#run_start, kept in the offer by
     #   TurnFlow), so it keeps that run's reasoning; nil starts cold (a
     #   model change while the offer stood, every other turn).
-    # @param origin [Hash, nil] who queued the turn ({client_id:, enqueued_id:},
-    #   and author: when someone other than the session's owner wrote it, from
-    #   its input file; absent for the owner); when given, the turn's boundary
-    #   events (:turn_started, :turn_completed, :turn_canceled, :turn_failed)
-    #   carry it as `origin:`, and GuardrailWiring#begin_turn gets it
+    # @param origin [TurnOrigin, Hash, nil] who queued the turn (client_id,
+    #   enqueued_id, and author when someone other than the session's owner
+    #   wrote it, from its input file; none for the owner; a Hash is read as
+    #   one, TurnOrigin.of; TurnOrigin::NONE, the default, names no sender
+    #   and so does nil or {}); when it names one, the turn's boundary events
+    #   (:turn_started, :turn_completed, :turn_canceled, :turn_failed) carry
+    #   it as `origin:` (its wire Hash), and GuardrailWiring#begin_turn gets it
     # @param images [Array<Hash>] the prompt's images: {path:} (a file on this
     #   machine; in-process and attached-TUI callers only) or {file:, name:}
     #   (already in the session's images/, e.g. a web upload). They are
@@ -2056,8 +2066,8 @@ module Samagotchi
     # other error (e.g. an LLM::ProviderError) emits :turn_failed and
     # re-raises; a provider error adds error_kind:, retryable:, host: and a
     # one-line summary:.
-    def run_turn(session, prompt, on_event: nil, max_iterations: nil, cancel_controller: nil, max_tool_output_chars: nil, pending_input: nil, continue: false, origin: nil,
-                 images: [], id: nil, resumed: false, resume_from: nil)
+    def run_turn(session, prompt, on_event: nil, max_iterations: nil, cancel_controller: nil, max_tool_output_chars: nil, pending_input: nil, continue: false,
+                 origin: TurnOrigin::NONE, images: [], id: nil, resumed: false, resume_from: nil)
       turn = begin_turn(session, prompt, on_event: on_event, cancel_controller: cancel_controller, origin: origin,
                                          continue: continue, id: id)
       if continue
@@ -2108,6 +2118,7 @@ module Samagotchi
     # the turn flag, its cancel controller and sink. The cross-thread state
     # is set here and cleared in #release_turn only.
     def begin_turn(session, prompt, on_event:, cancel_controller:, origin:, continue:, id: nil)
+      origin = TurnOrigin.of(origin)
       # Track the active session for recap and status snapshot.
       @session = session
       # status is turn state: running now, idle again before the turn's end
@@ -2151,7 +2162,7 @@ module Samagotchi
       turn_started[:cut_after] = steer_cut_after
       # A participant's turn names them (author, author_name) for the UIs'
       # badge; the owner's turn_started stays as it was.
-      turn_started.merge!(author_fields(turn.origin, session: session))
+      turn_started.merge!(author_fields(turn.origin.author, session: session))
       emit_event(turn.on_event, turn.tag(turn_started))
       raise image_error if image_error
 
@@ -2305,7 +2316,7 @@ module Samagotchi
       # system prompt invalidates cache for the entire prefix.
       # Not into a participant's turn: the owner's reminders are the owner's,
       # and would be used up there under the review boundary.
-      due_reminders = Steer.participant_author?(turn.origin&.dig(:author)) ? [] : @reminder_queue.inject!(turn.messages)
+      due_reminders = turn.origin.participant? ? [] : @reminder_queue.inject!(turn.messages)
       if due_reminders.any?
         emit_event(turn.on_event, {
           type: :reminder_injected,
@@ -2314,7 +2325,7 @@ module Samagotchi
       end
 
       unless turn.continue
-        user_message = { role: "user", content: turn.prompt, turn_id: turn.id, **author_fields(turn.origin) }
+        user_message = { role: "user", content: turn.prompt, turn_id: turn.id, **author_fields(turn.origin.author) }
         user_message[:images] = image_refs unless image_refs.empty?
         turn.messages << user_message
         session.last_prompt = turn.prompt

data/lib/samagotchi/guardrail_wiring.rb

@@ -11,6 +11,7 @@ require_relative "version"
 require_relative "hooks"
 require_relative "edit_preview"
 require_relative "tool_activity"
+require_relative "turn_origin"
 
 module Samagotchi
   # An Engine's tool guardrails: who can approve (the interface), the YAML
@@ -55,6 +56,7 @@ module Samagotchi
       @failures = Guardrails::LoadFailures.new
       @rules_mutex = Mutex.new
       @git = Guardrails::GitInfo.new
+      @origin = TurnOrigin::NONE
     end
 
     # Who can answer an approval: :repl, :worker or :non_interactive (the
@@ -83,17 +85,18 @@ module Samagotchi
       @protected = nil
     end
 
-    # A turn starts: its origin (Engine#run_turn's: {client_id:,
-    # enqueued_id:, author:}, each optional), and the git facts read afresh.
+    # A turn starts: its origin (Engine#run_turn's TurnOrigin; nil or a
+    # Hash is read as one, TurnOrigin.of), and the git facts read afresh.
     def begin_turn(origin)
-      @origin = origin
+      @origin = TurnOrigin.of(origin)
       @git = Guardrails::GitInfo.new
     end
 
     # Who wrote the running turn when it isn't the session's owner (its
-    # origin's author); nil for the owner's turns and every other origin.
+    # origin's participant author); nil for the owner's turns and every
+    # other origin.
     # @return [String, nil]
-    def turn_author = @origin.is_a?(Hash) ? @origin[:author] : nil
+    def turn_author = @origin.participant_author
 
     # The gate every tool call asks first.
     # @return [Guardrails::Gate]
@@ -229,7 +232,7 @@ module Samagotchi
     # @return [Guardrails::Context]
     def context
       Guardrails::Context.new(cwd: Dir.pwd, session_id: @session_lookup.call&.id, interface: interface,
-                              origin: @origin, git: @git)
+                              origin: @origin.wire, git: @git)
     end
 
     # Ask the user to approve a call the gate voted `ask` on, through the

data/lib/samagotchi/idle_scheduler.rb

@@ -63,7 +63,10 @@ module Samagotchi
     # takes) passes join: false: the thread finishes its tick and exits by
     # itself, and a later joining stop (Engine#shutdown, the worker's
     # teardown) still joins it. From the scheduler's own thread (a job's
-    # tick) it never joins.
+    # tick) it never joins. A thread that died of an error #run_loop doesn't
+    # rescue (a SystemStackError, a job's `exit`) is logged here, not raised
+    # again by the join into the caller (Engine#shutdown would skip the rest
+    # of its teardown: plugin tasks, MCP servers).
     def stop(join: true)
       @stopped = true
       @wake << :stop
@@ -72,7 +75,7 @@ module Samagotchi
       @unjoined = join ? nil : thread
       return if thread.nil? || !join || thread == Thread.current
 
-      thread.kill unless thread.join(STOP_JOIN_SECONDS)
+      thread.kill unless join_thread(thread)
       nil
     end
 
@@ -104,6 +107,18 @@ module Samagotchi
 
     private
 
+    # The thread joined within STOP_JOIN_SECONDS (truthy) or not (nil).
+    def join_thread(thread)
+      thread.join(STOP_JOIN_SECONDS)
+    rescue Exception => e # rubocop:disable Lint/RescueException -- the thread's own death, re-raised by join
+      # A status of nil: the thread ended with this exception. Anything else
+      # (an interrupt of the caller's own while it waited) is the caller's.
+      raise unless thread.status.nil?
+
+      Log.exception(:idle, "scheduler_died", e, echo: "[IdleScheduler] scheduler thread died: #{e.class}: #{e.message}")
+      thread
+    end
+
     def run_loop
       until @stopped
         tick

data/lib/samagotchi/last_turn.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "steer"
+
 module Samagotchi
   # How a session's last turn ended (Session#last_turn), saved as
   # session.json's "last_turn" and sent in the web's session summary.
@@ -44,6 +46,11 @@ module Samagotchi
     # The stop facts this turn has (LastTurn::STOP_FACTS), symbol keys.
     # @return [Hash{Symbol => Object}]
     def stop_facts = to_h.slice(*self.class::STOP_FACTS).compact
+
+    # The turn's author when a participant's (Steer.sender_author, as
+    # TurnOrigin#participant_author reads a running turn's), else nil.
+    # @return [String, nil]
+    def participant_author = Steer.sender_author(author)
   end
 
   # Why a turn stopped, for a parent agent's wait (ReplyWait::Result takes

data/lib/samagotchi/log_subscriber.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "log"
+require_relative "turn_origin"
 
 module Samagotchi
   # The event trail: a SessionObserver subscriber (next to SessionMetrics)
@@ -181,7 +182,7 @@ module Samagotchi
     end
 
     def origin(event)
-      client = event.dig(:origin, :client_id) if event[:origin].is_a?(Hash)
+      client = TurnOrigin.from(event[:origin])&.client_id
       client ? { client_id: client } : {}
     end
 

data/lib/samagotchi/memory_orphans.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "memory_paths"
+
+module Samagotchi
+  # A project memory folder left behind by a move: memories copied to a
+  # machine (or a path) where the project root differs, so its key
+  # (MemoryPaths.project_key: basename + MD5 of the root) differs too, and
+  # chi finds no project memories without a word about why.
+  #
+  # Pure: one listing of the projects dir, no git subprocess. Said at
+  # session start (Engine#announce_load_events!, label "memory") and under a
+  # memory_read miss (Tools::MemoryRead); never in the system prompt.
+  module MemoryOrphans
+    # @!attribute computed [String] the folder chi reads (this project's key)
+    # @!attribute candidates [Array<String>] same-basename folders, other hashes
+    # @!attribute computed_exists [Boolean] whether +computed+ is a folder (empty of memories)
+    Found = Data.define(:computed, :candidates, :computed_exists)
+
+    module_function
+
+    # The orphan candidates for +cwd+'s project, or nil: only inside a git
+    # repository (outside one the root is cwd, and every src/ or tmp/ would
+    # match), and only while the computed folder holds no *.md (a
+    # memory_write's mkdir_p or a project-scope bundle install alone must
+    # not silence it).
+    # @return [Found, nil]
+    def find(env: ENV, cwd: Dir.pwd)
+      return nil unless MemoryPaths.in_repo?(cwd)
+
+      projects = MemoryPaths.projects_dir(env: env)
+      computed = MemoryPaths.project_dir(env: env, cwd: cwd)
+      return nil if File.directory?(computed) && Dir.children(computed).any? { |name| name.end_with?(".md") }
+
+      key = File.basename(computed)
+      # The root's basename, never a split of a key on "_" (a basename may hold one).
+      pattern = /\A#{Regexp.escape(File.basename(MemoryPaths.project_root(cwd)))}_\h{8}\z/
+      names = Dir.children(projects).select { |name| name != key && name.match?(pattern) }
+      candidates = names.sort.map { |name| File.join(projects, name) }.select { |path| File.directory?(path) }
+      return nil if candidates.empty?
+
+      Found.new(computed: computed, candidates: candidates, computed_exists: File.directory?(computed))
+    rescue SystemCallError
+      nil
+    end
+
+    # The one text for the condition (the startup warning and the
+    # memory_read hint both say it), or nil when there is none.
+    def message(env: ENV, cwd: Dir.pwd)
+      found = find(env: env, cwd: cwd)
+      found && text(found)
+    end
+
+    def text(found)
+      computed = found.computed
+      lead = "no project memories in #{computed}"
+      if found.candidates.size == 1
+        candidate = found.candidates.first
+        fix = if found.computed_exists
+                "move its files into #{computed} (e.g. `mv #{candidate}/* #{computed}/`)"
+              else
+                "`mv #{candidate} #{computed}`"
+              end
+        "#{lead}, but #{candidate} has the same project name with another path's hash (memories moved from " \
+          "another machine or path?). A name match can't prove it's this project; if it is, #{fix}."
+      else
+        fix = found.computed_exists ? "move its files into #{computed}" : "`mv <that folder> #{computed}`"
+        "#{lead}, but these have the same project name with another path's hash (memories moved from another " \
+          "machine or path?): #{found.candidates.join(", ")}. A name match can't prove one is this project; if one " \
+          "is, #{fix}."
+      end
+    end
+  end
+end

data/lib/samagotchi/memory_paths.rb

@@ -23,10 +23,10 @@ module Samagotchi
     end
 
     # One folder per project root: basename + 8 hex chars of MD5(full root path).
-    def project_key(cwd = Dir.pwd)
-      root = project_root(cwd)
-      "#{File.basename(root)}_#{Digest::MD5.hexdigest(root)[0..7]}"
-    end
+    def project_key(cwd = Dir.pwd) = key_for_root(project_root(cwd))
+
+    # #project_key for a root already resolved (a session's project_root).
+    def key_for_root(root) = "#{File.basename(root)}_#{Digest::MD5.hexdigest(root)[0..7]}"
 
     # The repository's common git directory identifies the project; every linked
     # worktree shares it. Returns the checkout holding it when it is named .git,

data/lib/samagotchi/parent_report.rb

@@ -335,13 +335,21 @@ module Samagotchi
         turn = turn_id || result.turn_id
         turn.to_s.empty? ? WAITING_FOR_OWNER : "#{WAITING_FOR_OWNER}: #{via.command("send --wait --turn #{turn} #{session_id}")}"
       else
-        turn = turn_id || result.turn_id
-        wait_again = via.command("send --wait --turn #{turn} #{session_id}") unless turn.to_s.empty?
-        hint = wait_again || shows
+        hint = still_running_hint(session_id, turn_id || result.turn_id, via: via)
         timeout ? "still running after #{format("%g", timeout)} s: #{hint}" : "still running: #{hint}"
       end
     end
 
+    # What a wait that left the turn running (a --timeout, a Ctrl-C) offers
+    # next: the wait for that turn when its id is known, else the wait for
+    # the session's running turn, with the attach that shows it.
+    # @param turn [String, nil] the waited turn's id
+    def still_running_hint(session_id, turn, via: ChiInvocation::HERE)
+      return via.command("send --wait --turn #{turn} #{session_id}") unless turn.to_s.empty?
+
+      "#{via.command("send --wait #{session_id}")} waits again; #{via.shows(session_id)} shows it"
+    end
+
     # The whole question for stderr: header, text, numbered options, what
     # else it takes, and the commands that answer it.
     # @return [String] lines, newline-terminated

data/lib/samagotchi/proxy_trace.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  # The request headers a proxy in front of chi adds and chi's own clients
+  # never send: chi web takes a request with one as proxied
+  # (Web::ProxyGate), a Bridge refuses it (Bridge#browser_request?). Names
+  # are compared lower-cased with "_" read as "-", so an underscore twin
+  # (X_Forwarded_For) counts too. See docs/configuration.md "Behind an auth
+  # proxy".
+  module ProxyTrace
+    # Any name starting with one of these: X-Forwarded-For/-Host/-Proto/
+    # -Email/-User…, oauth2-proxy's X-Auth-Request-*, Cloudflare's Cf-*,
+    # Tailscale Serve's Tailscale-User-*, Authentik's X-Authentik-*, Google
+    # IAP's X-Goog-*, Azure App Service's X-MS-Client-Principal*, AWS ALB's
+    # X-Amzn-Oidc-*, Envoy's X-Envoy-*.
+    PREFIXES = %w[x-forwarded- x-auth-request- cf- tailscale- x-authentik- remote- x-goog- x-ms-client-principal
+                  x-amzn-oidc- x-envoy- x-original-forwarded-].freeze
+    # And these whole names.
+    NAMES = %w[forwarded x-real-ip via true-client-ip x-client-ip x-original-url x-original-uri].freeze
+
+    # The identity headers known setups send (docs/configuration.md's
+    # table): chi web's hint when the proxy sends one of them but not the
+    # one configured.
+    IDENTITY_HEADERS = %w[X-Forwarded-Email X-Auth-Request-Email Cf-Access-Authenticated-User-Email Tailscale-User-Login
+                          Remote-Email X-Authentik-Email X-Goog-Authenticated-User-Email X-MS-Client-Principal-Name
+                          X-Amzn-Oidc-Identity X-Forwarded-User X-Auth-Request-User Remote-User].freeze
+
+    module_function
+
+    # @param name [String] a header's name as sent (any case, - or _)
+    def header?(name)
+      key = normalize(name)
+      NAMES.include?(key) || PREFIXES.any? { |prefix| key.start_with?(prefix) }
+    end
+
+    def normalize(name) = name.to_s.downcase.tr("_", "-")
+
+    # The header name of a Rack env key (HTTP_X_FORWARDED_FOR →
+    # x-forwarded-for), nil for a key that isn't a header's.
+    def env_name(key)
+      key = key.to_s
+      key.start_with?("HTTP_") ? key.delete_prefix("HTTP_").downcase.tr("_", "-") : nil
+    end
+  end
+end

data/lib/samagotchi/reply_wait.rb

@@ -221,10 +221,15 @@ module Samagotchi
     # merged): that turn runs (its mark has another id, or none from a
     # worker that writes ids), or, idle, a turn not its ended since the
     # baseline. last_turn or a reply file being its own is never that, nor
-    # an input with a tombstone (a removal's, written before its claim).
+    # an input with a tombstone (a removal's, written before its claim),
+    # nor one whose claimed file is still there: a drain deletes the file
+    # it merges as it reads it, while a turn of its own keeps it until the
+    # turn ends (WorkerInbound#take_input), so a look between that claim
+    # and the turn's running save (idle, an earlier turn's end since the
+    # baseline) doesn't take the earlier turn's reply for it.
     def merged_elsewhere?(session, turn, baseline, session_dir)
       return false if session.last_turn&.enqueued_id == turn || SessionInbox.reply_for(session_dir, turn)
-      return false if SessionInbox.removed?(session_dir, turn)
+      return false if SessionInbox.removed?(session_dir, turn) || SessionInbox.claimed_input?(session_dir, turn)
 
       if session.status == Session::STATUS_RUNNING
         running_id = session.interrupted_turn&.enqueued_id

data/lib/samagotchi/send_command/busy.rb

@@ -40,9 +40,12 @@ module Samagotchi
       # What the user is told, after the session's short id.
       # @param via [ChiInvocation] how its commands are spelled
       def message(via: ChiInvocation::HERE)
-        return "busy: a turn is running; wait or #{via.remote? ? "open it in #{via.web}" : "attach"}" unless error == "waiting"
-
         id = session_id
+        unless error == "waiting"
+          return "busy: a turn is running; --queue runs the message after it, " \
+                 "#{via.command("send --wait #{id}")} waits for it, #{via.attach(id)} shows it"
+        end
+
         # The whole question (its options, its tags) for what a parent may
         # give.
         q = ParentReport.question(question, strategy: strategy)

data/lib/samagotchi/send_command/wait_target.rb

@@ -13,30 +13,35 @@ module Samagotchi
     WaitTarget = Data.define(:turn, :report_turn_id, :queued, :ended_before) do
       def initialize(turn: nil, report_turn_id: nil, queued: false, ended_before: false) = super
 
-      # A --new session's first message. A file-delivered one's own turn
-      # (its id also names the outcome of a session command that runs no
-      # turn); through the Bridge, the next reply.
+      # A --new session's first message: its own turn, the ack's id (a
+      # file-delivered one's also names the outcome of a session command
+      # that runs no turn), so a worker that dies in it and the next one's
+      # settle end the wait (TurnCheckpoint.settled_turn). A message merged
+      # into a turn starting then falls back to that turn's reply
+      # (ReplyWait's turn: without queued:); no id (an older worker), the
+      # next reply.
       # @param delivered [SessionManager::DeliverResult, nil] nil when the
       #   message started the session itself (no delivery)
       def self.first_message(delivered)
         return new unless delivered
 
-        new(turn: delivered.file? ? delivered.enqueued_id : nil, report_turn_id: delivered.enqueued_id)
+        new(turn: delivered.enqueued_id, report_turn_id: delivered.enqueued_id)
       end
 
       # A message to an existing session. --queue: its own turn, the ack's
       # id, also when the turn running at the check ended before it went in
       # (an idle worker's ack says next_step, and the file still runs as
-      # that turn). A file fallback's id names its turn too. Otherwise the
-      # next reply, reported as the turn that was running when it went in
-      # (+running_turn+, ReplyWait.own_turn), or as its own on an idle one.
-      # A plain message the worker queued (its ack says queue: a
-      # participant's review turn was running, which takes no steer) is a
-      # --queue's.
+      # that turn). A file fallback's id names its turn too, and so does a
+      # plain message to an idle session, as #first_message's. Otherwise
+      # (a session left running by a dead worker, the busy check's owner
+      # gone) the next reply, reported as the turn that was running when it
+      # went in (+running_turn+, ReplyWait.own_turn). A plain message the
+      # worker queued (its ack says queue: a participant's review turn was
+      # running, which takes no steer) is a --queue's.
       # @param running [Boolean] the session was running when it went in
       def self.message(delivered, queue:, running:, running_turn:)
         queue ||= delivered.delivery == Delivery::QUEUE
-        turn = delivered.enqueued_id if queue || delivered.file?
+        turn = delivered.enqueued_id if queue || delivered.file? || !running
         report = if queue then turn
                  elsif running then running_turn
                  else delivered.enqueued_id

data/lib/samagotchi/session_access/local.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "socket"
+
 require_relative "../session"
 require_relative "../session_access"
 require_relative "../reply_wait"
@@ -18,6 +20,8 @@ require_relative "../participants"
 require_relative "../config"
 require_relative "../web/grants"
 require_relative "../web/info_probe"
+require_relative "../web/public_url"
+require_relative "../web/link_codes"
 require_relative "../web/running"
 
 module Samagotchi
@@ -359,17 +363,24 @@ module Samagotchi
         grants.list(session_id: id).map { |grant| ParticipantView.from_h(grant.public_h(grants.now)) }
       end
 
-      # The link names this machine's chi web: its LAN address and port
-      # when one runs on the LAN (the port it recorded, else web.port),
-      # else 127.0.0.1 (+lan+ false).
+      # The link names this machine's chi web: web.public_url from this
+      # machine's config (never what the port answers) when it is set (the
+      # token in the fragment, as chi web's own invite), else its LAN address
+      # and port when one runs on the LAN (the port it recorded, else
+      # web.port), else 127.0.0.1 (+lan+ false: the link opens on this
+      # machine only).
       # @return [Invitation]
       # @raise [ArgumentError] no such session
       # @raise [BadRequest] a bad name, kind or ttl, an archived session
       def invite(id, name:, kind:, ttl: nil, cap: nil)
         issued = Participants.invite(grants, session_id: id, name: name, kind: kind, ttl: ttl, cap: cap, state_dir: state_dir!)
-        ip, port = local_web
+        public_url = configured_public_url
+        web = public_url ? nil : local_web
+        link = if public_url then public_url.link(link_code(issued), "s=#{id}")
+               else "http://#{web.ip || "127.0.0.1"}:#{web.port}/?token=#{issued.token}#s=#{id}"
+               end
         Invitation.new(participant: ParticipantView.from_h(issued.grant.public_h(grants.now)), token: issued.token,
-                       link: "http://#{ip || "127.0.0.1"}:#{port}/?token=#{issued.token}#s=#{id}", lan: !ip.nil?,
+                       link: link, lan: !public_url.nil? || !web.ip.nil?,
                        warning: ReviewStart.share_warning(Session.load(id, **dir)))
       rescue Web::Grants::Invalid => e
         raise BadRequest.new(e.message, code: "invalid_participant")
@@ -400,18 +411,43 @@ module Samagotchi
       WEB_PORT = 4567
       LOCAL_PROBE_TIMEOUT = 1.0
 
-      # [LAN ip or nil, port] of this machine's chi web (GET /api/info):
-      # the port the running one recorded (Web::Running) when a chi web
-      # answers there, else config's web.port.
+      # Where this machine's chi web answers (GET /api/info): its LAN ip
+      # (nil without one) and the port the running one recorded
+      # (Web::Running) when a chi web answers there, else config's web.port.
+      LocalWeb = Data.define(:ip, :port)
+
+      # The LAN address a probe answered, only if it is one of this
+      # machine's: whatever listens on the port may be another user's
+      # listener naming its own (nil then: the link names 127.0.0.1).
+      def own_address(ip)
+        return nil unless ip.is_a?(String)
+
+        Socket.ip_address_list.any? { |addr| addr.ip_address == ip } ? ip : nil
+      end
+
+      # A one-time code for the grant's link (Web::LinkCodes), until it expires.
+      def link_code(issued)
+        ttl = [Time.iso8601(issued.grant.expires_at) - grants.now, 1].max
+        Web::LinkCodes.for_grants(grants.path).issue(kind: :grant, token: issued.token, ttl: ttl)
+      end
+
+      # web.public_url as this machine's config has it; nil when unset or
+      # not a valid one (chi web refuses to start on that).
+      def configured_public_url
+        Web::PublicUrl.from_config(url: Config.get("web.public_url"))
+      rescue Web::PublicUrl::Invalid
+        nil
+      end
+
       def local_web
         configured = Config.get("web.port").to_s.to_i
         configured = WEB_PORT unless configured.positive?
         recorded = Web::Running.port(path: Web::Running.path(state_dir: state_dir!))
         [recorded, configured].compact.uniq.each do |port|
           info = Web::InfoProbe.call("127.0.0.1", port, timeout: LOCAL_PROBE_TIMEOUT)
-          return [info["lan"], port] if info.is_a?(Hash)
+          return LocalWeb.new(ip: own_address(info["lan"]), port: port) if info.is_a?(Hash)
         end
-        [nil, configured]
+        LocalWeb.new(ip: nil, port: configured)
       end
 
       def dir = @state_dir ? { state_dir: @state_dir } : {}