samagotchi 0.7.0 → 0.8.0

data/lib/samagotchi/web/app.rb

@@ -121,6 +121,31 @@ module Samagotchi
 
       private
 
+      # The routes, first match wins: a handler takes the request and the
+      # path's captures (the session id, an image's name).
+      ROUTES = [
+        ["GET", %r{\A/(?:index\.html)?\z}, :serve_index],
+        ["GET", %r{\A/api/sessions\z}, :handle_list],
+        ["POST", %r{\A/api/sessions\z}, :handle_create],
+        ["GET", %r{\A/api/info\z}, :handle_info],
+        ["GET", %r{\A/api/models\z}, :handle_models],
+        ["GET", %r{\A/api/events\z}, :handle_events],
+        ["GET", %r{\A/api/sessions/([^/]+)/stream\z}, :handle_stream],
+        ["GET", %r{\A/api/sessions/([^/]+)/output\z}, :handle_output],
+        ["POST", %r{\A/api/sessions/([^/]+)/cancel\z}, :handle_cancel],
+        ["POST", %r{\A/api/sessions/([^/]+)/stop\z}, :handle_stop],
+        ["POST", %r{\A/api/sessions/([^/]+)/archive\z}, :handle_archive],
+        ["POST", %r{\A/api/sessions/([^/]+)/unarchive\z}, :handle_unarchive],
+        ["POST", %r{\A/api/sessions/([^/]+)/turn\z}, :handle_turn],
+        ["POST", %r{\A/api/sessions/([^/]+)/answer\z}, :handle_question_answer],
+        ["POST", %r{\A/api/sessions/([^/]+)/question/dismiss\z}, :handle_question_dismiss],
+        ["POST", %r{\A/api/sessions/([^/]+)/command\z}, :handle_command],
+        ["POST", %r{\A/api/sessions/([^/]+)/images\z}, :handle_image_upload],
+        ["GET", %r{\A/api/sessions/([^/]+)/images/([^/]+)\z}, :handle_image],
+        ["GET", %r{\A/api/sessions/([^/]+)\z}, :handle_show],
+        ["DELETE", %r{\A/api/sessions/([^/]+)\z}, :handle_delete]
+      ].freeze
+
       def route(env)
         req = Rack::Request.new(env)
         return forbidden unless local_host_header?(env)
@@ -130,69 +155,19 @@ module Samagotchi
           return denied if denied
         end
 
-        case [req.request_method, req.path_info]
-        when ["GET", "/"], ["GET", "/index.html"]
-          serve_index(req)
-        when ["GET", "/api/sessions"]
-          handle_list(req)
-        when ["POST", "/api/sessions"]
-          handle_create(req)
-        when ["GET", "/api/info"]
-          handle_info
-        when ["GET", "/api/models"]
-          handle_models
-        when ["GET", "/api/events"]
-          handle_events(req)
-        else
-          # Dynamic routes
-          if (m = %r{\A/api/sessions/([^/]+)/stream\z}.match(req.path_info)) && req.get?
-            return handle_stream(req, m[1])
-          end
-          if (m = %r{\A/api/sessions/([^/]+)/output\z}.match(req.path_info)) && req.get?
-            return handle_output(req, m[1])
-          end
-          if (m = %r{\A/api/sessions/([^/]+)/cancel\z}.match(req.path_info)) && req.post?
-            return handle_cancel(req, m[1])
-          end
-          if (m = %r{\A/api/sessions/([^/]+)/stop\z}.match(req.path_info)) && req.post?
-            return handle_stop(req, m[1])
-          end
-          if (m = %r{\A/api/sessions/([^/]+)/(archive|unarchive)\z}.match(req.path_info)) && req.post?
-            return m[2] == "archive" ? handle_archive(req, m[1]) : handle_unarchive(req, m[1])
-          end
-          if (m = %r{\A/api/sessions/([^/]+)/turn\z}.match(req.path_info)) && req.post?
-            return handle_turn(req, m[1])
-          end
-          if (m = %r{\A/api/sessions/([^/]+)/answer\z}.match(req.path_info)) && req.post?
-            return handle_question_answer(req, m[1])
-          end
-          if (m = %r{\A/api/sessions/([^/]+)/question/dismiss\z}.match(req.path_info)) && req.post?
-            return handle_question_dismiss(req, m[1])
-          end
-          if (m = %r{\A/api/sessions/([^/]+)/command\z}.match(req.path_info)) && req.post?
-            return handle_command(req, m[1])
+        ROUTES.each do |verb, pattern, handler|
+          next unless req.request_method == verb && (m = pattern.match(req.path_info))
+          # Every /api/sessions/:id route: an id that isn't one (Session.valid_id?,
+          # "..", a %2F) is an unknown session before any handler makes a path.
+          if req.path_info.start_with?("/api/sessions/") && !Session.valid_id?(m.captures.first)
+            return error_response(404, "not_found", "Session not found: #{m.captures.first.to_s[0, 80]}")
           end
