Restore Chrome loopback debugging and document accepted local risks

docs/agent-corrections.md

@@ -10,3 +10,7 @@ Write rules only; omit incident histories and anecdotes.
 ## Terminology
 
 - Use “snapshot” for a point-in-time capture of code and conversation context; “revision” implies source control and changes the meaning.
+
+## Security
+
+- Accept other local OS accounts reaching preview forwards and Chrome’s loopback debugger on personal Macs; do not add authentication or account-isolating brokers for that threat.

docs/operations.md

@@ -115,7 +115,7 @@ byre never signs with a key on the machine it runs on. When a project checkout's
 - **Display sleep.** While the display sleeps, ScreenCaptureKit lists no displays. Every call holds a `PreventUserIdleDisplaySleep` assertion and, when the display is asleep, declares user activity and waits for ScreenCaptureKit to list it again. A declared activity doesn't reset the keyboard and mouse idle time, so the display sleeps again after powerd's grace period (`com.apple.powermanagement.delayDisplayOff` in `pmset -g assertions`), not after the full display-sleep delay. `pmset -g log` shows each wake as `Display is turned on` beside `byre-hands` assertions.
 - **Orion.** Orion ignores key events that carry only a Unicode string, so typing posts each ASCII character as its key code. Some apps list `confirm` but ignore it, Orion's address bar among them; send Return instead. `do JavaScript` needs Orion's Develop → "Allow JavaScript from Apple Events".
 - **Chrome.** Chrome refuses remote debugging on its default profile, so byre's Chrome is its own profile (`~/Library/Application Support/byre/chrome`), a separate Chrome beside any the human runs, and it keeps its logins: the human signs in there once. Chrome comes from `brew install --cask google-chrome`; macOS's "downloaded from the Internet" prompt on its first launch must be answered Open (or `osascript -e 'tell application "System Events" to tell process "CoreServicesUIAgent" to click button "Open" of window 1'`), and until it is, Chrome cannot accept debugging commands.
-- **Chrome's trust boundary.** Other OS accounts on the same Mac are not trusted with byre's logged-in browser. Chrome uses inherited debugging pipes, shared by agents through an owner-only Unix socket; never enable a debugging TCP port or fall back to one. After upgrading from the TCP transport, quit the old byre-profile Chrome once before using the tool; an already-running browser cannot acquire the new pipes. The saved profile and logins stay in place.
+- **Chrome's trust boundary.** Use Chrome's loopback debugging port with byre's separate persistent profile and Chrome's default browser-origin checks; never add `--remote-allow-origins=*`. Other local OS accounts can reach that debugger and control its logged-in sessions. This is an accepted risk on the personal Macs byre runs on, as is access to the app's local preview forwards; do not add account-isolating brokers for these listeners. Chrome must be launched with `--remote-debugging-port=0` so it records its port and browser WebSocket path in the profile’s `DevToolsActivePort` file. After switching from the pipe or fixed-port transport, quit the old byre-profile Chrome once so the next tool call can start it with that discovery file. The saved profile and logins stay in place.
 - **Permissions.** Agents' processes run as byre's descendants, so macOS privacy controls (TCC) hold byre responsible for them: the Screen Recording, Accessibility and Automation grants in System Settings → Privacy & Security are byre's, made by clicking at the Mac's screen, and each app scripted for the first time asks for its own Automation grant. Without Accessibility an untrusted process just sees no windows and no menu bar. Accessibility can list byre switched off; only its switch being on counts. TCC keys grants on the signing identifier and team, and every build is signed with Developer ID, so grants carry over from build to build. On a client Mac the grants belong to byre's app; `NSAppleEventsUsageDescription` in `mac/Info.plist` is what lets macOS ask for the Automation grant. `byre-hands check` prints the grants of the process that runs it; the Server and Settings tabs run it.
 
 ## Terminals

hands/Sources/byre-hands/Chrome.swift

@@ -62,16 +62,7 @@ final class Chain {
     }
 }
 
