CodexBar 是一个 macOS 菜单栏应用,用于查看本机 Codex 账号状态、额度、Token 用量、详细统计信息
Swift appkitcodexcodex-clideveloper-toolsmacosmacos-appmenu-bar-appopenai-codexproductivityswiftswiftuiusage-tracker
import CryptoKit
import Darwin
import Foundation
import Testing
/// 只绑定临时 Unix socket, 不访问用户的 Codex 服务或配置
final nonisolated class SharedServerFixture: @unchecked Sendable {
let url = URL(fileURLWithPath: "/tmp/\(UUID().uuidString).sock")
private let descriptor: Int32
private let completed = DispatchSemaphore(value: 0)
private let lock = NSLock()
private var failure: (any Error)?
init(connections: Int = 1, concurrentConnections: Bool = false, handler: @escaping @Sendable (Peer) throws -> Void) throws {
descriptor = socket(AF_UNIX, SOCK_STREAM, 0)
guard descriptor >= 0 else { throw FixtureError.io }
var address = sockaddr_un()
address.sun_family = sa_family_t(AF_UNIX)
withUnsafeMutableBytes(of: &address.sun_path) { bytes in
Array(url.path.utf8CString).withUnsafeBytes { bytes.copyBytes(from: $0) }
}
let bound = withUnsafePointer(to: &address) {
$0.withMemoryRebound(to: sockaddr.self, capacity: 1) {
Darwin.bind(descriptor, $0, socklen_t(MemoryLayout<sockaddr_un>.size))
}
}
guard bound == 0, listen(descriptor, Int32(max(1, connections))) == 0 else {
Darwin.close(descriptor)
throw FixtureError.io
}
DispatchQueue.global().async { [self] in
let clients = DispatchGroup()
defer {
clients.wait()
completed.signal()
}
do {
for _ in 0 ..< connections {
var poller = pollfd(fd: descriptor, events: Int16(POLLIN), revents: 0)
guard poll(&poller, 1, 5000) > 0 else { throw FixtureError.io }
let client = accept(descriptor, nil, nil)
guard client >= 0 else { throw FixtureError.io }
var timeout = timeval(tv_sec: 5, tv_usec: 0)
_ = setsockopt(client, SOL_SOCKET, SO_RCVTIMEO, &timeout, socklen_t(MemoryLayout<timeval>.size))
_ = setsockopt(client, SOL_SOCKET, SO_SNDTIMEO, &timeout, socklen_t(MemoryLayout<timeval>.size))
var enabled: Int32 = 1
_ = setsockopt(client, SOL_SOCKET, SO_NOSIGPIPE, &enabled, socklen_t(MemoryLayout<Int32>.size))
let serve: @Sendable () -> Void = { [self] in
defer { Darwin.close(client) }
do {
let peer = Peer(descriptor: client)
try peer.handshake()
try handler(peer)
} catch {
lock.withLock { failure = error }
}
}
if concurrentConnections {
clients.enter()
DispatchQueue.global().async {
serve()
clients.leave()
}
} else {
serve()
}
}
} catch {
lock.withLock { failure = error }
}
}
}
func finish() throws {
guard completed.wait(timeout: .now() + 6) == .success else { throw FixtureError.io }
if let error = lock.withLock({ failure }) {
throw error
}
}
func close() {
Darwin.close(descriptor)
try? FileManager.default.removeItem(at: url)
}
struct Peer {
let descriptor: Int32
func handshake() throws {
var header = Data()
while !header.suffix(4).elementsEqual([13, 10, 13, 10]), header.count < 16384 {
try header.append(read(1))
}
let text = try #require(String(data: header, encoding: .utf8))
let key = try #require(text.components(separatedBy: "\r\n").first { $0.hasPrefix("Sec-WebSocket-Key: ") }?.dropFirst(19))
let accept = Data(Insecure.SHA1.hash(data: Data((key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").utf8))).base64EncodedString()
try write(Data("HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: \(accept)\r\n\r\n".utf8))
}
func readMessage() throws -> [String: Any] {
let data = try readPayload(opcode: 1)
return try #require(JSONSerialization.jsonObject(with: data) as? [String: Any])
}
func readPayload(opcode: UInt8) throws -> Data {
let header = try [UInt8](read(2))
#expect(header[0] == 0x80 | opcode)
#expect(header[1] & 0x80 != 0)
var length = Int(header[1] & 127)
if length == 126 || length == 127 {
length = try read(length == 126 ? 2 : 8).reduce(0) { ($0 << 8) | Int($1) }
}
guard length < 65536 else { throw FixtureError.io }
let mask = try [UInt8](read(4))
return try Data(read(length).enumerated().map { $0.element ^ mask[$0.offset % 4] })
}
func reply(to request: [String: Any], result: [String: Any]) throws {
try send(["id": #require(request["id"]), "result": result])
}
func send(_ object: [String: Any]) throws {
try sendRaw(JSONSerialization.data(withJSONObject: object))
}
func sendRaw(_ payload: Data, opcode: UInt8 = 1, final: Bool = true) throws {
try sendHeader(length: UInt64(payload.count), opcode: opcode, final: final)
try sendBytes(payload)
}
func sendHeader(length: UInt64, opcode: UInt8 = 1, final: Bool = true) throws {
var frame = Data([(final ? 0x80 : 0) | opcode])
if length < 126 {
frame.append(UInt8(length))
} else if length <= UInt16.max {
frame.append(contentsOf: [126, UInt8(length >> 8), UInt8(length & 255)])
} else {
frame.append(127)
frame.append(contentsOf: (0 ..< 8).reversed().map { UInt8((length >> ($0 * 8)) & 255) })
}
try write(frame)
}
func sendBytes(_ data: Data) throws {
try write(data)
}
private func read(_ count: Int) throws -> Data {
var data = Data()
while data.count < count {
var buffer = [UInt8](repeating: 0, count: count - data.count)
let received = Darwin.read(descriptor, &buffer, buffer.count)
guard received > 0 else { throw FixtureError.io }
data.append(contentsOf: buffer.prefix(received))
}
return data
}
private func write(_ data: Data) throws {
try data.withUnsafeBytes { bytes in
var offset = 0
while offset < bytes.count {
let written = Darwin.write(descriptor, bytes.baseAddress!.advanced(by: offset), bytes.count - offset)
guard written > 0 else { throw FixtureError.io }
offset += written
}
}
}
}
private enum FixtureError: Error { case io }
}