| import Foundation |
| import OpenClawProtocol |
| import UniformTypeIdentifiers |
|
|
| actor MacNodeBrowserProxy { |
| static let shared = MacNodeBrowserProxy() |
|
|
| struct Endpoint { |
| let baseURL: URL |
| let token: String? |
| let password: String? |
| } |
|
|
| private struct RequestParams: Decodable { |
| let method: String? |
| let path: String? |
| let query: [String: OpenClawProtocol.AnyCodable]? |
| let body: OpenClawProtocol.AnyCodable? |
| let timeoutMs: Int? |
| let profile: String? |
| } |
|
|
| private struct ProxyFilePayload { |
| let path: String |
| let base64: String |
| let mimeType: String? |
|
|
| func asJSON() -> [String: Any] { |
| var json: [String: Any] = [ |
| "path": self.path, |
| "base64": self.base64, |
| ] |
| if let mimeType = self.mimeType { |
| json["mimeType"] = mimeType |
| } |
| return json |
| } |
| } |
|
|
| private static let maxProxyFileBytes = 10 * 1024 * 1024 |
| private let endpointProvider: @Sendable () -> Endpoint |
| private let performRequest: @Sendable (URLRequest) async throws -> (Data, URLResponse) |
|
|
| init( |
| session: URLSession = .shared, |
| endpointProvider: (@Sendable () -> Endpoint)? = nil, |
| performRequest: (@Sendable (URLRequest) async throws -> (Data, URLResponse))? = nil) |
| { |
| self.endpointProvider = endpointProvider ?? MacNodeBrowserProxy.defaultEndpoint |
| self.performRequest = performRequest ?? { request in |
| try await session.data(for: request) |
| } |
| } |
|
|
| func request(paramsJSON: String?) async throws -> String { |
| let params = try Self.decodeRequestParams(from: paramsJSON) |
| let request = try Self.makeRequest(params: params, endpoint: self.endpointProvider()) |
| let (data, response) = try await self.performRequest(request) |
| let http = try Self.requireHTTPResponse(response) |
| guard (200..<300).contains(http.statusCode) else { |
| throw NSError(domain: "MacNodeBrowserProxy", code: http.statusCode, userInfo: [ |
| NSLocalizedDescriptionKey: Self.httpErrorMessage(statusCode: http.statusCode, data: data), |
| ]) |
| } |
|
|
| let result = try JSONSerialization.jsonObject(with: data, options: [.fragmentsAllowed]) |
| let files = try Self.loadProxyFiles(from: result) |
| var payload: [String: Any] = ["result": result] |
| if !files.isEmpty { |
| payload["files"] = files.map { $0.asJSON() } |
| } |
| let payloadData = try JSONSerialization.data(withJSONObject: payload) |
| guard let payloadJSON = String(data: payloadData, encoding: .utf8) else { |
| throw NSError(domain: "MacNodeBrowserProxy", code: 2, userInfo: [ |
| NSLocalizedDescriptionKey: "browser proxy returned invalid UTF-8", |
| ]) |
| } |
| return payloadJSON |
| } |
|
|
| private static func defaultEndpoint() -> Endpoint { |
| let config = GatewayEndpointStore.localConfig() |
| let controlPort = GatewayEnvironment.gatewayPort() + 2 |
| let baseURL = URL(string: "http://127.0.0.1:\(controlPort)")! |
| return Endpoint(baseURL: baseURL, token: config.token, password: config.password) |
| } |
|
|
| private static func decodeRequestParams(from raw: String?) throws -> RequestParams { |
| guard let raw else { |
| throw NSError(domain: "MacNodeBrowserProxy", code: 3, userInfo: [ |
| NSLocalizedDescriptionKey: "INVALID_REQUEST: paramsJSON required", |
| ]) |
| } |
| return try JSONDecoder().decode(RequestParams.self, from: Data(raw.utf8)) |
| } |
|
|
| private static func makeRequest(params: RequestParams, endpoint: Endpoint) throws -> URLRequest { |
| let method = (params.method ?? "GET").trimmingCharacters(in: .whitespacesAndNewlines).uppercased() |
| let path = (params.path ?? "").trimmingCharacters(in: .whitespacesAndNewlines) |
| guard !path.isEmpty else { |
| throw NSError(domain: "MacNodeBrowserProxy", code: 1, userInfo: [ |
| NSLocalizedDescriptionKey: "INVALID_REQUEST: path required", |
| ]) |
| } |
|
|
| let normalizedPath = path.hasPrefix("/") ? path : "/\(path)" |
| guard var components = URLComponents( |
| url: endpoint.baseURL.appendingPathComponent(String(normalizedPath.dropFirst())), |
| resolvingAgainstBaseURL: false) |
| else { |
| throw NSError(domain: "MacNodeBrowserProxy", code: 4, userInfo: [ |
| NSLocalizedDescriptionKey: "INVALID_REQUEST: invalid browser proxy URL", |
| ]) |
| } |
|
|
| var queryItems: [URLQueryItem] = [] |
| if let query = params.query { |
| for key in query.keys.sorted() { |
| let value = query[key]?.value |
| guard value != nil, !(value is NSNull) else { continue } |
| queryItems.append(URLQueryItem(name: key, value: Self.stringValue(for: value))) |
| } |
| } |
| let profile = params.profile?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "" |
| if !profile.isEmpty, !queryItems.contains(where: { $0.name == "profile" }) { |
| queryItems.append(URLQueryItem(name: "profile", value: profile)) |
| } |
| if !queryItems.isEmpty { |
| components.queryItems = queryItems |
| } |
| guard let url = components.url else { |
| throw NSError(domain: "MacNodeBrowserProxy", code: 5, userInfo: [ |
| NSLocalizedDescriptionKey: "INVALID_REQUEST: invalid browser proxy URL", |
| ]) |
| } |
|
|
| var request = URLRequest(url: url) |
| request.httpMethod = method |
| request.timeoutInterval = params.timeoutMs.map { TimeInterval(max($0, 1)) / 1000 } ?? 5 |
| request.setValue("application/json", forHTTPHeaderField: "Accept") |
| if let token = endpoint.token?.trimmingCharacters(in: .whitespacesAndNewlines), !token.isEmpty { |
| request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization") |
| } else if let password = endpoint.password?.trimmingCharacters(in: .whitespacesAndNewlines), |
| !password.isEmpty |
| { |
| request.setValue(password, forHTTPHeaderField: "x-openclaw-password") |
| } |
|
|
| if method != "GET", let body = params.body { |
| request.httpBody = try JSONSerialization.data(withJSONObject: body.foundationValue, options: [.fragmentsAllowed]) |
| request.setValue("application/json", forHTTPHeaderField: "Content-Type") |
| } |
|
|
| return request |
| } |
|
|
| private static func requireHTTPResponse(_ response: URLResponse) throws -> HTTPURLResponse { |
| guard let http = response as? HTTPURLResponse else { |
| throw NSError(domain: "MacNodeBrowserProxy", code: 6, userInfo: [ |
| NSLocalizedDescriptionKey: "browser proxy returned a non-HTTP response", |
| ]) |
| } |
| return http |
| } |
|
|
| private static func httpErrorMessage(statusCode: Int, data: Data) -> String { |
| if let object = try? JSONSerialization.jsonObject(with: data, options: [.fragmentsAllowed]) as? [String: Any], |
| let error = object["error"] as? String, |
| !error.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty |
| { |
| return error |
| } |
| if let text = String(data: data, encoding: .utf8)? |
| .trimmingCharacters(in: .whitespacesAndNewlines), |
| !text.isEmpty |
| { |
| return text |
| } |
| return "HTTP \(statusCode)" |
| } |
|
|
| private static func stringValue(for value: Any?) -> String? { |
| guard let value else { return nil } |
| if let string = value as? String { return string } |
| if let bool = value as? Bool { return bool ? "true" : "false" } |
| if let number = value as? NSNumber { return number.stringValue } |
| return String(describing: value) |
| } |
|
|
| private static func loadProxyFiles(from result: Any) throws -> [ProxyFilePayload] { |
| let paths = self.collectProxyPaths(from: result) |
| return try paths.map(self.loadProxyFile) |
| } |
|
|
| private static func collectProxyPaths(from payload: Any) -> [String] { |
| guard let object = payload as? [String: Any] else { return [] } |
|
|
| var paths = Set<String>() |
| if let path = object["path"] as? String, !path.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty { |
| paths.insert(path.trimmingCharacters(in: .whitespacesAndNewlines)) |
| } |
| if let imagePath = object["imagePath"] as? String, |
| !imagePath.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty |
| { |
| paths.insert(imagePath.trimmingCharacters(in: .whitespacesAndNewlines)) |
| } |
| if let download = object["download"] as? [String: Any], |
| let path = download["path"] as? String, |
| !path.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty |
| { |
| paths.insert(path.trimmingCharacters(in: .whitespacesAndNewlines)) |
| } |
| return paths.sorted() |
| } |
|
|
| private static func loadProxyFile(path: String) throws -> ProxyFilePayload { |
| let url = URL(fileURLWithPath: path) |
| let values = try url.resourceValues(forKeys: [.isRegularFileKey, .fileSizeKey]) |
| guard values.isRegularFile == true else { |
| throw NSError(domain: "MacNodeBrowserProxy", code: 7, userInfo: [ |
| NSLocalizedDescriptionKey: "browser proxy file not found: \(path)", |
| ]) |
| } |
| if let fileSize = values.fileSize, fileSize > Self.maxProxyFileBytes { |
| throw NSError(domain: "MacNodeBrowserProxy", code: 8, userInfo: [ |
| NSLocalizedDescriptionKey: "browser proxy file exceeds 10MB: \(path)", |
| ]) |
| } |
|
|
| let data = try Data(contentsOf: url) |
| let mimeType = UTType(filenameExtension: url.pathExtension)?.preferredMIMEType |
| return ProxyFilePayload(path: path, base64: data.base64EncodedString(), mimeType: mimeType) |
| } |
| } |
|
|