-final class ChromeContext {
-    let pid: pid_t
-    var tabs: [String: Task<TabState, Error>] = [:]
-    var current: String?
-
-    init(pid: pid_t) { self.pid = pid }
-}
-
 final class TabState {
-    weak var context: ChromeContext?
     let session: String
     let target: String
     var seq = 0
@@ -107,59 +98,50 @@ final class TabState {
 }
 
 final class Chrome: @unchecked Sendable {
-    let input: FileHandle
-    let output: FileHandle
-    let writes = DispatchQueue(label: "run.fc.byre.chrome-pipe")
+    let ws: URLSessionWebSocketTask
     let lock = NSLock()
     var next = 0
     var pending: [Int: CheckedContinuation<[String: Any], Error>] = [:]
+    var tabs: [String: Task<TabState, Error>] = [:]
     var sessions: [String: TabState] = [:]
+    var current: String?
     var closed = false
 
-    init(input: FileHandle, output: FileHandle, pid: pid_t) {
-        self.input = input
-        self.output = output
-        Thread.detachNewThread { [self] in
-            var buffer = Data()
-            do {
-                while let chunk = try readChromeChunk(output), !chunk.isEmpty {
-                    buffer.append(chunk)
-                    while let end = buffer.firstIndex(of: 0) {
-                        dispatch(Data(buffer[..<end]))
-                        buffer.removeSubrange(...end)
-                    }
-                    guard buffer.count <= 256 << 20 else {
-                        throw ToolError("Chrome's message is too large")
-                    }
+    init(_ url: URL) {
+        ws = URLSession.shared.webSocketTask(with: url)
+        ws.maximumMessageSize = 1 << 28
+        ws.resume()
+        receive()
+    }
+
+    func receive() {
+        ws.receive { [self] result in
+            switch result {
+            case .failure(let e):
+                fail(e)
+            case .success(let msg):
+                switch msg {
+                case .string(let s):
+                    dispatch(Data(s.utf8))
+                case .data(let d):
+                    dispatch(d)
+                @unknown default:
+                    break
                 }
-                fail(ToolError("Chrome closed its debugging pipe; if byre's Chrome was already open before this update, quit that browser once and retry"))
-            } catch {
-                fail(error)
+                receive()
             }
         }
-        Thread.detachNewThread {
-            var status: Int32 = 0
-            while waitpid(pid, &status, 0) < 0, errno == EINTR {}
-            // Finish replies already in flight, then retire the browser owner.
-            // The next call launches the current hands binary, including updates.
-            chromeBrokerCalls.notify(queue: .global()) { exit(0) }
-        }
     }
 
     func fail(_ e: Error) {
         let waiting = lock.withLock {
-            if closed { return [Int: CheckedContinuation<[String: Any], Error>]() }
             closed = true
             let p = pending
             pending = [:]
             return p
         }
-        let message = (e as? ToolError)?.message ?? e.localizedDescription
         for c in waiting.values {
-            c.resume(throwing: ToolError("lost the connection to Chrome: \(message)"))
-        }
-        writes.async { [self] in
-            try? input.close()
+            c.resume(throwing: ToolError("lost the connection to Chrome: \(e.localizedDescription)"))
         }
     }
 
@@ -192,14 +174,9 @@ final class Chrome: @unchecked Sendable {
                 c.resume(throwing: ToolError("lost the connection to Chrome"))
                 return
             }
-            writes.async { [self] in
-                guard !lock.withLock({ closed }) else { return }
-                do {
-                    var frame = data
-                    frame.append(0)
-                    try input.write(contentsOf: frame)
-                } catch {
-                    fail(error)
+            ws.send(.string(String(decoding: data, as: UTF8.self))) { [self] err in
+                if let err {
+                    resolve(id, .failure(err))
                 }
             }
             Task {
@@ -225,7 +202,7 @@ final class Chrome: @unchecked Sendable {
         let p = m.dict("params") ?? [:]
         lock.withLock {
             if method == "Target.detachedFromTarget", let s = p.string("sessionId"), let t = sessions.removeValue(forKey: s) {
-                t.context?.tabs.removeValue(forKey: t.target)
+                tabs.removeValue(forKey: t.target)
                 return
             }
             guard let s = m.string("sessionId"), let t = sessions[s] else {
@@ -320,43 +297,42 @@ final class Chrome: @unchecked Sendable {
         return (r["targetInfos"] as? [[String: Any]] ?? []).filter { $0.string("type") == "page" }
     }
 
-    func tab(_ id: String?, context: ChromeContext) async throws -> (String, TabState) {
+    func tab(_ id: String?) async throws -> (String, TabState) {
         var target = id
         if target == nil {
             let open = try await pages().compactMap { $0.string("targetId") }
-            target = lock.withLock { context.current }.flatMap { open.contains($0) ? $0 : nil } ?? open.first
+            target = lock.withLock { current }.flatMap { open.contains($0) ? $0 : nil } ?? open.first
         }
         guard let target else {
             throw ToolError("Chrome has no tabs; navigate with new_tab to open one")
         }
         let task = lock.withLock {
-            context.current = target
-            if let a = context.tabs[target] {
+            current = target
+            if let a = tabs[target] {
                 return a
             }
-            let a = Task { try await attach(target, context: context) }
-            context.tabs[target] = a
+            let a = Task { try await attach(target) }
+            tabs[target] = a
             return a
         }
         do {
             return (target, try await task.value)
         } catch {
             lock.withLock {
-                if context.tabs[target] == task {
-                    context.tabs.removeValue(forKey: target)
+                if tabs[target] == task {
+                    tabs.removeValue(forKey: target)
                 }
             }
             throw error
         }
     }
 
-    func attach(_ target: String, context: ChromeContext) async throws -> TabState {
+    func attach(_ target: String) async throws -> TabState {
         let r = try await send("Target.attachToTarget", ["targetId": target, "flatten": true])
         guard let s = r.string("sessionId") else {
             throw ToolError("Chrome attached to \(target) without a session")
         }
         let t = TabState(session: s, target: target)
-        t.context = context
         lock.withLock { sessions[s] = t }
         for m in ["Page.enable", "Network.enable", "Runtime.enable", "Log.enable"] {
             _ = try await send(m, session: s)
@@ -390,54 +366,63 @@ func consoleLine(_ level: String, _ text: String, _ url: String?, _ line: Int?)
     return "\(level) \(text)  (\(url):\((line ?? 0) + 1))"
 }
 
+// Chrome writes both its ephemeral port and browser-specific WebSocket path
+// into this profile. A live port alone does not identify our browser.
+func chromeFromProfile() async -> Chrome? {
+    let activePort = URL(filePath: chromeProfile).appending(path: "DevToolsActivePort")
+    guard let text = try? String(contentsOf: activePort, encoding: .utf8) else { return nil }
+    let lines = text.split(whereSeparator: \.isNewline)
+    guard lines.count == 2, let port = Int(lines[0]), (1...65535).contains(port),
+          lines[1].hasPrefix("/devtools/browser/") else { return nil }
+    var endpoint = URLComponents()
+    endpoint.scheme = "ws"
+    endpoint.host = "127.0.0.1"
+    endpoint.port = port
+    endpoint.path = String(lines[1])
+    guard let url = endpoint.url else { return nil }
+    let chrome = Chrome(url)
+    do {
+        _ = try await chrome.send("Browser.getVersion", timeout: 2)
+        return chrome
+    } catch {
+        chrome.ws.cancel(with: .goingAway, reason: nil)
+        chrome.fail(error)
+        return nil
+    }
+}
+
 func openChrome() async throws -> (Chrome, String) {
+    if let chrome = await chromeFromProfile() { return (chrome, "") }
     let lock = try await lockInput()
     defer { close(lock) }
-    guard let app = NSWorkspace.shared.urlForApplication(withBundleIdentifier: "com.google.Chrome"),
-          let executable = Bundle(url: app)?.executablePath else {
-        throw ToolError("Google Chrome is not installed on this Mac")
-    }
+    // Another helper may have started Chrome while this one waited.
+    if let chrome = await chromeFromProfile() { return (chrome, "") }
     let fm = FileManager.default
     try fm.createDirectory(atPath: chromeProfile, withIntermediateDirectories: true, attributes: [.posixPermissions: 0o700])
     try fm.setAttributes([.posixPermissions: 0o700], ofItemAtPath: chromeProfile)
-    let commands = Pipe()
-    let replies = Pipe()
-    guard fcntl(commands.fileHandleForWriting.fileDescriptor, F_SETNOSIGPIPE, 1) == 0 else {
-        throw ToolError("configure Chrome command pipe: errno \(errno)")
+    let p = Process()
+    p.executableURL = URL(filePath: "/usr/bin/open")
+    p.arguments = ["-na", "Google Chrome", "--args", "--user-data-dir=\(chromeProfile)", "--remote-debugging-port=0", "--no-first-run", "--no-default-browser-check"]
+    try p.run()
+    p.waitUntilExit()
+    if p.terminationStatus != 0 {
+        throw ToolError("could not open Google Chrome (open exited \(p.terminationStatus)); is it installed on this Mac?")
     }
-    // Keep sources out of Chrome's fd 3/4 destinations during posix_spawn.
-    let readFD = fcntl(commands.fileHandleForReading.fileDescriptor, F_DUPFD_CLOEXEC, 10)
-    guard readFD >= 0 else { throw ToolError("create Chrome command pipe: errno \(errno)") }
-    defer { close(readFD) }
-    let writeFD = fcntl(replies.fileHandleForWriting.fileDescriptor, F_DUPFD_CLOEXEC, 10)
-    guard writeFD >= 0 else { throw ToolError("create Chrome reply pipe: errno \(errno)") }
-    defer { close(writeFD) }
-    let pid = try spawnChromeProcess(executable, ["--user-data-dir=\(chromeProfile)", "--remote-debugging-pipe", "--no-first-run", "--no-default-browser-check"], pipes: (readFD, writeFD))
-    try commands.fileHandleForReading.close()
-    try replies.fileHandleForWriting.close()
-    let chrome = Chrome(input: commands.fileHandleForWriting, output: replies.fileHandleForReading, pid: pid)
-    // Prove the private connection works; never discover or fall back to a TCP debugger.
-    do {
-        _ = try await chrome.send("Browser.getVersion", timeout: 15)
-    } catch {
-        // Only the newly launched process group belongs to this attempt. An
-        // existing browser using this profile must be quit by the human.
-        kill(-pid, SIGTERM)
-        chrome.fail(error)
-        let message = (error as? ToolError)?.message ?? error.localizedDescription
-        throw ToolError("Chrome did not open its private debugging pipe: \(message). If byre's Chrome was already running, quit that browser once and retry.")
+    let start = Date()
+    while Date().timeIntervalSince(start) < 15 {
+        if let chrome = await chromeFromProfile() {
+            return (chrome, "started Chrome with byre's profile\n")
+        }
+        await pause(200)
     }
-    return (chrome, "started Chrome with byre's profile\n")
+    throw ToolError("Chrome's debugger for byre's profile didn't answer within 15s; quit any already-running byre-profile Chrome once and retry")
 }
 
 actor ChromeLink {
     var conn: Task<(Chrome, String), Error>?
 
     func get() async throws -> (Chrome, String) {
-        if let conn, let (c, _) = try? await conn.value {
-            guard !c.lock.withLock({ c.closed }) else {
-                throw ToolError("Chrome closed its debugging pipe; retry the call after quitting any old byre-profile Chrome browser")
-            }
+        if let conn, let (c, _) = try? await conn.value, !c.lock.withLock({ c.closed }) {
             return (c, "")
         }
         let t = Task { try await openChrome() }
@@ -660,7 +645,7 @@ func shrink(_ png: Data, _ maxEdge: Double) throws -> (Data, String) {
     return (data as Data, "page viewport, image \(img.width)x\(img.height) scaled from \(full.width)x\(full.height)")
 }
 
-func chromeTool(_ args: [String: Any], saveDir: String?, context: ChromeContext) async throws -> [Content] {
+func chromeTool(_ args: [String: Any]) async throws -> [Content] {
     let op = try args.require("op", args.string)
     let maxEdge = args.double("max_edge") ?? 1568
     if !maxEdge.isFinite || maxEdge < 16 || maxEdge > 8192 {
@@ -690,7 +675,7 @@ func chromeTool(_ args: [String: Any], saveDir: String?, context: ChromeContext)
         let r = try await c.send("Target.createTarget", ["url": "about:blank"])
         tabId = r.string("targetId")
     }
-    let (target, t) = try await c.tab(tabId, context: context)
+    let (target, t) = try await c.tab(tabId)
     switch op {
     case "tabs":
         break
@@ -757,7 +742,7 @@ func chromeTool(_ args: [String: Any], saveDir: String?, context: ChromeContext)
     let (png, shotNote) = try shrink(Data(base64Encoded: shot.string("data") ?? "") ?? Data(), maxEdge)
     log.append(shotNote)
     if args.bool("save") {
-        log.append("saved to \(try save(png, in: saveDir))")
+        log.append("saved to \(try save(png))")
     }
     return [.text(log.joined(separator: "\n")), .png(png)]
 }

hands/Sources/byre-hands/ChromeBroker.swift

@@ -1,237 +0,0 @@
-import AppKit
-import Darwin
-
-// Chrome's pipe transport belongs to one process. All hands processes on this
-// account share that owner through a socket in the account's private temp dir.
-private let chromeSocketDir = NSTemporaryDirectory() + "byre-chrome"
-private let chromeSocketPath = chromeSocketDir + "/control"
-
-private func chromeAddress() throws -> sockaddr_un {
-    var address = sockaddr_un()
-    address.sun_family = sa_family_t(AF_UNIX)
-    let bytes = Array(chromeSocketPath.utf8) + [0]
-    guard bytes.count <= MemoryLayout.size(ofValue: address.sun_path) else {
-        throw ToolError("Chrome's private socket path is too long")
-    }
-    withUnsafeMutableBytes(of: &address.sun_path) { $0.copyBytes(from: bytes) }
-    address.sun_len = UInt8(MemoryLayout<sockaddr_un>.size)
-    return address
-}
-
-private func connectChromeBroker() throws -> Int32 {
-    var address = try chromeAddress()
-    let fd = socket(AF_UNIX, SOCK_STREAM, 0)
-    guard fd >= 0 else { throw ToolError("create Chrome socket: errno \(errno)") }
-    let result = withUnsafePointer(to: &address) {
-        $0.withMemoryRebound(to: sockaddr.self, capacity: 1) {
-            Darwin.connect(fd, $0, socklen_t(MemoryLayout<sockaddr_un>.size))
-        }
-    }
-    guard result == 0 else {
-        close(fd)
-        throw ToolError("Chrome's private helper is not running")
-    }
-    var noSignal: Int32 = 1
-    setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, &noSignal, socklen_t(MemoryLayout<Int32>.size))
-    return fd
-}
-
-// Both the broker and Chrome are launched in their own process groups, so ending
-// one agent's hands process cannot take down the shared browser.
-func spawnChromeProcess(_ executable: String, _ args: [String], pipes: (Int32, Int32)? = nil) throws -> pid_t {
-    var actions: posix_spawn_file_actions_t?
-    var attrs: posix_spawnattr_t?
-    posix_spawn_file_actions_init(&actions)
-    posix_spawnattr_init(&attrs)
-    defer {
-        posix_spawn_file_actions_destroy(&actions)
-        posix_spawnattr_destroy(&attrs)
-    }
-    posix_spawnattr_setflags(&attrs, Int16(POSIX_SPAWN_SETPGROUP | POSIX_SPAWN_CLOEXEC_DEFAULT))
-    posix_spawnattr_setpgroup(&attrs, 0)
-    for fd: Int32 in [0, 1, 2] {
-        posix_spawn_file_actions_addopen(&actions, fd, "/dev/null", O_RDWR, 0)
-    }
-    if let (input, output) = pipes {
-        posix_spawn_file_actions_adddup2(&actions, input, 3)
-        posix_spawn_file_actions_adddup2(&actions, output, 4)
-    }
-    let argv = ([executable] + args).map { strdup($0) } + [nil]
-    defer { for p in argv { free(p) } }
-    var pid: pid_t = 0
-    let result = argv.withUnsafeBufferPointer {
-        posix_spawn(&pid, executable, &actions, &attrs, $0.baseAddress!, environ)
-    }
-    guard result == 0 else { throw ToolError("launch \(executable): errno \(result)") }
-    return pid
-}
-
-// Foundation's read(upToCount:) can wait to fill its buffer on a socket or
-// pipe. A single POSIX read returns the available bytes without waiting for EOF.
-func readChromeChunk(_ handle: FileHandle) throws -> Data? {
-    var bytes = [UInt8](repeating: 0, count: 64 << 10)
-    while true {
-        let count = Darwin.read(handle.fileDescriptor, &bytes, bytes.count)
-        if count > 0 { return Data(bytes.prefix(count)) }
-        if count == 0 { return nil }
-        if errno != EINTR { throw ToolError("read Chrome connection: errno \(errno)") }
-    }
-}
-
-private func chromeFrame(_ handle: FileHandle) throws -> Data {
-    var data = Data()
-    // One request per connection. Chunked reads avoid per-byte system calls.
-    while true {
-        guard let chunk = try readChromeChunk(handle), !chunk.isEmpty else {
-            throw ToolError("Chrome's private connection closed")
-        }
-        if let end = chunk.firstIndex(of: 0) {
-            data.append(chunk[..<end])
-            guard data.count <= 256 << 20 else { throw ToolError("Chrome's reply is too large") }
-            return data
-        }
-        data.append(chunk)
-        guard data.count <= 256 << 20 else { throw ToolError("Chrome's reply is too large") }
-    }
-}
-
-private let chromeClientID = UUID().uuidString
-
-private actor ChromeContexts {
-    var clients: [String: ChromeContext] = [:]
-
-    func get(_ id: String, pid: pid_t) async -> ChromeContext {
-        clients = clients.filter { _, context in
-            kill(context.pid, 0) == 0 || errno != ESRCH
-        }
-        let context = clients[id] ?? ChromeContext(pid: pid)
-        clients[id] = context
-        // A departed helper's target sessions should stop collecting events.
-        if let connection = await chromeLink.conn, let (chrome, _) = try? await connection.value {
-            let detached = chrome.lock.withLock {
-                let ids = chrome.sessions.filter { $0.value.context == nil }.map { $0.key }
-                for id in ids { chrome.sessions.removeValue(forKey: id) }
-                return ids
-            }
-            for id in detached {
-                _ = try? await chrome.send("Target.detachFromTarget", ["sessionId": id])
-            }
-        }
-        return context
-    }
-}
-
-private let chromeContexts = ChromeContexts()
-let chromeBrokerCalls = DispatchGroup()
-
-func sharedChromeTool(_ args: [String: Any]) async throws -> [Content] {
-    try await Task.detached {
-        var fd = try? connectChromeBroker()
-        if fd == nil {
-            let pid = try spawnChromeProcess(Bundle.main.executablePath!, ["chrome-broker"])
-            Thread.detachNewThread {
-                var status: Int32 = 0
-                while waitpid(pid, &status, 0) < 0, errno == EINTR {}
-            }
-            let start = Date()
-            while fd == nil, Date().timeIntervalSince(start) < 15 {
-                await pause(100)
-                fd = try? connectChromeBroker()
-            }
-        }
-        guard let fd else { throw ToolError("Chrome's private helper did not start within 15s") }
-        let handle = FileHandle(fileDescriptor: fd, closeOnDealloc: true)
-        defer { try? handle.close() }
-        var request: [String: Any] = ["arguments": args, "client": chromeClientID]
-        request["media_dir"] = mediaDir
-        var data = try JSONSerialization.data(withJSONObject: request)
-        data.append(0)
-        try handle.write(contentsOf: data)
-        let response = try JSONSerialization.jsonObject(with: chromeFrame(handle)) as? [String: Any] ?? [:]
-        if let error = response.string("error") { throw ToolError(error) }
-        return (response["content"] as? [[String: Any]] ?? []).compactMap { item in
-            if item.string("type") == "image", let data = Data(base64Encoded: item.string("data") ?? "") {
-                return Content.png(data)
-            }
-            return Content.text(item.string("text") ?? "")
-        }
-    }.value
-}
-
-func serveChromeBroker() throws {
-    let fm = FileManager.default
-    if !fm.fileExists(atPath: chromeSocketDir) {
-        do {
-            try fm.createDirectory(atPath: chromeSocketDir, withIntermediateDirectories: false, attributes: [.posixPermissions: 0o700])
-        } catch {
-            if !fm.fileExists(atPath: chromeSocketDir) { throw error }
-        }
-    }
-    let attributes = try fm.attributesOfItem(atPath: chromeSocketDir)
-    guard attributes[.type] as? FileAttributeType == .typeDirectory,
-          (attributes[.ownerAccountID] as? NSNumber)?.uint32Value == getuid() else {
-        throw ToolError("Chrome's socket directory is not owned by this account")
-    }
-    try fm.setAttributes([.posixPermissions: 0o700], ofItemAtPath: chromeSocketDir)
-    let lock = Darwin.open(chromeSocketDir + "/lock", O_CREAT | O_RDWR | O_NOFOLLOW | O_CLOEXEC, 0o600)
-    guard lock >= 0 else { throw ToolError("open Chrome helper lock: errno \(errno)") }
-    defer { close(lock) }
-    guard flock(lock, LOCK_EX | LOCK_NB) == 0 else { return }
-    unlink(chromeSocketPath)
-    let fd = socket(AF_UNIX, SOCK_STREAM, 0)
-    guard fd >= 0 else { throw ToolError("create Chrome listener: errno \(errno)") }
-    defer {
-        close(fd)
-        unlink(chromeSocketPath)
-    }
-    var address = try chromeAddress()
-    let bound = withUnsafePointer(to: &address) {
-        $0.withMemoryRebound(to: sockaddr.self, capacity: 1) {
-            bind(fd, $0, socklen_t(MemoryLayout<sockaddr_un>.size))
-        }
-    }
-    guard bound == 0, listen(fd, 16) == 0 else { throw ToolError("listen on Chrome socket: errno \(errno)") }
-    while true {
-        let client = accept(fd, nil, nil)
-        if client < 0 {
-            if errno == EINTR { continue }
-            throw ToolError("accept Chrome connection: errno \(errno)")
-        }
-        // Check the peer too: filesystem permissions alone are not the boundary.
-        var uid: uid_t = 0
-        var gid: gid_t = 0
-        guard getpeereid(client, &uid, &gid) == 0, uid == getuid() else {
-            close(client)
-            continue
-        }
-        var pid: pid_t = 0
-        var pidSize = socklen_t(MemoryLayout<pid_t>.size)
-        guard getsockopt(client, SOL_LOCAL, LOCAL_PEERPID, &pid, &pidSize) == 0 else {
-            close(client)
-            continue
-        }
-        var noSignal: Int32 = 1
-        setsockopt(client, SOL_SOCKET, SO_NOSIGPIPE, &noSignal, socklen_t(MemoryLayout<Int32>.size))
-        chromeBrokerCalls.enter()
-        Task.detached {
-            defer { chromeBrokerCalls.leave() }
-            let handle = FileHandle(fileDescriptor: client, closeOnDealloc: true)
-            defer { try? handle.close() }
-            var response: [String: Any]
-            do {
-                let request = try JSONSerialization.jsonObject(with: chromeFrame(handle)) as? [String: Any] ?? [:]
-                let context = await chromeContexts.get(request.string("client") ?? "", pid: pid)
-                let content = try await chromeTool(request.dict("arguments") ?? [:], saveDir: request.string("media_dir"), context: context)
-                response = ["content": content.map { $0.json }]
-            } catch let error as ToolError {
-                response = ["error": error.message]
-            } catch {
-                response = ["error": "\(error)"]
-            }
-            if var data = try? JSONSerialization.data(withJSONObject: response) {
-                data.append(0)
-                try? handle.write(contentsOf: data)
-            }
-        }
-    }
-}

hands/Sources/byre-hands/Screen.swift

@@ -142,8 +142,8 @@ func captureTool(_ args: [String: Any]) async throws -> [Content] {
     return [.text("\(shot.note); saved to \(try save(shot.png))"), .png(shot.png)]
 }
 
-func save(_ png: Data, in directory: String? = mediaDir) throws -> String {
-    guard let dir = directory else {
+func save(_ png: Data) throws -> String {
+    guard let dir = mediaDir else {
         throw ToolError("save needs byre's media folder, and this byre-hands has none")
     }
     let url = URL(filePath: dir).appending(path: "capture-\(UUID().uuidString.prefix(8).lowercased()).png")

hands/Sources/byre-hands/Server.swift

@@ -49,19 +49,6 @@ struct Server {
             runCheck()
             RunLoop.main.run()
         }
-        if CommandLine.arguments.dropFirst().first == "chrome-broker" {
-            Thread.detachNewThread {
-                do {
-                    try serveChromeBroker()
-                    exit(0)
-                } catch {
-                    FileHandle.standardError.write(Data("Chrome helper: \(error)\n".utf8))
-                    exit(1)
-                }
-            }
-            RunLoop.main.run()
-            return
-        }
         Thread.detachNewThread {
             let inFlight = DispatchGroup()
             while let line = readLine() {

hands/Sources/byre-hands/Tools.swift

@@ -127,6 +127,6 @@ let tools: [Tool] = [
             "save": {"type": "boolean", "description": "With capture, also save the screenshot as a PNG in the task's media folder; the reply gives its path, which a Markdown image in your final message can show."}
         }, "required": ["op"]}
         """,
-        run: sharedChromeTool
+        run: chromeTool
     ),
 ]