native macOS codings agent orchestrator prowl.onev.cat
Something went wrong. Try again.
13 kB · 366 lines
Swift
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367import Darwinimport Foundation
struct ForegroundProcess: Equatable, Sendable { let pid: pid_t let parentProcessID: pid_t? let name: String let argv0: String? let cmdline: String? let arguments: [String]?
nonisolated init( pid: pid_t, parentProcessID: pid_t? = nil, name: String, argv0: String?, cmdline: String?, arguments: [String]? = nil ) { self.pid = pid self.parentProcessID = parentProcessID self.name = name self.argv0 = argv0 self.cmdline = cmdline self.arguments = arguments }}
struct ForegroundJob: Equatable, Sendable { let processGroupID: pid_t let processes: [ForegroundProcess]
/// The job member the shell launched on behalf of `pid`: its topmost ancestor /// that is still part of this job. A runtime that forks an engine child /// (Droid's `droid exec`) moves the identified process while this stays put. nonisolated func launchProcessID(of pid: pid_t) -> pid_t { var current = pid var hops = 0 while hops < processes.count, let parent = processes.first(where: { $0.pid == current })?.parentProcessID, processes.contains(where: { $0.pid == parent }) { current = parent hops += 1 } return current }}
actor AgentProcessProbe { static let shared = AgentProcessProbe()
private struct CachedJob { let capturedAt: Date let job: ForegroundJob? }
private let cacheLifetime: TimeInterval private var jobsByProcessGroupID: [pid_t: CachedJob] = [:]
init(cacheLifetime: TimeInterval = 0.75) { self.cacheLifetime = cacheLifetime }
/// `bypassingCache` samples the process group again even inside the cache lifetime: /// after a `COMMAND_FINISHED` a cached hit or miss could neither confirm nor deny /// the exit (docs-ai 079). The fresh result replaces the cache entry. func foregroundJob(processGroupID: pid_t?, childPID: pid_t?, bypassingCache: Bool = false) -> ForegroundJob? { let resolvedProcessGroupID: pid_t? if let processGroupID, processGroupID > 0 { resolvedProcessGroupID = processGroupID } else if let childPID, childPID > 0 { resolvedProcessGroupID = ProcessDetection.foregroundProcessGroupID(pid: childPID) } else { resolvedProcessGroupID = nil }
guard let resolvedProcessGroupID else { return nil } return cachedForegroundJob(processGroupID: resolvedProcessGroupID, now: Date(), bypassingCache: bypassingCache) }
private func cachedForegroundJob(processGroupID: pid_t, now: Date, bypassingCache: Bool) -> ForegroundJob? { if !bypassingCache, let cached = jobsByProcessGroupID[processGroupID], now.timeIntervalSince(cached.capturedAt) < cacheLifetime { return cached.job }
let job = ProcessDetection.foregroundJob(processGroupID: processGroupID) jobsByProcessGroupID[processGroupID] = CachedJob(capturedAt: now, job: job) removeExpiredJobs(now: now) return job }
private func removeExpiredJobs(now: Date) { guard jobsByProcessGroupID.count > 64 else { return } jobsByProcessGroupID = jobsByProcessGroupID.filter { _, cached in now.timeIntervalSince(cached.capturedAt) < cacheLifetime } }}
nonisolated enum ProcessDetection { static func foregroundJob(childPID: pid_t) -> ForegroundJob? { guard childPID > 0, let processGroupID = foregroundProcessGroupID(pid: childPID) else { return nil } return foregroundJob(processGroupID: processGroupID) }
static func foregroundJob(processGroupID: pid_t) -> ForegroundJob? { guard processGroupID > 0 else { return nil } let processes = processGroupPIDs(processGroupID).compactMap { pid -> ForegroundProcess? in guard pid > 0, let info = processBSDInfo(pid: pid), let name = comm(from: info) else { return nil } let argv = processArguments(pid: pid) return ForegroundProcess( pid: pid, parentProcessID: pid_t(info.pbi_ppid), name: name, argv0: argv?.first.flatMap(basename), cmdline: argv?.joined(separator: " "), arguments: argv ) }
guard !processes.isEmpty else { return nil } return ForegroundJob(processGroupID: processGroupID, processes: processes) }
static func processGroupPIDs(_ processGroupID: pid_t) -> [pid_t] { guard processGroupID > 0 else { return [] } var capacity = 16
while capacity <= 4096 { var pids = [pid_t](repeating: 0, count: capacity) let bytes = pids.withUnsafeMutableBufferPointer { buffer in proc_listpids( UInt32(PROC_PGRP_ONLY), UInt32(processGroupID), buffer.baseAddress, Int32(buffer.count * MemoryLayout<pid_t>.size) ) } guard bytes > 0 else { return [] }
let count = Int(bytes) / MemoryLayout<pid_t>.size let result = pids.prefix(count).filter { $0 > 0 } if count < capacity { return Array(result) } capacity *= 2 }
return [] }
static func foregroundProcessGroupID(pid: pid_t) -> pid_t? { guard let info = processBSDInfo(pid: pid), info.e_tpgid > 0 else { return nil } return pid_t(info.e_tpgid) }
static func processCommandLine(pid: pid_t) -> String? { processArguments(pid: pid)?.joined(separator: " ") }
static func processArgv0Name(pid: pid_t) -> String? { guard let argv0 = processArguments(pid: pid)?.first else { return nil } return basename(argv0) }
static func processArguments(pid: pid_t) -> [String]? { guard let buffer = kernProcargs2(pid: pid) else { return nil } return procargs2Argv(buffer) }
/// One variable from another same-user process's environment, as the kernel recorded it /// at exec. The caller reads it; nothing the process claims over a socket is trusted. static func processEnvironmentValue(pid: pid_t, name: String) -> String? { guard let buffer = kernProcargs2(pid: pid) else { return nil } let prefix = name + "=" guard let entry = procargs2Environment(buffer)?.first(where: { $0.hasPrefix(prefix) }) else { return nil } return String(entry.dropFirst(prefix.count)) }
/// Codex 0.157+ runs every thread's shell commands in this shared process. Its /// environment and ancestry belong to whichever process last started it, never to /// the pane that drives a given thread. static func isCodexManagedDaemon(pid: pid_t) -> Bool { guard let info = processBSDInfo(pid: pid), comm(from: info) == "codex", let arguments = processArguments(pid: pid) else { return false } return isCodexManagedDaemon(arguments: arguments) }
static func isCodexManagedDaemon(arguments: [String]) -> Bool { arguments.contains("app-server") && arguments.contains("--managed-daemon") }
static func processBSDInfo(pid: pid_t) -> proc_bsdinfo? { var info = proc_bsdinfo() let size = MemoryLayout<proc_bsdinfo>.size let result = withUnsafeMutablePointer(to: &info) { pointer in proc_pidinfo(pid, PROC_PIDTBSDINFO, 0, pointer, Int32(size)) } return result == Int32(size) ? info : nil }
static func processStartDate(pid: pid_t) -> Date? { guard let info = processBSDInfo(pid: pid), info.pbi_start_tvsec > 0 else { return nil } return Date( timeIntervalSince1970: TimeInterval(info.pbi_start_tvsec) + TimeInterval(info.pbi_start_tvusec) / 1_000_000 ) }
static func openFilePaths(pid: pid_t) -> [String] { var complete = false return openFilePaths(pid: pid, complete: &complete) }
/// State attribution must reject an incomplete inventory. Existing session /// lookup callers can still use the best-effort wrapper above. static func openFilePaths(pid: pid_t, complete: inout Bool) -> [String] { complete = false guard pid > 0 else { return [] } var capacity = 256 var descriptors: [proc_fdinfo] = [] var count = 0 while capacity <= 4_096 { descriptors = [proc_fdinfo](repeating: proc_fdinfo(), count: capacity) let filled = descriptors.withUnsafeMutableBytes { buffer in proc_pidinfo(pid, PROC_PIDLISTFDS, 0, buffer.baseAddress, Int32(buffer.count)) } guard filled > 0 else { return [] } count = Int(filled) / MemoryLayout<proc_fdinfo>.stride if count < capacity { break } capacity *= 2 } complete = count < descriptors.count
return descriptors.prefix(count).compactMap { descriptor -> String? in guard descriptor.proc_fdtype == PROX_FDTYPE_VNODE else { return nil } var info = vnode_fdinfowithpath() let size = MemoryLayout<vnode_fdinfowithpath>.size let result = withUnsafeMutablePointer(to: &info) { pointer in proc_pidfdinfo(pid, descriptor.proc_fd, PROC_PIDFDVNODEPATHINFO, pointer, Int32(size)) } guard result == Int32(size) else { complete = false return nil } // Only writable descriptors identify a session an agent OWNS. Agents // transiently open other sessions read-only (resume pickers, history // browsing); every legitimate signal (Codex rollout, Amp thread log, // Cursor store.db) is open for writing. guard info.pfi.fi_openflags & UInt32(FWRITE) != 0 else { return nil } return withUnsafeBytes(of: info.pvip.vip_path) { rawBuffer -> String? in let bytes = rawBuffer.bindMemory(to: UInt8.self) let end = bytes.firstIndex(of: 0) ?? bytes.endIndex guard end > bytes.startIndex, end < bytes.endIndex, let path = String(bytes: bytes[..<end], encoding: .utf8) else { complete = false return nil } return path } } }
static func comm(from info: proc_bsdinfo) -> String? { let bytes = withUnsafeBytes(of: info.pbi_comm) { rawBuffer -> [UInt8] in Array(rawBuffer) } let end = bytes.firstIndex(of: 0) ?? bytes.count guard end > 0 else { return nil } return String(bytes: bytes[..<end], encoding: .utf8) }
static func kernProcargs2(pid: pid_t) -> [UInt8]? { var mib: [Int32] = [CTL_KERN, KERN_PROCARGS2, pid] var size = 0 guard sysctl(&mib, u_int(mib.count), nil, &size, nil, 0) == 0, size > 0 else { return nil }
var buffer = [UInt8](repeating: 0, count: size) let result = buffer.withUnsafeMutableBufferPointer { pointer in sysctl(&mib, u_int(mib.count), pointer.baseAddress, &size, nil, 0) } guard result == 0 else { return nil } return Array(buffer.prefix(size)) }
static func procargs2Argv(_ buffer: [UInt8]) -> [String]? { guard let parsed = procargs2Strings(buffer) else { return nil } let argv = Array(parsed.strings.prefix(parsed.argc)) return argv.isEmpty ? nil : argv }
/// The `NAME=value` strings that follow argv in a `KERN_PROCARGS2` buffer. static func procargs2Environment(_ buffer: [UInt8]) -> [String]? { guard let parsed = procargs2Strings(buffer), parsed.strings.count >= parsed.argc else { return nil } return parsed.strings.dropFirst(parsed.argc).filter { $0.contains("=") } }
private static func procargs2Strings(_ buffer: [UInt8]) -> (argc: Int, strings: [String])? { guard buffer.count >= MemoryLayout<Int32>.size else { return nil } let argc = buffer.withUnsafeBytes { rawBuffer in rawBuffer.loadUnaligned(as: Int32.self) } guard argc > 0 else { return nil }
var position = MemoryLayout<Int32>.size guard let execEnd = buffer[position...].firstIndex(of: 0) else { return nil } position = execEnd while position < buffer.count, buffer[position] == 0 { position += 1 }
var strings: [String] = [] // Only the executable-path padding may contain extra NUL bytes. Within argv, // each NUL ends one argument, including an empty one. for _ in 0..<Int(argc) { guard position < buffer.count, let end = buffer[position...].firstIndex(of: 0), let value = String(bytes: buffer[position..<end], encoding: .utf8) else { return nil } strings.append(value) position = end + 1 } while position < buffer.count { let start = position while position < buffer.count, buffer[position] != 0 { position += 1 } if position > start, let value = String(bytes: buffer[start..<position], encoding: .utf8) { strings.append(value) } while position < buffer.count, buffer[position] == 0 { position += 1 } }
return (Int(argc), strings) }
static func basename(_ raw: String) -> String? { let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines) .trimmingCharacters(in: CharacterSet(charactersIn: "'\"")) guard !trimmed.isEmpty else { return nil } let name = (trimmed as NSString).lastPathComponent let stripped = name.hasPrefix("-") ? String(name.dropFirst()) : name return stripped.isEmpty ? nil : stripped }}