Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.
Rust agentai-agentapplecomputer-usecomputer-use-agentcontainerizationcuadesktop-automationhacktoberfestlumemacosmanusoperatorswiftvirtualizationvirtualization-frameworkwindowswindows-sandbox
import Foundation
import NIOCore
import NIOPosix
import NIOHTTP1
// MARK: - Error Types
enum PortError: Error, LocalizedError {
case alreadyInUse(port: UInt16)
var errorDescription: String? {
switch self {
case .alreadyInUse(let port):
return "Port \(port) is already in use by another process"
}
}
}
// MARK: - NIO Channel Handler
/// Accumulates HTTP/1.1 request parts delivered by NIOHTTP1's decoder (which
/// already handles Content-Length / chunked-encoding reassembly), then
/// dispatches the complete request to the Server's route handlers.
private final class HTTPChannelHandler: ChannelInboundHandler, @unchecked Sendable {
typealias InboundIn = HTTPServerRequestPart
typealias OutboundOut = HTTPServerResponsePart
private var requestHead: HTTPRequestHead?
private var bodyBuffer: ByteBuffer = ByteBuffer()
private let server: Server
init(server: Server) {
self.server = server
}
func channelRead(context: ChannelHandlerContext, data: NIOAny) {
switch unwrapInboundIn(data) {
case .head(let head):
requestHead = head
bodyBuffer.clear()
case .body(var buf):
bodyBuffer.writeBuffer(&buf)
case .end:
guard let head = requestHead else { return }
let bodyData: Data? =
bodyBuffer.readableBytes > 0 ? Data(bodyBuffer.readableBytesView) : nil
var headers: [String: String] = [:]
for (name, value) in head.headers {
headers[name.description] = value
}
let request = HTTPRequest(
method: head.method.rawValue,
path: head.uri,
headers: headers,
body: bodyData
)
Logger.info(
"Received request",
metadata: [
"method": request.method,
"path": request.path,
"body": String(data: bodyData ?? Data(), encoding: .utf8) ?? "",
])
// Bridge to Swift concurrency via an EventLoopPromise so that
// ChannelHandlerContext (non-Sendable) is only ever accessed on
// the event loop — never sent across actor boundaries.
let promise = context.eventLoop.makePromise(of: HTTPResponse.self)
let srv = server
Task {
do {
let response = try await srv.handleRequest(request)
promise.succeed(response)
} catch {
promise.succeed(srv.errorResponse(error))
}
}
promise.futureResult.whenComplete { result in
let response: HTTPResponse
switch result {
case .success(let r): response = r
case .failure(let e): response = srv.errorResponse(e)
}
HTTPChannelHandler.writeResponse(response, to: context)
}
}
}
private static func writeResponse(_ response: HTTPResponse, to context: ChannelHandlerContext) {
var nioHeaders = HTTPHeaders()
for (k, v) in response.headers {
nioHeaders.add(name: k, value: v)
}
if let body = response.body {
nioHeaders.replaceOrAdd(name: "Content-Length", value: "\(body.count)")
}
let status = HTTPResponseStatus(statusCode: response.statusCode.rawValue)
let head = HTTPResponseHead(version: .http1_1, status: status, headers: nioHeaders)
Logger.info(
"Sending response",
metadata: [
"statusCode": "\(response.statusCode.rawValue)",
"body": String(data: response.body ?? Data(), encoding: .utf8) ?? "",
])
context.eventLoop.execute {
context.write(NIOAny(HTTPServerResponsePart.head(head)), promise: nil)
if let body = response.body {
var buf = context.channel.allocator.buffer(capacity: body.count)
buf.writeBytes(body)
context.write(NIOAny(HTTPServerResponsePart.body(.byteBuffer(buf))), promise: nil)
}
context.writeAndFlush(NIOAny(HTTPServerResponsePart.end(nil)), promise: nil)
}
}
func errorCaught(context: ChannelHandlerContext, error: Error) {
Logger.error("Channel error", metadata: ["error": error.localizedDescription])
context.close(promise: nil)
}
}
// MARK: - Server Class
final class Server: @unchecked Sendable {
// MARK: - Route Type
private struct Route {
let method: String
let path: String
let handler: (HTTPRequest) async throws -> HTTPResponse
func matches(_ request: HTTPRequest) -> Bool {
if method != request.method { return false }
let routeParts = path.split(separator: "/")
let requestParts = request.path.split(separator: "/")
if routeParts.count != requestParts.count { return false }
for (routePart, requestPart) in zip(routeParts, requestParts) {
if routePart.hasPrefix(":") { continue }
if routePart != requestPart { return false }
}
return true
}
func extractParams(_ request: HTTPRequest) -> [String: String] {
var params: [String: String] = [:]
let routeParts = path.split(separator: "/")
let requestPathOnly = request.path.split(separator: "?", maxSplits: 1)[0]
let requestParts = requestPathOnly.split(separator: "/")
for (routePart, requestPart) in zip(routeParts, requestParts) {
if routePart.hasPrefix(":") {
params[String(routePart.dropFirst())] = String(requestPart)
}
}
return params
}
}
// MARK: - Properties
private let portNumber: UInt16
private let controller: LumeController
private var routes: [Route]
// _channelLock guards both _serverChannel and _eventLoopGroup, which are
// written in start() and read in stop() — potentially from different tasks.
private let _channelLock = NSLock()
private var _serverChannel: (any Channel)?
private var _eventLoopGroup: (any EventLoopGroup)?
private var serverChannel: (any Channel)? {
get { _channelLock.withLock { _serverChannel } }
set { _channelLock.withLock { _serverChannel = newValue } }
}
private var eventLoopGroup: (any EventLoopGroup)? {
get { _channelLock.withLock { _eventLoopGroup } }
set { _channelLock.withLock { _eventLoopGroup = newValue } }
}
// MARK: - Initialization
init(port: UInt16 = LumeChannel.current.lumePort) {
self.portNumber = port
self.controller = LumeController()
self.routes = []
self.setupRoutes()
}
// MARK: - Route Setup
private func setupRoutes() {
routes = [
Route(
method: "GET", path: "/lume/vms",
handler: { [weak self] request in
guard let self else { throw HTTPError.internalError }
let storage = self.extractQueryParam(request: request, name: "storage")
return try await self.handleListVMs(storage: storage)
}),
Route(
method: "GET", path: "/lume/vms/:name",
handler: { [weak self] request in
guard let self else { throw HTTPError.internalError }
let params = self.extractPathParams(pattern: "/lume/vms/:name", from: request)
guard let name = params["name"] else {
return HTTPResponse(statusCode: .badRequest, body: "Missing VM name")
}
let storage = self.extractQueryParam(request: request, name: "storage")
return try await self.handleGetVM(name: name, storage: storage)
}),
Route(
method: "DELETE", path: "/lume/vms/:name",
handler: { [weak self] request in
guard let self else { throw HTTPError.internalError }
let params = self.extractPathParams(pattern: "/lume/vms/:name", from: request)
guard let name = params["name"] else {
return HTTPResponse(statusCode: .badRequest, body: "Missing VM name")
}
let storage = self.extractQueryParam(request: request, name: "storage")
return try await self.handleDeleteVM(name: name, storage: storage)
}),
Route(
method: "POST", path: "/lume/vms",
handler: { [weak self] request in
guard let self else { throw HTTPError.internalError }
return try await self.handleCreateVM(request.body)
}),
Route(
method: "POST", path: "/lume/vms/clone",
handler: { [weak self] request in
guard let self else { throw HTTPError.internalError }
return try await self.handleCloneVM(request.body)
}),
Route(
method: "PATCH", path: "/lume/vms/:name",
handler: { [weak self] request in
guard let self else { throw HTTPError.internalError }
let params = self.extractPathParams(pattern: "/lume/vms/:name", from: request)
guard let name = params["name"] else {
return HTTPResponse(statusCode: .badRequest, body: "Missing VM name")
}
return try await self.handleSetVM(name: name, body: request.body)
}),
Route(
method: "POST", path: "/lume/vms/:name/run",
handler: { [weak self] request in
guard let self else { throw HTTPError.internalError }
let params = self.extractPathParams(pattern: "/lume/vms/:name/run", from: request)
guard let name = params["name"] else {
return HTTPResponse(statusCode: .badRequest, body: "Missing VM name")
}
return try await self.handleRunVM(name: name, body: request.body)
}),
Route(
method: "POST", path: "/lume/vms/:name/stop",
handler: { [weak self] request in
guard let self else { throw HTTPError.internalError }
let params = self.extractPathParams(
pattern: "/lume/vms/:name/stop", from: request)
guard let name = params["name"] else {
return HTTPResponse(statusCode: .badRequest, body: "Missing VM name")
}
Logger.info(
"Processing stop VM request",
metadata: ["method": request.method, "path": request.path])
var storage: String? = nil
var force = false
var timeout = VM.defaultStopTimeout
if let bodyData = request.body, !bodyData.isEmpty {
do {
if let json = try JSONSerialization.jsonObject(with: bodyData)
as? [String: Any]
{
if let bodyStorage = json["storage"] as? String {
storage = bodyStorage
}
if let bodyForce = json["force"] as? Bool {
force = bodyForce
}
if let bodyTimeout = json["timeout"] as? NSNumber {
timeout = max(bodyTimeout.doubleValue, 0)
}
}
} catch {}
}
return try await self.handleStopVM(
name: name, storage: storage, force: force, timeout: timeout)
}),
Route(
method: "POST", path: "/lume/vms/:name/suspend",
handler: { [weak self] request in
guard let self else { throw HTTPError.internalError }
let params = self.extractPathParams(
pattern: "/lume/vms/:name/suspend", from: request)
guard let name = params["name"] else {
return HTTPResponse(statusCode: .badRequest, body: "Missing VM name")
}
return try await self.handleSuspendVM(name: name)
}),
Route(
method: "POST", path: "/lume/vms/:name/rename",
handler: { [weak self] request in
guard let self else { throw HTTPError.internalError }
let params = self.extractPathParams(
pattern: "/lume/vms/:name/rename", from: request)
guard let name = params["name"] else {
return HTTPResponse(statusCode: .badRequest, body: "Missing VM name")
}
return try await self.handleRenameVM(name: name, body: request.body)
}),
Route(
method: "POST", path: "/lume/vms/:name/setup",
handler: { [weak self] request in
guard let self else { throw HTTPError.internalError }
let params = self.extractPathParams(
pattern: "/lume/vms/:name/setup", from: request)
guard let name = params["name"] else {
return HTTPResponse(statusCode: .badRequest, body: "Missing VM name")
}
return try await self.handleSetupVM(name: name, body: request.body)
}),
Route(
method: "GET", path: "/lume/ipsw",
handler: { [weak self] _ in
guard let self else { throw HTTPError.internalError }
return try await self.handleIPSW()
}),
Route(
method: "POST", path: "/lume/pull",
handler: { [weak self] request in
guard let self else { throw HTTPError.internalError }
return try await self.handlePull(request.body)
}),
Route(
method: "POST", path: "/lume/pull/start",
handler: { [weak self] request in
guard let self else { throw HTTPError.internalError }
return try await self.handlePullStart(request.body)
}),
Route(
method: "POST", path: "/lume/pull/cancel",
handler: { [weak self] request in
guard let self else { throw HTTPError.internalError }
return try await self.handlePullCancel(request.body)
}),
Route(
method: "POST", path: "/lume/prune",
handler: { [weak self] _ in
guard let self else { throw HTTPError.internalError }
return try await self.handlePruneImages()
}),
Route(
method: "GET", path: "/lume/images",
handler: { [weak self] request in
guard let self else { throw HTTPError.internalError }
return try await self.handleGetImages(request)
}),
Route(
method: "GET", path: "/lume/config",
handler: { [weak self] _ in
guard let self else { throw HTTPError.internalError }
return try await self.handleGetConfig()
}),
Route(
method: "POST", path: "/lume/config",
handler: { [weak self] request in
guard let self else { throw HTTPError.internalError }
return try await self.handleUpdateConfig(request.body)
}),
Route(
method: "GET", path: "/lume/config/locations",
handler: { [weak self] _ in
guard let self else { throw HTTPError.internalError }
return try await self.handleGetLocations()
}),
Route(
method: "POST", path: "/lume/config/locations",
handler: { [weak self] request in
guard let self else { throw HTTPError.internalError }
return try await self.handleAddLocation(request.body)
}),
Route(
method: "DELETE", path: "/lume/config/locations/:name",
handler: { [weak self] request in
guard let self else { throw HTTPError.internalError }
let params = self.extractPathParams(
pattern: "/lume/config/locations/:name", from: request)
guard let name = params["name"] else {
return HTTPResponse(statusCode: .badRequest, body: "Missing location name")
}
return try await self.handleRemoveLocation(name)
}),
Route(
method: "GET", path: "/lume/logs",
handler: { [weak self] request in
guard let self else { throw HTTPError.internalError }
let type = self.extractQueryParam(request: request, name: "type")
let linesParam = self.extractQueryParam(request: request, name: "lines")
let lines = linesParam.flatMap { Int($0) }
return try await self.handleGetLogs(type: type, lines: lines)
}),
Route(
method: "POST", path: "/lume/config/locations/default/:name",
handler: { [weak self] request in
guard let self else { throw HTTPError.internalError }
let params = self.extractPathParams(
pattern: "/lume/config/locations/default/:name", from: request)
guard let name = params["name"] else {
return HTTPResponse(statusCode: .badRequest, body: "Missing location name")
}
return try await self.handleSetDefaultLocation(name)
}),
Route(
method: "POST", path: "/lume/vms/push",
handler: { [weak self] request in
guard let self else { throw HTTPError.internalError }
return try await self.handlePush(request.body)
}),
Route(
method: "GET", path: "/lume/host/status",
handler: { [weak self] _ in
guard let self else { throw HTTPError.internalError }
return try await self.handleGetHostStatus()
}),
]
}
// MARK: - Helpers
private func extractQueryParam(request: HTTPRequest, name: String) -> String? {
let parts = request.path.split(separator: "?", maxSplits: 1)
guard parts.count > 1 else { return nil }
let queryString = String(parts[1])
if let urlComponents = URLComponents(string: "http://placeholder.com?" + queryString),
let queryItems = urlComponents.queryItems
{
return queryItems.first(where: { $0.name == name })?.value?.removingPercentEncoding
}
return nil
}
private func extractPathParams(pattern: String, from request: HTTPRequest) -> [String: String] {
var params: [String: String] = [:]
let routeParts = pattern.split(separator: "/")
let requestPathOnly = request.path.split(separator: "?", maxSplits: 1)[0]
let requestParts = requestPathOnly.split(separator: "/")
for (routePart, requestPart) in zip(routeParts, requestParts) {
if routePart.hasPrefix(":") {
params[String(routePart.dropFirst())] = String(requestPart)
}
}
return params
}
// MARK: - Server Lifecycle
func start() async throws {
let group = MultiThreadedEventLoopGroup(numberOfThreads: System.coreCount)
eventLoopGroup = group
let srv = self
let bootstrap = ServerBootstrap(group: group)
.serverChannelOption(ChannelOptions.backlog, value: 256)
.serverChannelOption(ChannelOptions.socketOption(.so_reuseaddr), value: 1)
.childChannelInitializer { channel in
channel.pipeline.configureHTTPServerPipeline().flatMap {
channel.pipeline.addHandler(HTTPChannelHandler(server: srv))
}
}
do {
let channel = try await bootstrap.bind(host: "127.0.0.1", port: Int(portNumber)).get()
serverChannel = channel
Logger.info("Server started", metadata: ["port": "\(portNumber)"])
try await channel.closeFuture.get()
} catch let ioError as IOError where ioError.errnoCode == EADDRINUSE {
try? await group.shutdownGracefully()
throw PortError.alreadyInUse(port: portNumber)
} catch {
try? await group.shutdownGracefully()
throw error
}
try? await group.shutdownGracefully()
}
func stop() {
serverChannel?.close(promise: nil)
if let group = eventLoopGroup {
Task { try? await group.shutdownGracefully() }
}
}
// MARK: - Request Handling
func handleRequest(_ request: HTTPRequest) async throws -> HTTPResponse {
Logger.info(
"Parsed request",
metadata: [
"method": request.method,
"path": request.path,
"body": String(data: request.body ?? Data(), encoding: .utf8) ?? "",
])
guard let route = routes.first(where: { $0.matches(request) }) else {
return HTTPResponse(statusCode: .notFound, body: "Not found")
}
let operation = TelemetryClient.httpOperation(method: route.method, routePath: route.path)
let startedAt = Date()
let response: HTTPResponse
do {
response = try await route.handler(request)
let success = response.statusCode.rawValue < 400
let errorClass: TelemetryErrorClass
switch response.statusCode {
case .badRequest: errorClass = .invalidParams
case .notFound: errorClass = .notFound
case .internalServerError: errorClass = .internalError
default: errorClass = .none
}
TelemetryClient.shared.recordOperationCompleted(
operation: operation,
transport: .http,
success: success,
errorClass: errorClass,
elapsed: Date().timeIntervalSince(startedAt),
phase: response.statusCode == .accepted ? "accepted" : "completed"
)
} catch {
TelemetryClient.shared.recordOperationCompleted(
operation: operation,
transport: .http,
success: false,
errorClass: .internalError,
elapsed: Date().timeIntervalSince(startedAt)
)
throw error
}
Logger.info(
"Sending response",
metadata: [
"statusCode": "\(response.statusCode.rawValue)",
"body": String(data: response.body ?? Data(), encoding: .utf8) ?? "",
])
return response
}
func errorResponse(_ error: Error) -> HTTPResponse {
HTTPResponse(
statusCode: .internalServerError,
headers: ["Content-Type": "application/json"],
body: try! JSONEncoder().encode(APIError(message: error.localizedDescription))
)
}
}