feat(ios): add ClawdisNode app scaffold

apps/ios/Sources/Bridge/BridgeClient.swift

@@ -0,0 +1,121 @@
+import ClawdisNodeKit
+import Foundation
+import Network
+
+actor BridgeClient {
+    private let encoder = JSONEncoder()
+    private let decoder = JSONDecoder()
+
+    func pairAndHello(
+        endpoint: NWEndpoint,
+        nodeId: String,
+        displayName: String?,
+        platform: String,
+        version: String,
+        existingToken: String?) async throws -> String
+    {
+        let connection = NWConnection(to: endpoint, using: .tcp)
+        let queue = DispatchQueue(label: "com.steipete.clawdis.ios.bridge-client")
+        connection.start(queue: queue)
+
+        let token = existingToken
+        try await self.send(
+            BridgeHello(
+                nodeId: nodeId,
+                displayName: displayName,
+                token: token,
+                platform: platform,
+                version: version),
+            over: connection)
+
+        if let line = try await self.receiveLine(over: connection),
+           let data = line.data(using: .utf8),
+           let base = try? self.decoder.decode(BridgeBaseFrame.self, from: data)
+        {
+            if base.type == "hello-ok" {
+                connection.cancel()
+                return existingToken ?? ""
+            }
+            if base.type == "error" {
+                let err = try self.decoder.decode(BridgeErrorFrame.self, from: data)
+                if err.code == "NOT_PAIRED" || err.code == "UNAUTHORIZED" {
+                    try await self.send(
+                        BridgePairRequest(
+                            nodeId: nodeId,
+                            displayName: displayName,
+                            platform: platform,
+                            version: version),
+                        over: connection)
+
+                    while let next = try await self.receiveLine(over: connection) {
+                        guard let nextData = next.data(using: .utf8) else { continue }
+                        let nextBase = try self.decoder.decode(BridgeBaseFrame.self, from: nextData)
+                        if nextBase.type == "pair-ok" {
+                            let ok = try self.decoder.decode(BridgePairOk.self, from: nextData)
+                            connection.cancel()
+                            return ok.token
+                        }
+                        if nextBase.type == "error" {
+                            let e = try self.decoder.decode(BridgeErrorFrame.self, from: nextData)
+                            connection.cancel()
+                            throw NSError(domain: "Bridge", code: 2, userInfo: [
+                                NSLocalizedDescriptionKey: "\(e.code): \(e.message)",
+                            ])
+                        }
+                    }
+                }
+                connection.cancel()
+                throw NSError(domain: "Bridge", code: 1, userInfo: [
+                    NSLocalizedDescriptionKey: "\(err.code): \(err.message)",
+                ])
+            }
+        }
+
+        connection.cancel()
+        throw NSError(domain: "Bridge", code: 0, userInfo: [
+            NSLocalizedDescriptionKey: "Unexpected bridge response",
+        ])
+    }
+
+    private func send(_ obj: some Encodable, over connection: NWConnection) async throws {
+        let data = try self.encoder.encode(obj)
+        var line = Data()
+        line.append(data)
+        line.append(0x0A)
+        try await withCheckedThrowingContinuation { (cont: CheckedContinuation<Void, Error>) in
+            connection.send(content: line, completion: .contentProcessed { err in
+                if let err { cont.resume(throwing: err) } else { cont.resume(returning: ()) }
+            })
+        }
+    }
+
+    private func receiveLine(over connection: NWConnection) async throws -> String? {
+        var buffer = Data()
+        while true {
+            if let idx = buffer.firstIndex(of: 0x0A) {
+                let lineData = buffer.prefix(upTo: idx)
+                return String(data: lineData, encoding: .utf8)
+            }
+
+            let chunk = try await self.receiveChunk(over: connection)
+            if chunk.isEmpty { return nil }
+            buffer.append(chunk)
+        }
+    }
+
+    private func receiveChunk(over connection: NWConnection) async throws -> Data {
+        try await withCheckedThrowingContinuation { (cont: CheckedContinuation<Data, Error>) in
+            connection.receive(minimumIncompleteLength: 1, maximumLength: 64 * 1024) { data, _, isComplete, error in
+                if let error {
+                    cont.resume(throwing: error)
+                    return
+                }
+                if isComplete {
+                    cont.resume(returning: Data())
+                    return
+                }
+                cont.resume(returning: data ?? Data())
+            }
+        }
+    }
+}