samagotchi 0.123.0 → 0.125.0

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

@@ -36,7 +36,8 @@ enum ChiError: Error, CustomStringConvertible {
 }
 
 /// One session from `chi sessions list --format json`: a live one, or a
-/// recent stopped one (listed below the live ones; a message wakes it).
+/// recent stopped one (listed below the live ones; a message wakes it), on
+/// this Mac or on a remote (`chi --remote NAME sessions list`).
 struct LiveSession: Decodable, Identifiable, Equatable {
   let id: String
   let desc: String?
@@ -45,6 +46,9 @@ struct LiveSession: Decodable, Identifiable, Equatable {
   let owner: String?
   let updatedAt: String?
   var recent = false
+  /// The remote it was listed on (set by the helper, never decoded); nil:
+  /// this Mac.
+  var remote: String?
 
   enum CodingKeys: String, CodingKey {
     case id, desc, cwd, busy, owner
@@ -54,7 +58,13 @@ struct LiveSession: Decodable, Identifiable, Equatable {
   /// Only UUID-shaped ids go into chi's argv, so nothing can turn into a flag.
   var valid: Bool { UUID(uuidString: id) != nil }
 
-  var shortCwd: String { cwd.map(Self.shorten) ?? "" }
+  /// The row's key in the selection, ⌘ numbers and the remembered choice:
+  /// "studio:<id>" on a remote, the plain id on this Mac (so a choice
+  /// remembered before remotes still counts).
+  var key: String { remote.map { "\($0):\(id)" } ?? id }
+
+  /// A remote's home may differ from this Mac's: its path stays whole.
+  var shortCwd: String { remote == nil ? cwd.map(Self.shorten) ?? "" : cwd ?? "" }
 
   /// A path with the home folder as "~".
   static func shorten(_ path: String) -> String {
@@ -83,7 +93,43 @@ struct LiveSession: Decodable, Identifiable, Equatable {
   }
 }
 
+/// The remotes `chi remote ls` keeps (`chi remote add`): a name goes into
+/// argv only when it came from that answer and passes chi's own rule.
+enum Remotes {
+  /// One row of `chi remote ls --format json`; the token itself never
+  /// leaves chi, only whether there is one.
+  struct Entry: Decodable {
+    let name: String
+    let token: Bool?
+  }
+
+  /// chi's `Remotes::NAME`: no leading "-", so never a flag.
+  static func valid(_ name: String) -> Bool {
+    name.range(of: "\\A[A-Za-z0-9][A-Za-z0-9_-]{0,39}\\z", options: .regularExpression) != nil
+  }
+
+  /// The names with a token (one without can't reach that chi web), in
+  /// chi's order.
+  static func names(_ entries: [Entry]) -> [String] {
+    var seen = Set<String>()
+    return entries.filter { $0.token == true && valid($0.name) && seen.insert($0.name).inserted }.map(\.name)
+  }
+}
+
+/// A remote's part of the panel: its rows, or why there are none.
+struct RemoteSection: Equatable {
+  let name: String
+  var sessions: [LiveSession] = []
+  /// "studio: no answer within 4 s", or the first line of chi's stderr.
+  var error: String?
+  var loading = true
+}
+
 final class ChiRunner {
+  /// A remote's two lists together: chi's own open timeout is 5 s, so a
+  /// down host is stopped here before chi says anything.
+  static let remoteBudget: TimeInterval = 4
+
   static let supportDir = NSString(string: "~/Library/Application Support/Chi Helper").expandingTildeInPath
   static let launchPath = supportDir + "/launch.json"
 
@@ -125,30 +171,75 @@ final class ChiRunner {
       completion(.failure(.failed("\(error)"))); return
     }
 
+    var env = ProcessInfo.processInfo.environment.merging(config.env ?? [:]) { _, baked in baked }
+    // chi reads CHI_REMOTE for every call without --remote: one from the
+    // shell would send this Mac's rows to a remote. --remote is the only way.
+    env["CHI_REMOTE"] = nil
     ProcessRunner.run(executable: config.argv[0], args: Array(config.argv.dropFirst()) + args,
-                      env: ProcessInfo.processInfo.environment.merging(config.env ?? [:]) { _, baked in baked },
-                      stdin: stdin, timeout: timeout ?? self.timeout, queue: queue, completion: completion)
+                      env: env, stdin: stdin, timeout: timeout ?? self.timeout, queue: queue, completion: completion)
   }
 
   /// The live sessions, oldest started first, then up to +recentCount+
   /// stopped ones, newest first. The live order is by creation so ⌘1…⌘9
   /// stay on their sessions as turns update them; a new one comes last.
   /// A session a chi REPL holds is in neither: it takes no notes or
-  /// messages. A failed second call just leaves "recent" empty.
-  func sessions(recentCount: Int = 3, completion: @escaping (Result<[LiveSession], ChiError>) -> Void) {
-    list(["--live", "--sort", "created_at", "--order", "asc"]) { result in
+  /// messages. A failed second call just leaves "recent" empty. Calls
+  /// back on +queue+ (a headless seam waits on another one).
+  func sessions(recentCount: Int = 3, queue: DispatchQueue = .main,
+                completion: @escaping (Result<[LiveSession], ChiError>) -> Void) {
+    list(Self.liveFlags, queue: queue) { result in
       guard case .success(let live) = result else { completion(result); return }
-      self.list(["--limit", "20"]) { recent in
-        let liveIds = Set(live.map(\.id))
-        let stopped = ((try? recent.get()) ?? [])
-          .filter { $0.owner == nil && !liveIds.contains($0.id) }
-          .prefix(recentCount)
-          .map { session -> LiveSession in var session = session; session.recent = true; return session }
-        completion(.success(live + stopped))
+      self.list(Self.recentFlags, queue: queue) { recent in
+        completion(.success(Self.rows(live: live, recent: recent, recentCount: recentCount)))
       }
     }
   }
 
+  private static let liveFlags = ["--live", "--sort", "created_at", "--order", "asc"]
+  private static let recentFlags = ["--limit", "20"]
+
+  /// The live rows, then up to +recentCount+ of the recent list that are
+  /// neither live nor a REPL's; a failed recent list adds none.
+  private static func rows(live: [LiveSession], recent: Result<[LiveSession], ChiError>, recentCount: Int) -> [LiveSession] {
+    let liveIds = Set(live.map(\.id))
+    let stopped = ((try? recent.get()) ?? [])
+      .filter { $0.owner == nil && !liveIds.contains($0.id) }
+      .prefix(recentCount)
+      .map { session -> LiveSession in var session = session; session.recent = true; return session }
+    return live + stopped
+  }
+
+  /// `chi remote ls --format json`: the remotes with a token, in chi's
+  /// order; none when it fails (an older chi has no `remote`).
+  func remotes(queue: DispatchQueue = .main, completion: @escaping ([String]) -> Void) {
+    run(["remote", "ls", "--format", "json"], queue: queue) { result in
+      guard case .success(let r) = result, r.status == 0, !r.timedOut,
+            let entries = try? JSONDecoder().decode([Remotes.Entry].self, from: Data(r.stdout.utf8)) else {
+        completion([]); return
+      }
+      completion(Remotes.names(entries))
+    }
+  }
+
+  /// A remote's rows as sessions(...) lists this Mac's, each tagged with
+  /// +name+. Its two lists run at once under one budget (each is a chi boot
+  /// and two requests); the failure is the panel's line for that remote.
+  func sessions(remote name: String, recentCount: Int = 3, queue: DispatchQueue = .main,
+                completion: @escaping (Result<[LiveSession], ChiError>) -> Void) {
+    var live: Result<[LiveSession], ChiError>?
+    var recent: Result<[LiveSession], ChiError>?
+    // Both answer on +queue+, one at a time.
+    let finish = {
+      guard let live, let recent else { return }
+      completion(live.map { rows in
+        Self.rows(live: rows, recent: recent, recentCount: recentCount)
+          .map { session -> LiveSession in var session = session; session.remote = name; return session }
+      })
+    }
+    list(Self.liveFlags, remote: name, queue: queue) { live = $0; finish() }
+    list(Self.recentFlags, remote: name, queue: queue) { recent = $0; finish() }
+  }
+
   /// The model a new session starts on (`chi self --model`: the config's
   /// default, as chi resolves it), or nil when none is configured or chi
   /// can't say. Only a single line counts: nothing that looks like a whole
@@ -180,17 +271,38 @@ final class ChiRunner {
     }
   }
 
-  private func list(_ flags: [String], completion: @escaping (Result<[LiveSession], ChiError>) -> Void) {
+  /// @param remote a remote's name: `--remote NAME` first, the remote
+  ///   budget, and its two failure lines (no answer in time, or the first
+  ///   line of chi's stderr: it names the remote and why)
+  private func list(_ flags: [String], remote: String? = nil, queue: DispatchQueue = .main,
+                    completion: @escaping (Result<[LiveSession], ChiError>) -> Void) {
+    let prefix = remote.map { ["--remote", $0] } ?? []
+    let timeout = remote == nil ? self.timeout : Self.remoteBudget
     // Every project's sessions: the helper isn't in any one project (an
     // older chi ignores the flag).
-    run(["sessions", "list"] + flags + ["--scope=all", "--format", "json"]) { result in
+    run(prefix + ["sessions", "list"] + flags + ["--scope=all", "--format", "json"], timeout: timeout,
+        queue: queue) { result in
       switch result {
       case .failure(let error): completion(.failure(error))
       case .success(let r):
-        if r.timedOut { completion(.failure(.failed("chi sessions list took over \(Int(self.timeout)) s"))); return }
+        if r.timedOut {
+          let message = remote.map { "\($0): no answer within \(Int(timeout)) s" } ?? "chi sessions list took over \(Int(timeout)) s"
+          completion(.failure(.failed(message)))
+          return
+        }
         guard r.status == 0, let data = r.stdout.data(using: .utf8),
               let sessions = try? JSONDecoder().decode([LiveSession].self, from: data) else {
           let detail = r.stderr.isEmpty ? r.stdout : r.stderr
+          if let remote {
+            // chi's own line names the remote and why; Ruby's warnings
+            // ("…: warning: …") before it aren't the reason.
+            let line = r.status == 0 ? nil : detail.split(whereSeparator: \.isNewline).map(String.init)
+              .first { !$0.contains("warning:") && !$0.trimmingCharacters(in: .whitespaces).isEmpty }
+            let fallback = r.status == 0 ? "\(remote): chi sessions list answered no session list"
+                                         : "\(remote): chi sessions list failed (exit \(r.status))"
+            completion(.failure(.failed(line ?? fallback)))
+            return
+          }
           completion(.failure(.failed("chi sessions list failed (exit \(r.status)): \(detail.prefix(400))")))
           return
         }

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

@@ -88,9 +88,10 @@ enum ImageIntake {
   static let sentMaxAge: TimeInterval = 7 * 86_400
 
   /// The paths an agent paste names: an image the helper wrote is copied to
-  /// sentDir first (the send deletes the original), with no spaces in its
-  /// name; a file of the user's is named as it is. Call before any send
-  /// job starts. An image that can't be copied is left out.
+  /// sentDir first (the helper deletes the original after the send; chi's
+  /// send copies what it reads and leaves it), with no spaces in its name;
+  /// a file of the user's is named as it is. Call before any send job
+  /// starts. An image that can't be copied is left out.
   static func keepForPaste(_ images: [PanelImage]) -> [String] {
     images.compactMap { image in
       guard image.temp else { return image.url.path }