samagotchi 0.11.0 → 0.13.0

data/lib/samagotchi/cli/parent_wait.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "../session"
+require_relative "../reply_wait"
+require_relative "../parent_report"
+require_relative "exit"
+
+module Samagotchi
+  module CLI
+    # The parent-agent side shared by `chi send --wait` and `chi answer`:
+    # --format json's one object whatever the end, the session id resolved
+    # for it, and the wait for what comes next, reported the ParentReport
+    # way (Ctrl-C included). The including class (a CLI::Command) defines
+    # #parse (options, or an exit status) and #run_parsed(options), sets
+    # @stdout, @stderr and @state_dir, and may override the constants
+    # (specs stub them on the class).
+    module ParentWait
+      POLL_INTERVAL = ReplyWait::POLL_INTERVAL
+      # No live worker this long while waiting: it died before it could mark
+      # the session (a worker takes well under a second to start).
+      WORKER_GONE_AFTER = 5
+      FORMATS = %w[text json].freeze
+
+      # @return [Integer] the exit status
+      def run
+        options = parse
+        return options if options.is_a?(Integer)
+
+        @json = options[:format] == "json"
+        # With --format json stdout is one JSON object, whatever the end: a
+        # failure before the wait is reported from stderr's last line.
+        @stderr = ParentReport::LastLine.new(@stderr) if @json
+        status = run_parsed(options)
+        if @json && !@reported && status == 1
+          detail = @stderr.last.to_s.delete_prefix("#{command_name}: ")
+          @stdout.puts(ParentReport.error_line(detail, session_id: @session_id))
+          @stdout.flush
+        end
+        status
+      end
+
+      private
+
+      # The full id of +given+ (an id or a prefix), kept for the JSON
+      # error line; nil after the error line.
+      # @return [String, nil]
+      def resolve(given)
+        id = Session.resolve_id(given, state_dir: @state_dir)
+        Session.load(id, state_dir: @state_dir)
+        @session_id = id
+      rescue ArgumentError => e
+        error_line("#{command_name}: #{e.is_a?(Session::AmbiguousId) ? e.message : "no session #{given}"}")
+        nil
+      end
+
+      # Wait for the session's next reply past +cursor+ (ReplyWait) and
+      # report it. Ctrl-C leaves the turn running (130).
+      # @param owner_grace [Numeric, nil] seconds with no live worker before
+      #   it counts as gone; nil waits for whatever wakes one
+      # @return [Integer] the exit status
+      def wait_for_reply(id, cursor:, baseline:, timeout:, owner_grace: self.class::WORKER_GONE_AFTER)
+        result = ReplyWait.call(id, state_dir: @state_dir, cursor: cursor, timeout: timeout, baseline: baseline,
+                                    owner_grace: owner_grace, poll_interval: self.class::POLL_INTERVAL)
+        result.text = result.text&.dup&.force_encoding(Encoding::UTF_8)&.scrub
+        @reported = true
+        ParentReport.report(result, session_id: id, stdout: @stdout, stderr: @stderr, command: command_name,
+                                    json: @json, timeout: timeout)
+      rescue Interrupt
+        if @json
+          @stdout.puts(ParentReport.json_line(ReplyWait::Result.new(status: :canceled), session_id: id))
+          @stdout.flush
+          @reported = true
+        end
+        error_line("#{command_name}: still running: chi --attach #{id}")
+        Exit::INTERRUPTED
+      rescue ArgumentError
+        error_line("#{command_name}: the session is gone (deleted while waiting)")
+        Exit::FAILED
+      end
+    end
+  end
+end

data/lib/samagotchi/config.rb

@@ -104,10 +104,14 @@ module Samagotchi
       Entry.new(key: "image.max_bytes",          yaml_path: %w[image max_bytes],          type: :integer, default: 3_750_000,       expose: %i[env config]),
       Entry.new(key: "image.max_per_request",    yaml_path: %w[image max_per_request],    type: :integer, default: 20,              expose: %i[env config]),
 
-      Entry.new(key: "guardrails.enabled",       yaml_path: %w[guardrails enabled],       type: :bool,   default: true,             expose: %i[env config]),
+      # The guardrails settings are config.yml only: a parent agent must not switch a child's guardrails off from its
+      # own environment (SAMAGOTCHI_GUARDRAILS_ENABLED=false). SessionManager.spawn_options unsets them for a worker too.
+      Entry.new(key: "guardrails.enabled",       yaml_path: %w[guardrails enabled],       type: :bool,   default: true,             expose: %i[config]),
       # Which models get the rules with `models: small` (Guardrails::ModelSize): auto (32B or less by the name's size, an MoE's
       # active size counting), globs on the bare model name or its key, "|"-separated (a YAML list works too), or "" ([]) for none.
-      Entry.new(key: "guardrails.small_models",  yaml_path: %w[guardrails small_models],  type: :string, default: "auto",           expose: %i[env config]),
+      Entry.new(key: "guardrails.small_models",  yaml_path: %w[guardrails small_models],  type: :string, default: "auto",           expose: %i[config]),
+      # What `chi answer` lets a parent agent allow on an approval: off (deny only) or once ("Allow once", never a wider scope).
+      Entry.new(key: "guardrails.parent_approvals", yaml_path: %w[guardrails parent_approvals], type: :enum, default: "off", expose: %i[config], enum_values: %w[off once]),
 
       Entry.new(key: "log.file",                 yaml_path: %w[log file],                 type: :string, default: nil,              expose: %i[env config cli]),
       Entry.new(key: "log.disable",              yaml_path: %w[log disable],              type: :bool,   default: false,            expose: %i[env config cli]),
@@ -156,6 +160,8 @@ module Samagotchi
       Entry.new(key: "execute.truncate_at_bytes",       yaml_path: %w[execute truncate_at_bytes],       type: :integer, default: 65_536, expose: %i[env config cli]),
       Entry.new(key: "execute.preview_bytes",           yaml_path: %w[execute preview_bytes],           type: :integer, default: 12_288, expose: %i[env config cli]),
       Entry.new(key: "execute.telemetry_threshold_pct", yaml_path: %w[execute telemetry_threshold_pct], type: :integer, default: 80,     expose: %i[env config cli]),
+      # Seconds one execute command may run before it is stopped (Tools::Execute::TIMEOUT_SEC).
+      Entry.new(key: "execute.timeout_sec",             yaml_path: %w[execute timeout_sec],             type: :integer, default: 30,     expose: %i[env config cli]),
 
       Entry.new(key: "web.port",                 yaml_path: %w[web port],                 type: :integer, default: 4567,            expose: %i[env config cli]),
       Entry.new(key: "web.host",                 yaml_path: %w[web host],                 type: :string, default: "127.0.0.1",     expose: %i[env config cli]),
@@ -695,18 +701,7 @@ module Samagotchi
 
     def hosts_config(env: ENV, path: global_path(env: env))
       data = read_yaml(env: env, path: path)
-      raw_hosts = data[HOSTS_KEY] if data.is_a?(Hash)
-
-      # ENV override: SAMAGOTCHI_HOSTS_JSON (used to propagate to workers)
-      env_json = env["SAMAGOTCHI_HOSTS_JSON"].to_s.strip
-      unless env_json.empty?
-        begin
-          parsed_env = JSON.parse(env_json)
-          raw_hosts = parsed_env if parsed_env.is_a?(Hash)
-        rescue StandardError
-          nil
-        end
-      end
+      raw_hosts = hosts_source(data, env)
 
       normalized = {}
       if raw_hosts.is_a?(Hash)
@@ -726,10 +721,8 @@ module Samagotchi
           port = raw_cfg["port"] || raw_cfg[:port]
           transport = raw_cfg["transport"] || raw_cfg[:transport]
           api = raw_cfg["api"] || raw_cfg[:api]
-          enabled = raw_cfg.key?("enabled") ? raw_cfg["enabled"] : (raw_cfg.key?(:enabled) ? raw_cfg[:enabled] : true)
-          if enabled == false || enabled.to_s.strip.downcase == "false"
-            next
-          end
+          next if host_disabled?(raw_cfg)
+
           url = (raw_cfg["url"] || raw_cfg[:url]).to_s.strip
           api_key_env = (raw_cfg["api_key_env"] || raw_cfg[:api_key_env]).to_s.strip
           # Kept as written; ModelProfile.resolve warns about an unknown one.
@@ -822,6 +815,42 @@ module Samagotchi
       {}
     end
 
+    # The names (lowercased) of the hosts entries with enabled: false, which
+    # hosts_config leaves out. Read from the same source: config.yml's
+    # hosts:, or SAMAGOTCHI_HOSTS_JSON in a worker.
+    # @return [Array<String>]
+    def disabled_host_names(env: ENV, path: global_path(env: env))
+      raw = hosts_source(read_yaml(env: env, path: path), env)
+      return [] unless raw.is_a?(Hash)
+
+      raw.filter_map { |name, cfg| name.to_s.strip.downcase if cfg.is_a?(Hash) && host_disabled?(cfg) }
+    rescue StandardError
+      []
+    end
+
+    # config.yml's hosts: as written, or the SAMAGOTCHI_HOSTS_JSON override
+    # a worker inherits from its parent.
+    def hosts_source(data, env)
+      raw = data[HOSTS_KEY] if data.is_a?(Hash)
+      env_json = env["SAMAGOTCHI_HOSTS_JSON"].to_s.strip
+      return raw if env_json.empty?
+
+      parsed = begin
+        JSON.parse(env_json)
+      rescue StandardError
+        nil
+      end
+      parsed.is_a?(Hash) ? parsed : raw
+    end
+    private_class_method :hosts_source
+
+    # enabled: false (or "false", any case) in a hosts entry.
+    def host_disabled?(cfg)
+      enabled = cfg.key?("enabled") ? cfg["enabled"] : (cfg.key?(:enabled) ? cfg[:enabled] : true)
+      enabled == false || enabled.to_s.strip.downcase == "false"
+    end
+    private_class_method :host_disabled?
+
     # Resolve the `recap:` section through the Config registry so scalar
     # recap settings share the single precedence path (CLI > ENV > file >
     # default). Returns false when explicitly disabled (file `recap: false`
@@ -908,6 +937,9 @@ module Samagotchi
                        "profile" => v[:profile], "first_token_timeout" => v[:first_token_timeout],
                        "vision" => v[:vision], "sampling" => v[:sampling], "thinking" => v[:thinking]&.to_s).compact
       end
