Add run_on_client: agents run commands with files on the user's Macs

2026-10-17 14:41:04 -07:00
parent 14975d2ab8
commit fbc0699fdf
16 changed files with 928 additions and 249 deletions
@@ -0,0 +1,166 @@
+import ByreAPI
+import Foundation
+
+private let maxOutput = 64 << 10
+
+private let runsDir = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)[0].appending(path: "run.fc.byre.mac/runs", directoryHint: .isDirectory)
+
+@MainActor
+private var watching: Set<String> = []
+
+@MainActor
+func runOnThisMac(_ api: API, _ item: InboxItem) async throws {
+    let dir = runsDir.appending(path: UUID().uuidString, directoryHint: .isDirectory)
+    watching.insert(dir.path)
+    do {
+        try await start(api, item, dir)
+    } catch {
+        try? FileManager.default.removeItem(at: dir)
+        watching.remove(dir.path)
+        throw error
+    }
+    poll(api, dir)
+}
+
+@MainActor
+private func start(_ api: API, _ item: InboxItem, _ dir: URL) async throws {
+    let files = dir.appending(path: "files", directoryHint: .isDirectory)
+    try FileManager.default.createDirectory(at: files, withIntermediateDirectories: true)
+    try item.id.write(to: dir.appending(path: "item"), atomically: true, encoding: .utf8)
+    try api.origin.absoluteString.write(to: dir.appending(path: "server"), atomically: true, encoding: .utf8)
+    try str(item.payload.value, "command")!.write(to: dir.appending(path: "command.sh"), atomically: true, encoding: .utf8)
+
+    let (bundle, response) = try await api.session.download(from: api.url("/api/inbox/\(item.id)/bundle"))
+    let code = (response as! HTTPURLResponse).statusCode
+    if code != 200 {
+        let text = (try? String(contentsOf: bundle, encoding: .utf8)) ?? ""
+        throw ApiError(status: code, message: "download bundle: \(code) \(text)")
+    }
+    try await untar(bundle, into: files, errors: dir.appending(path: "untar.log"))
+    try? FileManager.default.removeItem(at: bundle)
+
+    let p = Process()
+    p.executableURL = URL(filePath: "/usr/bin/lockf")
+    p.arguments = ["-k", "lock", "/bin/zsh", "-c", "cd files && /bin/zsh -l ../command.sh >../output.log 2>&1; echo $? >../exit.tmp; mv ../exit.tmp ../exit"]
+    p.currentDirectoryURL = dir
+    p.standardInput = FileHandle.nullDevice
+    p.standardOutput = FileHandle.nullDevice
+    p.standardError = FileHandle.nullDevice
+    try p.run()
+    let lock = dir.appending(path: "lock")
+    while !FileManager.default.fileExists(atPath: lock.path) {
+        if !p.isRunning {
+            throw ApiError(status: 0, message: "start command: lockf exited \(p.terminationStatus) before taking its lock")
+        }
+        try await Task.sleep(for: .milliseconds(20))
+    }
+    log.info("client run started: item \(item.id, privacy: .public) in \(dir.path, privacy: .public)")
+}
+
+private func untar(_ bundle: URL, into dir: URL, errors: URL) async throws {
+    FileManager.default.createFile(atPath: errors.path, contents: nil)
+    let errFile = try FileHandle(forWritingTo: errors)
+    defer {
+        try? errFile.close()
+    }
+    let p = Process()
+    p.executableURL = URL(filePath: "/usr/bin/tar")
+    p.arguments = ["-xzf", bundle.path, "-C", dir.path]
+    p.standardError = errFile
+    p.standardOutput = FileHandle.nullDevice
+    try await withCheckedThrowingContinuation { (c: CheckedContinuation<Void, any Error>) in
+        p.terminationHandler = { _ in
+            c.resume()
+        }
+        do {
+            try p.run()
+        } catch {
+            c.resume(throwing: error)
+        }
+    }
+    if p.terminationStatus != 0 {
+        let text = tail(errors)
+        throw ApiError(status: 0, message: "unpack bundle: tar exited \(p.terminationStatus): \(text)")
+    }
+}
+
+@MainActor
+func resumeClientRuns(_ api: API) {
+    let dirs = (try? FileManager.default.contentsOfDirectory(at: runsDir, includingPropertiesForKeys: nil)) ?? []
+    for dir in dirs where !watching.contains(dir.path) && (try? String(contentsOf: dir.appending(path: "server"), encoding: .utf8)) == api.origin.absoluteString {
+        if !FileManager.default.fileExists(atPath: dir.appending(path: "lock").path) {
+            log.info("client run never started; removing \(dir.path, privacy: .public)")
+            try? FileManager.default.removeItem(at: dir)
+            continue
+        }
+        watching.insert(dir.path)
+        poll(api, dir)
+    }
+}
+
+@MainActor
+private func poll(_ api: API, _ dir: URL) {
+    Task {
+        let exitFile = dir.appending(path: "exit").path
+        var interrupted = false
+        while !FileManager.default.fileExists(atPath: exitFile) {
+            if lockFree(dir.appending(path: "lock").path) {
+                interrupted = !FileManager.default.fileExists(atPath: exitFile)
+                break
+            }
+            try? await Task.sleep(for: .seconds(1))
+        }
+        await report(api, dir, interrupted: interrupted)
+        watching.remove(dir.path)
+    }
+}
+
+private func lockFree(_ path: String) -> Bool {
+    guard let h = FileHandle(forReadingAtPath: path) else {
+        return false
+    }
+    defer {
+        try? h.close()
+    }
+    let fd = h.fileDescriptor
+    if flock(fd, LOCK_EX | LOCK_NB) != 0 {
+        return false
+    }
+    flock(fd, LOCK_UN)
+    return true
+}
+
+@MainActor
+private func report(_ api: API, _ dir: URL, interrupted: Bool) async {
+    do {
+        let itemId = trimmed(try String(contentsOf: dir.appending(path: "item"), encoding: .utf8))
+        var exit = -1
+        var output = tail(dir.appending(path: "output.log"))
+        if interrupted {
+            output += "\n[byre: the command stopped without finishing, for example because the Mac restarted]"
+        } else {
+            exit = Int(trimmed(try String(contentsOf: dir.appending(path: "exit"), encoding: .utf8))) ?? -1
+        }
+        let client = Host.current().localizedName ?? ProcessInfo.processInfo.hostName
+        _ = try await api.client.reportRun(path: .init(itemId: itemId), body: .json(.init(runId: dir.lastPathComponent, client: client, exitCode: exit, output: output))).ok
+        log.info("client run reported: item \(itemId, privacy: .public) exit \(exit)")
+    } catch {
+        log.error("report client run \(dir.path, privacy: .public): \(errorText(error), privacy: .public)")
+        guard let e = rootError(error) as? ApiError, (400..<500).contains(e.status) else {
+            return
+        }
+    }
+    try? FileManager.default.removeItem(at: dir)
+}
+
+private func tail(_ file: URL) -> String {
+    guard let h = try? FileHandle(forReadingFrom: file) else {
+        return ""
+    }
+    defer {
+        try? h.close()
+    }
+    let size = (try? h.seekToEnd()) ?? 0
+    try? h.seek(toOffset: size > UInt64(maxOutput) ? size - UInt64(maxOutput) : 0)
+    return String(decoding: (try? h.readToEnd()) ?? Data(), as: UTF8.self)
+}