-          if (m = %r{\A/api/sessions/([^/]+)/images\z}.match(req.path_info)) && req.post?
-            return handle_image_upload(req, m[1])
-          end
-          if (m = %r{\A/api/sessions/([^/]+)/images/([^/]+)\z}.match(req.path_info)) && req.get?
-            return handle_image(req, m[1], m[2])
-          end
-          if (m = %r{\A/api/sessions/([^/]+)\z}.match(req.path_info)) && req.get?
-            return handle_show(req, m[1])
-          end
-          if (m = %r{\A/api/sessions/([^/]+)\z}.match(req.path_info)) && req.delete?
-            return handle_delete(req, m[1])
-          end
-          if req.path_info.start_with?("/assets/") || req.path_info.start_with?("/public/")
-            return serve_static(req)
-          end
-          # Fallback static file serve from public_dir (e.g. /style.css)
-          maybe_static = serve_static(req)
-          return maybe_static if maybe_static[0] != 404
 
-          not_found(path: req.path_info)
+          return send(handler, req, *m.captures)
         end
+        # Anything else is a file under public_dir (/assets/*, /public/* or
+        # a bare path such as /style.css), or 404.
+        serve_static(req)
       rescue StandardError => e
         Log.exception(:web, "request_failed", e, method: env["REQUEST_METHOD"], path: env["PATH_INFO"])
         error_response(500, "internal_error", e.message)
@@ -429,7 +404,7 @@ module Samagotchi
 
       # What a second `chi web` probes before starting its own server: this
       # is chi web, and it knows ?dir (features).
-      def handle_info
+      def handle_info(_req)
         json_response(200, { app: "chi-web", version: Samagotchi::VERSION, pid: Process.pid, cwd: Dir.pwd,
                              features: ["dir"], lan: @lan && @lan[:ip] })
       end
@@ -442,7 +417,7 @@ module Samagotchi
       # a bounded time for a fresh listing and answers with what it has, a
       # host that failed or the wait running out noted in +warning+, never a
       # failure: the default alone is enough for the page.
-      def handle_models
+      def handle_models(_req)
         default = begin
           ModelProfile.required_model_name
         rescue StandardError
@@ -586,12 +561,14 @@ module Samagotchi
         snapshot = live && live["session_state_snapshot"]
         last_event_seq = snapshot ? snapshot["event_seq"] : bridge_event_seq(id)
         current_turn = turn_snapshot && turn_snapshot["current_turn"]
+        owner = session_owner(id)
+        # The file's question only with a live owner: one a dead worker
+        # saved can't be answered (its turn is gone).
         pending = if turn_snapshot
                     current_turn && current_turn["pending_question"]
-                  elsif session.respond_to?(:pending_question)
+                  elsif owner && session.respond_to?(:pending_question)
                     session.pending_question
                   end
-        owner = session_owner(id)
         # A /model in the worker changes it before the file catches up.
         session.model_name = snapshot["model_name"] if snapshot && !snapshot["model_name"].to_s.empty?
         session_json = session_to_json(session, status: displayed_status(session, snapshot, owner: owner), owner: owner)
@@ -673,16 +650,9 @@ module Samagotchi
         unless body.is_a?(Hash)
           return error_response(400, "invalid_json", "invalid JSON body")
         end
