samagotchi 0.66.0 → 0.68.0

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

@@ -1,7 +1,8 @@
 // Agent CLIs (claude, codex, …) in kitty windows as panel targets, through
 // the kitty binary's remote control (`kitty @ --to unix:<socket> …`). The
 // settings come from launch.json's "kitty" section (chi desktop bakes it
-// from config.yml's kitty:); without it there are no kitty targets.
+// from config.yml's kitty:); without it there are no kitty targets. One of
+// the AgentTerminals (AgentTerminal.swift).
 import Foundation
 
 struct KittySettings: Decodable, Equatable {
@@ -15,45 +16,6 @@ struct KittySettings: Decodable, Equatable {
   }
 }
 
-/// One kitty window running an agent: `<socket>#<id>` keys it.
-struct KittyWindow: Identifiable, Equatable {
-  let socket: String
-  let windowId: Int
-  let agent: String
-  let title: String
-  let cwd: String
-
-  var id: String { key }
-  var key: String { "\(socket)#\(windowId)" }
-  var shortCwd: String { LiveSession.shorten(cwd) }
-  /// "claude · samagotchi": the agent and its folder.
-  var label: String {
-    let folder = (cwd as NSString).lastPathComponent
-    return folder.isEmpty ? agent : "\(agent) · \(folder)"
-  }
-
-  /// Parses a key back into its socket and window id.
-  static func parse(key: String) -> (socket: String, windowId: Int)? {
-    guard let hash = key.lastIndex(of: "#"), let id = Int(key[key.index(after: hash)...]) else { return nil }
-    let socket = String(key[..<hash])
-    return socket.isEmpty ? nil : (socket, id)
-  }
-}
-
-enum KittyError: Error, CustomStringConvertible {
-  case notUnix(String)
-  case windowClosed
-  case failed(String)
-
-  var description: String {
-    switch self {
-    case .notUnix(let value): return "kitty.listen_on \(value): only unix: sockets"
-    case .windowClosed: return "window closed"
-    case .failed(let message): return message
-    }
-  }
-}
-
 /// The pure parts: which files are sockets of this listen_on, which windows
 /// are agents, what text a paste carries. The runner below does the I/O.
 enum Kitty {
@@ -91,106 +53,51 @@ enum Kitty {
   /// The windows of one `kitty @ ls` whose foreground programs include an
   /// agent: the basename of a process's cmdline[0] or cmdline[1] (codex and
   /// gemini run as `node …/codex`); `*` takes every window.
-  static func windows(ls data: Data, socket: String, agents: [String]) -> [KittyWindow] {
+  static func windows(ls data: Data, socket: String, agents: [String]) -> [AgentTarget] {
     guard let osWindows = try? JSONSerialization.jsonObject(with: data) as? [[String: Any]] else { return [] }
-    let all = agents.contains("*")
-    var found: [KittyWindow] = []
+    var found: [AgentTarget] = []
     for osWindow in osWindows {
       for tab in osWindow["tabs"] as? [[String: Any]] ?? [] {
         for window in tab["windows"] as? [[String: Any]] ?? [] {
           guard let id = window["id"] as? Int else { continue }
           let names = (window["foreground_processes"] as? [[String: Any]] ?? []).flatMap { process -> [String] in
             let cmdline = process["cmdline"] as? [String] ?? []
-            return cmdline.prefix(2).map(programName)
+            return cmdline.prefix(2).map(AgentText.programName)
           }.filter { !$0.isEmpty }
-          guard let agent = names.first(where: agents.contains) ?? (all ? names.last ?? "" : nil) else { continue }
-          found.append(KittyWindow(socket: socket, windowId: id, agent: agent,
-                                   title: cleanTitle(window["title"] as? String ?? ""),
-                                   cwd: window["cwd"] as? String ?? ""))
+          guard let agent = AgentText.agent(names: names, agents: agents) else { continue }
+          found.append(AgentTarget(terminal: "kitty", key: "\(socket)#\(id)", agent: agent,
+                                   title: AgentText.cleanTitle(window["title"] as? String ?? ""),
+                                   cwd: window["cwd"] as? String ?? "", place: "", names: names))
         }
       }
     }
     return found
   }
 
-  /// "/usr/bin/claude" → "claude", a login shell's "-fish" → "fish".
-  static func programName(_ arg: String) -> String {
-    var name = (arg as NSString).lastPathComponent
-    if name.hasPrefix("-") { name.removeFirst() }
-    return name
-  }
-
-  /// A title without the status glyph agents put in front ("✳ Claude Code").
-  static func cleanTitle(_ title: String) -> String {
-    guard let first = title.unicodeScalars.first, first.value > 127, !first.properties.isAlphabetic,
-          title.dropFirst().first == " " else { return title }
-    return String(title.dropFirst(2))
-  }
-
-  /// Context as a quote above the message, then one image path per line:
-  /// ContextQuote.block's shape (`> line`, `>` for an empty one, a blank line
-  /// after). A paste-only text ends in a newline, so the next paste starts
-  /// on its own line. Bracketed-paste markers are taken out of the text:
-  /// it is wrapped in them to arrive as one paste.
-  static func text(context: String, message: String, imagePaths: [String], pasteOnly: Bool) -> String {
-    var text = quote(context) ?? ""
-    text += message
-    let paths = imagePaths.map(shellQuote)
-    if !paths.isEmpty {
-      if !text.isEmpty && !text.hasSuffix("\n") { text += "\n" }
-      text += paths.joined(separator: "\n")
-    }
-    while text.hasSuffix("\n") { text.removeLast() }
-    if pasteOnly && !text.isEmpty { text += "\n" }
-    return text.replacingOccurrences(of: "\u{1b}[200~", with: "").replacingOccurrences(of: "\u{1b}[201~", with: "")
-  }
-
-  static func quote(_ context: String) -> String? {
-    var lines = context.replacingOccurrences(of: "\r\n", with: "\n").replacingOccurrences(of: "\r", with: "\n")
-      .components(separatedBy: "\n")
-      .map { line -> String in
-        var line = line
-        while let last = line.unicodeScalars.last, CharacterSet.whitespacesAndNewlines.contains(last) {
-          line.unicodeScalars.removeLast()
-        }
-        return line
-      }
-    while lines.first?.isEmpty == true { lines.removeFirst() }
-    while lines.last?.isEmpty == true { lines.removeLast() }
-    guard !lines.isEmpty else { return nil }
-    return lines.map { $0.isEmpty ? ">" : "> \($0)" }.joined(separator: "\n") + "\n\n"
-  }
-
-  /// A path as is when it holds only safe characters, else single-quoted
-  /// (claude reads a quoted path with spaces as an image).
-  static func shellQuote(_ path: String) -> String {
-    if path.range(of: #"^[A-Za-z0-9_./~+@%,:=-]+$"#, options: .regularExpression) != nil { return path }
-    return "'" + path.replacingOccurrences(of: "'", with: #"'\''"#) + "'"
+  /// A `<socket>#<window id>` key back into its parts.
+  static func parse(key: String) -> (socket: String, windowId: Int)? {
+    guard let hash = key.lastIndex(of: "#"), let id = Int(key[key.index(after: hash)...]) else { return nil }
+    let socket = String(key[..<hash])
+    return socket.isEmpty ? nil : (socket, id)
   }
 }
 
-final class KittyRunner {
-  let settings: KittySettings?
+final class KittyRunner: AgentTerminal {
+  let name = "kitty"
+  let settings: KittySettings
   let queue: DispatchQueue
   let env: [String: String]
   let lsTimeout: TimeInterval = 2
   let sendTimeout: TimeInterval = 5
 
   /// @param queue where completions run (the main queue in the app)
-  init(settings: KittySettings?, queue: DispatchQueue = .main,
+  init(settings: KittySettings, queue: DispatchQueue = .main,
        env: [String: String] = ProcessInfo.processInfo.environment) {
     self.settings = settings
     self.queue = queue
     self.env = env
   }
 
-  /// From a launch file; no settings when it has no kitty section.
-  convenience init(launchPath: String, queue: DispatchQueue = .main) {
-    let launch = FileManager.default.contents(atPath: launchPath)
-      .flatMap { try? JSONDecoder().decode(LaunchConfig.self, from: $0) }
-    self.init(settings: launch?.kitty, queue: queue)
-  }
-
   /// kitty @ runs, and listen_on expands, with the helper's env minus
   /// kitty's own variables (a helper started from a kitty window must not
   /// talk to that one, nor fill in the ${KITTY_PID} kitty keeps literal).
@@ -198,10 +105,9 @@ final class KittyRunner {
 
   /// The sockets listen_on names: the files in its folder whose names match
   /// (a directory listing, not glob(): the path may hold `${ }` literally).
-  func sockets() -> Result<[String], KittyError> {
-    guard let settings else { return .success([]) }
+  func sockets() -> Result<[String], AgentTerminalError> {
     guard let path = Kitty.socketPath(listenOn: settings.listenOn, env: kittyEnv) else {
-      return .failure(.notUnix(settings.listenOn))
+      return .failure(.config("kitty.listen_on \(settings.listenOn): only unix: sockets"))
     }
     let dir = (path as NSString).deletingLastPathComponent
     let base = (path as NSString).lastPathComponent
@@ -212,21 +118,24 @@ final class KittyRunner {
   }
 
   /// Agent windows from every live socket; a dead one drops out silently.
-  func windows(completion: @escaping (Result<[KittyWindow], KittyError>) -> Void) {
+  func owns(key: String) -> Bool { Kitty.parse(key: key) != nil }
+
+  func list(completion: @escaping (Result<[AgentTarget], AgentTerminalError>) -> Void) {
     let sockets: [String]
     switch self.sockets() {
     case .failure(let error): queue.async { completion(.failure(error)) }; return
     case .success(let found): sockets = found
     }
-    guard let settings, !sockets.isEmpty else { queue.async { completion(.success([])) }; return }
+    guard !sockets.isEmpty else { queue.async { completion(.success([])) }; return }
     let group = DispatchGroup()
     let lock = NSLock()
-    var bySocket: [String: [KittyWindow]] = [:]
+    let agents = settings.agents
+    var bySocket: [String: [AgentTarget]] = [:]
     for socket in sockets {
       group.enter()
       kitty(socket, ["ls"], timeout: lsTimeout, on: .global()) { result in
         if case .success(let r) = result, r.status == 0, !r.timedOut {
-          let found = Kitty.windows(ls: Data(r.stdout.utf8), socket: socket, agents: settings.agents)
+          let found = Kitty.windows(ls: Data(r.stdout.utf8), socket: socket, agents: agents)
           lock.lock(); bySocket[socket] = found; lock.unlock()
         }
         group.leave()
@@ -238,26 +147,26 @@ final class KittyRunner {
   /// Pastes +text+ into the window as one bracketed paste, then presses
   /// Enter unless +pasteOnly+. send-text reports nothing, even for a gone
   /// window, so `ls --match` checks the window first.
-  func send(key: String, text: String, pasteOnly: Bool, completion: @escaping (Result<Void, KittyError>) -> Void) {
-    guard let (socket, id) = KittyWindow.parse(key: key) else {
+  func send(key: String, text: String, pasteOnly: Bool, completion: @escaping (Result<Void, AgentTerminalError>) -> Void) {
+    guard let (socket, id) = Kitty.parse(key: key) else {
       queue.async { completion(.failure(.failed("not a kitty window: \(key)"))) }; return
     }
     let match = ["--match", "id:\(id)"]
     kitty(socket, ["ls"] + match, timeout: lsTimeout) { result in
       guard case .success(let r) = result, !r.timedOut else {
-        completion(.failure(self.failure(result, "kitty ls"))); return
+        completion(.failure(.from(result, "kitty ls"))); return
       }
-      guard r.status == 0 else { completion(.failure(.windowClosed)); return }
+      guard r.status == 0 else { completion(.failure(.closed("window closed"))); return }
       let paste = Data(("\u{1b}[200~" + text + "\u{1b}[201~").utf8)
       self.kitty(socket, ["send-text"] + match + ["--bracketed-paste=disable", "--stdin"], stdin: paste,
                  timeout: self.sendTimeout) { result in
         guard case .success(let r) = result, r.status == 0, !r.timedOut else {
-          completion(.failure(self.failure(result, "kitty send-text"))); return
+          completion(.failure(.from(result, "kitty send-text"))); return
         }
         if pasteOnly { completion(.success(())); return }
         self.kitty(socket, ["send-key"] + match + ["enter"], timeout: self.sendTimeout) { result in
           guard case .success(let r) = result, r.status == 0, !r.timedOut else {
-            completion(.failure(self.failure(result, "kitty send-key"))); return
+            completion(.failure(.from(result, "kitty send-key"))); return
           }
           completion(.success(()))
         }
@@ -265,82 +174,9 @@ final class KittyRunner {
     }
   }
 
-  private func failure(_ result: Result<ChiResult, ChiError>, _ what: String) -> KittyError {
-    switch result {
-    case .failure(let error): return .failed(error.description)
-    case .success(let r):
-      if r.timedOut { return .failed("\(what) timed out") }
-      let detail = (r.stderr.isEmpty ? r.stdout : r.stderr).trimmingCharacters(in: .whitespacesAndNewlines)
-      return .failed("\(what) failed (exit \(r.status)): \(detail.prefix(200))")
-    }
-  }
-
   private func kitty(_ socket: String, _ args: [String], stdin: Data? = nil, timeout: TimeInterval,
                      on queue: DispatchQueue? = nil, completion: @escaping (Result<ChiResult, ChiError>) -> Void) {
-    guard let settings else { return }
     ProcessRunner.run(executable: settings.binary, args: ["@", "--to", "unix:\(socket)"] + args, env: kittyEnv,
                       stdin: stdin, timeout: timeout, queue: queue ?? self.queue, completion: completion)
   }
 }
-
-/// `ChiHelper --kitty list|send …`, run directly (specs, a terminal):
-///   --kitty list [--launch PATH]                  JSON {"windows": […], "error": …}
-///   --kitty send KEY [--paste-only] [--message M] [--image PATH]… [--temp-image PATH]… [--launch PATH]
-/// send reads the context from stdin and prints "sent", "pasted" or the
-/// error (exit 1). --temp-image is an image the helper wrote (copied first).
-func kittyCommand(_ args: [String]) -> Int32 {
-  var args = args
-  let sub = args.isEmpty ? "" : args.removeFirst()
-  var launchPath = ChiRunner.launchPath, key: String?, message = "", pasteOnly = false
-  var images: [PanelImage] = []
-  while !args.isEmpty {
-    let arg = args.removeFirst()
-    switch arg {
-    case "--launch" where !args.isEmpty: launchPath = args.removeFirst()
-    case "--message" where !args.isEmpty: message = args.removeFirst()
-    case "--image" where !args.isEmpty: images.append(PanelImage(url: URL(fileURLWithPath: args.removeFirst()), temp: false))
-    case "--temp-image" where !args.isEmpty: images.append(PanelImage(url: URL(fileURLWithPath: args.removeFirst()), temp: true))
-    case "--paste-only": pasteOnly = true
-    default:
-      if key == nil && !arg.hasPrefix("--") { key = arg } else { return kittyUsage() }
-    }
-  }
-  let queue = DispatchQueue(label: "kitty-command")
-  let runner = KittyRunner(launchPath: launchPath, queue: queue)
-  let done = DispatchSemaphore(value: 0)
-  var status: Int32 = 0
-  switch sub {
-  case "list":
-    runner.windows { result in
-      var out: [String: Any] = ["windows": [], "error": NSNull()]
-      switch result {
-      case .success(let windows):
-        out["windows"] = windows.map { ["key": $0.key, "agent": $0.agent, "title": $0.title, "cwd": $0.cwd, "label": $0.label] }
-      case .failure(let error): out["error"] = error.description; status = 1
-      }
-      let data = try! JSONSerialization.data(withJSONObject: out, options: [.sortedKeys])
-      print(String(decoding: data, as: UTF8.self))
-      done.signal()
-    }
-  case "send":
-    guard let key else { return kittyUsage() }
-    let context = String(decoding: FileHandle.standardInput.readDataToEndOfFile(), as: UTF8.self)
-    let paths = ImageIntake.keepForPaste(images)
-    let text = Kitty.text(context: context, message: message, imagePaths: paths, pasteOnly: pasteOnly)
-    runner.send(key: key, text: text, pasteOnly: pasteOnly) { result in
-      switch result {
-      case .success: print(pasteOnly ? "pasted" : "sent")
-      case .failure(let error): print(error.description); status = 1
-      }
-      done.signal()
-    }
-  default: return kittyUsage()
-  }
-  done.wait()
-  return status
-}
-
-private func kittyUsage() -> Int32 {
-  FileHandle.standardError.write("usage: ChiHelper --kitty list|send KEY [--paste-only] [--message M] [--image PATH] [--launch PATH]\n".data(using: .utf8)!)
-  return 2
-}