+      # Disabled hosts travel as just that, so a worker refuses "box:x"
+      # the way its parent does instead of sending it to the default host.
+      disabled_host_names(env: env, path: path).grep(HOST_NAME_RE).each { |name| simple[name] ||= { "enabled" => false } }
       JSON.generate(simple)
     rescue StandardError
       nil

data/lib/samagotchi/desktop/macos/App.swift

@@ -3,7 +3,8 @@
 // the clipboard (a screenshot too). No Dock icon (LSUIElement); it stays
 // running after the first launch. `ChiHelper --login on|off|status` (run
 // directly by chi desktop) manages the login item and exits;
-// `ChiHelper --kitty list|send` is the kitty targets' seam (Kitty.swift).
+// `ChiHelper --kitty list|send` is the kitty targets' seam (Kitty.swift),
+// `ChiHelper --model-pick` the model chooser's (Models.swift).
 import AppKit
 import ServiceManagement
 
@@ -101,6 +102,9 @@ struct ChiHelperMain {
     if args.count >= 2, args[1] == "--kitty" {
       exit(kittyCommand(Array(args.dropFirst(2))))
     }
+    if args.count >= 2, args[1] == "--model-pick" {
+      exit(modelPickCommand(Array(args.dropFirst(2))))
+    }
     let app = NSApplication.shared
     let delegate = AppDelegate()
     app.delegate = delegate

data/lib/samagotchi/desktop/macos/ChiRunner.swift

@@ -147,6 +147,25 @@ final class ChiRunner {
     }
   }
 