-        qid = body["id"] || body[:id] || body["question_id"] || body[:question_id]
-        selected = body["selected"] || body[:selected] || body["selection"] || body[:selection]
-        freeform = body["freeform"] || body[:freeform] || body["other"] || body[:other]
-        # Allow payload nested under answer
-        if body["answer"].is_a?(Hash)
-          ans = body["answer"]
-          qid ||= ans["id"] || ans[:id]
-          selected ||= ans["selected"] || ans[:selected]
-          freeform ||= ans["freeform"] || ans[:freeform]
-        end
+        qid = body["id"]
+        selected = body["selected"]
+        freeform = body["freeform"]
         if qid.to_s.strip.empty?
           return error_response(400, "missing_fields", "id is required")
         end
@@ -817,8 +787,6 @@ module Samagotchi
         end
       rescue SessionManager::OwnedByTUI => e
         error_response(409, "owned_by_tui", e.message)
-      rescue SessionManager::ImagesUnsupported => e
-        error_response(409, "images_unsupported", e.message)
       rescue ArgumentError => e
         error_response(404, "not_found", e.message)
       end

data/lib/samagotchi/web/info_probe.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+
+module Samagotchi
+  module Web
+    # What answers GET /api/info on host:port: the one probe for a running
+    # chi web (chi web's own port check, chi update, chi self).
+    module InfoProbe
+      module_function
+
+      # @return [Hash, :free, :other] a chi web's /api/info; :free when
+      #   nothing listens; :other for anything else (another program, an
+      #   error status, a body that isn't a chi web's)
+      def call(host, port, timeout:)
+        response = Net::HTTP.start(host, port, open_timeout: timeout, read_timeout: timeout) { |http| http.get("/api/info") }
+        verdict(response.code.to_i, response.body)
+      rescue Errno::ECONNREFUSED, Errno::EADDRNOTAVAIL
+        :free
+      rescue StandardError
+        :other
+      end
+
+      def verdict(status, body)
+        info = status == 200 ? JSON.parse(body.to_s) : nil
+        info.is_a?(Hash) && info["app"] == "chi-web" ? info : :other
+      rescue JSON::ParserError
+        :other
+      end
+    end
+  end
+end

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

@@ -2018,7 +2018,7 @@ async function handleSendTurn() {
   } catch (e) {
     echo.remove();
     // The chips stay (uploaded ones keep their ref) for another try.
-    if (/images_unsupported|bad_image|too_large|restart it/.test(e.message)) {
+    if (/bad_image|too_large/.test(e.message)) {
       alert(e.message);
       return;
     }

data/lib/samagotchi/web/public/index.html

@@ -482,6 +482,7 @@ body.stage-view #dock,body.stage-view #dock:focus-within{background:transparent;
 .ts-trail-item{flex:none;max-width:36ch;overflow:hidden;text-overflow:ellipsis}
 .ts-trail-item.error{color:var(--danger-text)}
 .ts-trail-item.warn{color:var(--warn-text)}
+.ts-trail-item.info,.ts-trail-item.steer{color:var(--accent)}
 .ts-trail-item.none{font-style:italic}
 /* A card waits: the tool row and trail give it their room. */
 .turn-stage.waiting .ts-now,.turn-stage.waiting .ts-trail{display:none}

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

@@ -4,6 +4,7 @@
 // covers the rules; stage_view.js draws them.
 import { toolName } from "./activity.js";
 import { splitSentences } from "./sentences.js";
+import { hookNoticeLabel } from "./turn_events.js";
 
 const READ_LIKE = new Set(["read", "memory_read", "web_fetch", "task_get", "task_list", "list_sessions"]);
 const EDITS = new Set(["edit", "write", "memory_write"]);
@@ -48,12 +49,19 @@ export function plainHeadline(line) {
 
 // The step's newest narration sentence, as plain text: the end of a
 // finished text is a boundary (its last line may have no period), a live
-// one's not yet. A sentence that is only markdown syntax is skipped.
+// one's not yet. A sentence that is only markdown syntax is skipped, and so
+// is code: the lines between a fence and its close (or the end, while one
+// is open).
 export function headlineOf(text, done) {
   const { sentences, rest } = splitSentences(text, { atEnd: true });
-  const fragment = plainHeadline(rest);
+  let fenced = false;
+  const plain = [];
+  for (const sentence of sentences) {
+    if (/^(```|~~~)/.test(sentence)) fenced = !fenced;
+    else if (!fenced && plainHeadline(sentence)) plain.push(plainHeadline(sentence));
+  }
+  const fragment = fenced ? "" : plainHeadline(rest);
   if (done && fragment) return fragment;
-  const plain = sentences.map(plainHeadline).filter(Boolean);
   if (plain.length) return plain[plain.length - 1];
   return fragment.length > 160 ? fragment : "";
 }
@@ -148,6 +156,17 @@ export function handOffOrder({ prompt = null, block = null, extras = [], answer
 // Where a row app.js would append goes: the stage's extras while a turn is
 // live (and not handing off), else the history; the recap always the
 // history (it is idle-only).
+// What flashes in the trail for a few seconds while the turn runs (the
+// rows themselves go into their step inside the closed cloud): a hook's
+// notice, warn or info, as its row reads, and a plugin's nudge (steer).
+// chi's own asking-again row (a notice with a line and no hook) does not:
+// the status line tells that already. null: nothing flashes.
+export function flashOf(what, data = {}) {
+  if (what === "steer") return { kind: "steer", text: data.source ? `${data.source} nudged the model` : "nudged the model" };
+  if (what !== "notice" || !data.hook) return null;
+  return { kind: data.level === "warn" ? "warn" : "info", text: data.line || `${hookNoticeLabel(data.hook)}: ${data.text || ""}` };
+}
+
 export function placeFor({ live, handingOff, kind }) {
   if (kind === "recap") return "history";
   return live && !handingOff ? "stage" : "history";

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

@@ -11,7 +11,7 @@
 // reload. Slots are patched in place, never rebuilt from HTML: a selection
 // and annotate survive. The rules are pure in stage_model.js.
 import { createTurnView } from "./turn_view.js";
-import { handOffDue, handOffOrder, headlineOf, inUseFrom, isPlain, liveSlots, placeFor } from "./stage_model.js";
+import { flashOf, handOffDue, handOffOrder, headlineOf, inUseFrom, isPlain, liveSlots, placeFor } from "./stage_model.js";
 import { formatDuration } from "./timing.js";
 
 const COLLAPSE_KEY = "chi_stage_collapsed";
@@ -27,6 +27,9 @@ const PENDING = ".bubble.question:not(.answered):not(.cancelled), .bubble.contin
 // and never holds the hand-off (a turn cut short can leave it open).
 const ASKS = ".plugin-card[data-in-turn] .card-action";
 const MARKS = { answered: "✓", canceled: "■", failed: "✕" };
+// The mark of a flash in the trail: a warn notice, a hook's info notice, a
+// plugin's nudge (steer).
+const FLASH_MARKS = { warn: "⚠", info: "ℹ", steer: "↪" };
 
 function node(tag, cls, parent = null) {
   const el = document.createElement(tag);
@@ -95,7 +98,7 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
   let startedAt = 0;
   let endedAt = 0;
   let thinkingLine = null; // { step, text } from the live step's ticker
-  let flash = null; // { text, until } a warn notice in the trail
+  let flash = null; // { kind, text, until } a notice or nudge in the trail
   let collapsed = readCollapsed();
   let cloudOpen = false;
   let rafPending = false;
@@ -236,12 +239,12 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
   }
 
   function drawTrail(items) {
-    const flashing = flash && flash.until > Date.now() ? flash.text : "";
-    const key = JSON.stringify([flashing, items]);
+    const flashing = flash && flash.until > Date.now() ? flash : null;
+    const key = JSON.stringify([flashing?.kind, flashing?.text, items]);
     if (shown.trail === key) return;
     shown.trail = key;
     trail.replaceChildren();
-    if (flashing) node("span", "ts-trail-item warn", trail).textContent = `⚠ ${flashing}`;
+    if (flashing) node("span", `ts-trail-item ${flashing.kind}`, trail).textContent = `${FLASH_MARKS[flashing.kind]} ${flashing.text}`;
     for (const item of items) {
       const failed = item.status === "error";
       const el = node("span", `ts-trail-item${failed ? " error" : ""}`, trail);
@@ -250,6 +253,15 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
     if (!flashing && !items.length) node("span", "ts-trail-item none", trail).textContent = "no tool calls yet";
   }
 
+  // One line in the trail for FLASH_MS, ahead of the calls (a newer flash
+  // takes its place).
+  function flashTrail(what) {
+    if (!what) return;
+    flash = { ...what, until: Date.now() + FLASH_MS };
+    scheduleRefresh();
+    setTimeout(scheduleRefresh, FLASH_MS + 50);
+  }
+
   function drawTicks(list) {
     list.forEach((tick, i) => {
       let el = ticks.children[i];
@@ -540,15 +552,18 @@ export function createStageView({ historyEl, appendToHistory, isNearBottom: hist
       startWatch();
       return kept;
     },
+    // A hook's notice and a plugin's nudge go into their step inside the
+    // closed cloud; they flash in the trail meanwhile (flashOf).
     notice(data) {
       const placed = view.notice(data);
-      if (placed && data.level === "warn") {
-        flash = { text: data.line || data.text || "", until: Date.now() + FLASH_MS };
-        setTimeout(scheduleRefresh, FLASH_MS + 50);
-      }
+      if (placed) flashTrail(flashOf("notice", data));
+      return placed;
+    },
+    steer(data) {
+      const placed = view.steer(data);
+      if (placed) flashTrail(flashOf("steer", data));
       return placed;
     },
-    steer: (data) => view.steer(data),
     // A warn card (a plugin's warning) stays in sight: false puts it in the
     // extras (place), not in its step inside the closed cloud.
     card: (el) => !el.classList.contains("warn") && view.card(el),

data/lib/samagotchi/web/server.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 require "json"
-require "net/http"
 require "rack"
 require "rackup/handler/webrick"
 require "uri"
 require "webrick"
 
 require_relative "app"
+require_relative "info_probe"
 require_relative "lan"
 require_relative "qr"
 require_relative "session_hub"
@@ -206,21 +206,18 @@ module Samagotchi
       # ?dir, :free when nothing listens, :other for anything else (an older
       # chi web, another program).
       def self.probe(host, port, timeout: PROBE_TIMEOUT)
-        response = Net::HTTP.start(host, port, open_timeout: timeout, read_timeout: timeout) { |http| http.get("/api/info") }
-        probe_verdict(response.code.to_i, response.body)
-      rescue Errno::ECONNREFUSED, Errno::EADDRNOTAVAIL
-        :free
-      rescue StandardError
-        :other
+        knows_dir(InfoProbe.call(host, port, timeout: timeout))
       end
 
       def self.probe_verdict(status, body)
-        info = status == 200 ? JSON.parse(body.to_s) : nil
-        info.is_a?(Hash) && info["app"] == "chi-web" && Array(info["features"]).include?("dir") ? info : :other
-      rescue JSON::ParserError
-        :other
+        knows_dir(InfoProbe.verdict(status, body))
       end
 
+      def self.knows_dir(info)
+        info.is_a?(Hash) && !Array(info["features"]).include?("dir") ? :other : info
+      end
+      private_class_method :knows_dir
+
       # What a phone needs: the LAN link with the token, the warnings, and
       # the link's QR code (at a terminal only).
       def self.lan_lines(ip:, port:, token:, others: [], public: false, qr: $stdout.tty?)

data/lib/samagotchi/web/session_hub.rb

@@ -7,6 +7,7 @@ require "time"
 require_relative "../session"
 require_relative "../session_manager"
 require_relative "../bridge_client"
+require_relative "../worker_sidecar"
 require_relative "../log"
 require_relative "session_summary"
 
@@ -20,7 +21,7 @@ module Samagotchi
     # unlink bump the parent dir's mtime, so one stat of the state dir says
     # "some session file changed" and one stat of `<id>/` says "recap.json
     # or bridge.json appeared, changed or went". Nothing in-place is
-    # watched: the pid file and owner.lock are read by the owner probes.
+    # watched: owner.lock is read by the owner probes.
     #
     # #scan does one pass and is driven by the tick thread (#start) or by a
     # spec. Scan, #touch, the projection and the deliveries all run under
@@ -127,8 +128,10 @@ module Samagotchi
       # 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)
+        return nil unless Session.valid_id?(id)
+
         @monitor.synchronize do
-          path = File.join(@state_dir, "#{id}#{Session::FILE_EXT}")
+          path = Session.session_file(id, state_dir: @state_dir)
           if File.file?(path)
             @sessions[id] ||= Entry.new
             refresh(id, probe: true)
@@ -220,7 +223,7 @@ module Samagotchi
         @dir_mtime = dir_stat.mtime
         on_disk = Dir.glob(File.join(@state_dir, "*#{Session::FILE_EXT}")).to_h do |path|
           [File.basename(path, Session::FILE_EXT), path]
-        end
+        end.select { |id, _| Session.valid_id?(id) }
         (@sessions.keys - on_disk.keys).each { |id| drop(id) }
         on_disk.each_key { |id| @sessions[id] ||= Entry.new }
       end
@@ -231,7 +234,7 @@ module Samagotchi
       # and when its folder changed (a new owner.lock, a bridge.json).
       def refresh(id, probe: false)
         entry = @sessions[id]
-        path = File.join(@state_dir, "#{id}#{Session::FILE_EXT}")
+        path = Session.session_file(id, state_dir: @state_dir)
         stat = begin
           File.stat(path)
         rescue SystemCallError
@@ -305,9 +308,7 @@ module Samagotchi
       end
 
       def bridge_started_at(dir)
-        JSON.parse(File.read(File.join(dir, BridgeClient::SIDECAR_FILE)))["started_at"]
-      rescue StandardError
-        nil
+        WorkerSidecar.read(dir)&.started_at
       end
 
       def emit(type, data)

data/lib/samagotchi/web/session_summary.rb

@@ -5,6 +5,7 @@ require_relative "../recap_store"
 require_relative "../archive_store"
 require_relative "../session_metrics"
 require_relative "../bridge_client"
+require_relative "../worker_sidecar"
 require_relative "../bridge/pending_card"
 
 module Samagotchi
@@ -60,8 +61,8 @@ module Samagotchi
           bridge_up: up,
           # For the tab's notifications (notify.js): an open question, the
           # running turn's open card with actions, and how the last turn
-          # ended.
-          pending_question: pending_question_for(session),
+          # ended. A question saved by a worker that died is not open.
+          pending_question: owner ? pending_question_for(session) : nil,
           pending_card: up ? Bridge::PendingCard.read(session_dir) : nil,
           last_turn: session.respond_to?(:last_turn) ? session.last_turn : nil
         }
@@ -89,7 +90,7 @@ module Samagotchi
       # @return [Boolean] the sidecar file is there and the session has a
       #   live owner (the file alone says nothing: the worker may be gone)
       def bridge_up?(session_dir, owner)
-        !owner.nil? && File.file?(File.join(session_dir, BridgeClient::SIDECAR_FILE))
+        !owner.nil? && File.file?(WorkerSidecar.path(session_dir))
       rescue StandardError
         false
       end

data/lib/samagotchi/web/token.rb

@@ -2,6 +2,7 @@
 
 require "fileutils"
 require "securerandom"
+require_relative "../atomic_file"
 
 require_relative "../session"
 
@@ -53,12 +54,8 @@ module Samagotchi
       def write(path, token)
         dir = File.dirname(path)
         FileUtils.mkdir_p(dir, mode: 0o700)
-        tmp = File.join(dir, ".#{File.basename(path)}.#{Process.pid}.#{SecureRandom.hex(4)}")
-        File.open(tmp, File::WRONLY | File::CREAT | File::EXCL, 0o600) { |io| io.write("#{token}\n") }
-        File.rename(tmp, path)
+        AtomicFile.write(path, "#{token}\n", perm: 0o600)
         token
-      ensure
-        FileUtils.rm_f(tmp) if tmp && File.exist?(tmp)
       end
 
       # The token a running server checks against: the file is re-read when