+  /// `chi models --format json`: every host's models and the aliases. Exit
+  /// 1 (no host listed) still prints the default and the warnings. 10 s:
+  /// the boot and chi's own 4 s cap on the hosts, with a margin.
+  func models(completion: @escaping (Result<ModelList, ChiError>) -> Void) {
+    run(["models", "--format", "json"], timeout: 10) { result in
+      switch result {
+      case .failure(let error): completion(.failure(error))
+      case .success(let r):
+        if r.timedOut { completion(.failure(.failed("chi models took over 10 s"))); return }
+        guard r.status == 0 || r.status == 1, let list = ModelList.decode(Data(r.stdout.utf8)) else {
+          let detail = r.stderr.isEmpty ? r.stdout : r.stderr
+          completion(.failure(.failed("chi models failed (exit \(r.status)): \(detail.prefix(300))")))
+          return
+        }
+        completion(.success(list))
+      }
+    }
+  }
+
   private func list(_ flags: [String], completion: @escaping (Result<[LiveSession], ChiError>) -> Void) {
     // Every project's sessions: the helper isn't in any one project (an
     // older chi ignores the flag).

data/lib/samagotchi/desktop/macos/Models.swift

@@ -0,0 +1,238 @@
+// The new session's model: `chi models --format json` (every host's
+// listing and the aliases, the names `--model` takes) and the chooser's pure
+// rules: its rows, search ranking, the remembered pick and the recent picks.
+// The helper never builds or rewrites a name: what a row says is what
+// `chi send --new --model` gets. `ChiHelper --model-pick` is the build
+// spec's seam (stdin: the payload).
+import Foundation
+
+/// `chi models --format json`; printed on exit 1 too (no host listed: the
+/// default alone).
+struct ModelList: Decodable, Equatable {
+  struct Model: Decodable, Equatable {
+    let name: String
+    let host: String
+    let id: String
+    /// An alias of the same name takes it elsewhere: not offered.
+    let shadowedBy: String?
+  }
+
+  struct Alias: Decodable, Equatable {
+    let name: String
+    let ref: String
+    let host: String?
+  }
+
+  let `default`: String?
+  let defaultTyped: String?
+  let defaultHost: String?
+  let models: [Model]
+  let aliases: [Alias]?
+  let warnings: [String]?
+
+  static func decode(_ data: Data) -> ModelList? {
+    let decoder = JSONDecoder()
+    decoder.keyDecodingStrategy = .convertFromSnakeCase
+    return try? decoder.decode(ModelList.self, from: data)
+  }
+
+  /// "default (small → box:gemma)" style: the default as the row shows it.
+  var defaultLabel: String? {
+    guard let name = `default` else { return nil }
+    if let typed = defaultTyped, !typed.isEmpty { return "\(typed) → \(name)" }
+    return name
+  }
+}
+
+/// One line of the chooser. +name+ is what `--model` gets (the default row's
+/// is the default's name, for show: picking it sends no `--model`).
+struct ModelRow: Equatable {
+  enum Kind: String { case standard = "default", listed, alias, typed }
+
+  let kind: Kind
+  let name: String
+  /// The host that listed it ("" when unknown: a recent pick before the list).
+  let host: String
+  /// What the search looks at besides the host: the id, an alias's name
+  /// and target, a typed name.
+  let id: String
+  let label: String
+}
+
+enum ModelPick {
+  static let pickKey = "newSessionModel"
+  static let recentKey = "recentModels"
+  static let maxRecent = 5
+  /// ⌘1…⌘9.
+  static let maxRows = 9
+
+  static func same(_ a: String, _ b: String) -> Bool { a.caseInsensitiveCompare(b) == .orderedSame }
+
+  /// Every name the list offers, default host first, an alias after its
+  /// host's ids; the default itself left out (it is the Default row).
+  static func rows(_ list: ModelList) -> [ModelRow] {
+    let defaultHost = list.defaultHost ?? ""
+    let listed = list.models.filter { $0.shadowedBy == nil }
+    var hosts: [String] = []
+    for host in listed.map(\.host) + (list.aliases ?? []).compactMap(\.host) where !hosts.contains(host) {
+      hosts.append(host)
+    }
+    hosts = hosts.filter { $0 == defaultHost } + hosts.filter { $0 != defaultHost }
+    var rows: [ModelRow] = []
+    for host in hosts {
+      for model in listed where model.host == host {
+        rows.append(ModelRow(kind: .listed, name: model.name, host: host, id: model.id,
+                             label: host == defaultHost ? model.id : "\(host) · \(model.id)"))
+      }
+      for alias in list.aliases ?? [] where alias.host == host {
+        rows.append(ModelRow(kind: .alias, name: alias.name, host: host, id: "\(alias.name) \(alias.ref)",
+                             label: "\(alias.name) → \(alias.ref)"))
+      }
+    }
+    for alias in list.aliases ?? [] where alias.host == nil {
+      rows.append(ModelRow(kind: .alias, name: alias.name, host: "", id: "\(alias.name) \(alias.ref)",
+                           label: "\(alias.name) → \(alias.ref)"))
+    }
+    guard let standard = list.default else { return rows }
+    return rows.filter { !same($0.name, standard) }
+  }
+
+  /// The chooser's rows, at most maxRows: Default first; with no query
+  /// the recent picks still offered (as they are while the list loads),
+  /// then the list; with one, the ranked matches and, when no row is named
+  /// exactly that, the typed name ("not listed").
+  static func chooserRows(list: ModelList?, fallbackDefault: String?, recents: [String], query: String) -> [ModelRow] {
+    let standardName = list?.default ?? fallbackDefault ?? ""
+    let standard = ModelRow(kind: .standard, name: standardName, host: list?.defaultHost ?? "", id: standardName,
+                            label: standardName.isEmpty ? "Default" : "Default (\(list?.defaultLabel ?? standardName))")
+    let all = list.map(rows) ?? []
+    let text = query.trimmingCharacters(in: .whitespacesAndNewlines)
+    var out: [ModelRow] = [standard]
+    if text.isEmpty {
+      for name in recents where !(list != nil && same(name, standardName)) {
+        if let row = all.first(where: { same($0.name, name) }) {
+          out.append(row)
+        } else if list == nil {
+          out.append(ModelRow(kind: .listed, name: name, host: "", id: name, label: name))
+        }
+      }
+      for row in all where !out.contains(where: { same($0.name, row.name) }) { out.append(row) }
+      return Array(out.prefix(maxRows))
+    }
+    let exact = all.contains { same($0.name, text) } || same(text, standardName)
+    let room = maxRows - 1 - (exact ? 0 : 1)
+    out += match(all, query: text).prefix(room)
+    if !exact {
+      out.append(ModelRow(kind: .typed, name: text, host: "", id: text, label: "\(text) — not listed"))
+    }
+    return out
+  }
+
+  /// Rows matching every word of +query+ on the host or the id, ranked
+  /// like the web's picker: substring-only rows first (at a segment start
+  /// cheaper), then subsequences of 3+ characters by their gaps, then the
+  /// shorter id, then list order.
+  static func match(_ rows: [ModelRow], query: String) -> [ModelRow] {
+    let words = query.lowercased().split(whereSeparator: \.isWhitespace).map(String.init)
+    guard !words.isEmpty else { return [] }
+    var found: [(row: ModelRow, index: Int, sub: Bool, cost: Int)] = []
+    for (index, row) in rows.enumerated() {
+      let host = Array(row.host.lowercased()), id = Array(row.id.lowercased())
+      var sub = true, cost = 0, ok = true
+      for word in words {
+        let w = Array(word)
+        let onId = matchWord(w, id), onHost = matchWord(w, host)
+        guard let pick = better(onHost, than: onId) ? onHost : onId else { ok = false; break }
+        sub = sub && pick.sub
+        cost += pick.cost
+      }
+      if ok { found.append((row, index, sub, cost)) }
+    }
+    found.sort { a, b in
+      if a.sub != b.sub { return a.sub }
+      if a.cost != b.cost { return a.cost < b.cost }
+      if a.row.id.count != b.row.id.count { return a.row.id.count < b.row.id.count }
+      return a.index < b.index
+    }
+    return found.map(\.row)
+  }
+
+  private static let separators = Set("/-:._ ")
+
+  private static func matchWord(_ word: [Character], _ text: [Character]) -> (sub: Bool, cost: Int)? {
+    guard !word.isEmpty, word.count <= text.count else { return nil }
+    var best: (sub: Bool, cost: Int)?
+    for i in 0...(text.count - word.count) where Array(text[i..<(i + word.count)]) == word {
+      let cost = i == 0 || separators.contains(text[i - 1]) ? 0 : 2
+      if best == nil || cost < best!.cost { best = (true, cost) }
+      if cost == 0 { break }
+    }
+    if best != nil || word.count < 3 { return best }
+    guard var at = text.firstIndex(of: word[0]) else { return nil }
+    var gaps = 0
+    for k in 1..<word.count {
+      guard let i = text[(at + 1)...].firstIndex(of: word[k]) else { return nil }
+      gaps += i - at - 1
+      at = i
+    }
+    return (false, 10 + gaps)
+  }
+
+  private static func better(_ a: (sub: Bool, cost: Int)?, than b: (sub: Bool, cost: Int)?) -> Bool {
+    guard let a else { return false }
+    guard let b else { return true }
+    return (a.sub && !b.sub) || (a.sub == b.sub && a.cost < b.cost)
+  }
+
+  /// The remembered pick for this open: kept while the list loads, and
+  /// once it is in, only when offered (as the list spells it) or when no
+  /// host listed anything (no way to tell); else the default, with a note.
+  static func keep(_ stored: String?, in list: ModelList?) -> (pick: String?, note: String?) {
+    guard let stored = stored?.trimmingCharacters(in: .whitespacesAndNewlines), !stored.isEmpty else { return (nil, nil) }
+    guard let list else { return (stored, nil) }
+    if let standard = list.default, same(standard, stored) { return (nil, nil) }
+    if let row = rows(list).first(where: { same($0.name, stored) }) { return (row.name, nil) }
+    if list.models.isEmpty { return (stored, nil) }
+    return (nil, "\(stored) isn't listed any more; using the default")
+  }
+
+  /// The recent picks after +name+: it first, no other copy (any case).
+  static func pushRecent(_ list: [String], _ name: String) -> [String] {
+    Array(([name] + list.filter { !same($0, name) }).prefix(maxRecent))
+  }
+}
+
+/// `ChiHelper --model-pick [--query Q] [--recent NAME]... [--stored NAME]
+/// [--push NAME]`: the payload on stdin, the chooser as JSON on stdout
+/// (rows, the kept pick and its note, the recents after --push). Exit 1
+/// when stdin isn't a payload.
+func modelPickCommand(_ args: [String]) -> Int32 {
+  var args = args
+  var query = "", recents: [String] = [], stored: String?, push: String?
+  while !args.isEmpty {
+    let arg = args.removeFirst()
+    switch arg {
+    case "--query" where !args.isEmpty: query = args.removeFirst()
+    case "--recent" where !args.isEmpty: recents.append(args.removeFirst())
+    case "--stored" where !args.isEmpty: stored = args.removeFirst()
+    case "--push" where !args.isEmpty: push = args.removeFirst()
+    default:
+      FileHandle.standardError.write("usage: ChiHelper --model-pick [--query Q] [--recent NAME]... [--stored NAME] [--push NAME]\n".data(using: .utf8)!)
+      return 2
+    }
+  }
+  guard let list = ModelList.decode(FileHandle.standardInput.readDataToEndOfFile()) else {
+    FileHandle.standardError.write("not a chi models payload\n".data(using: .utf8)!)
+    return 1
+  }
+  let rows = ModelPick.chooserRows(list: list, fallbackDefault: nil, recents: recents, query: query)
+  let kept = ModelPick.keep(stored, in: list)
+  var out: [String: Any] = [
+    "rows": rows.map { ["kind": $0.kind.rawValue, "name": $0.name, "label": $0.label] },
+    "pick": kept.pick ?? NSNull(), "note": kept.note ?? NSNull(), "warnings": list.warnings ?? [],
+  ]
+  if let push { out["recent"] = ModelPick.pushRecent(recents, push) }
+  let data = try! JSONSerialization.data(withJSONObject: out, options: [.sortedKeys])
+  print(String(decoding: data, as: UTF8.self))
+  return 0
+}