Endpoint Protocol Documentation

# Python Integration Example
import requests
import websocket
import json
import ssl
import platform

class EndpointClient:
    BASE_URL = 'https://endpoint.solutions'
    
    def __init__(self, cert_path, key_path):
        self.cert = (cert_path, key_path)
        
    def register(self, qr_data):
        url = f'{self.BASE_URL}/endpoint/register'
        
        payload = {
            'qr_data': qr_data,
            'device_info': self._gather_device_info()
        }
        
        response = requests.post(
            url,
            json=payload,
            cert=self.cert,
            verify=True
        )
        
        return response.json()
    
    def connect_websocket(self, device_id):
        ws_url = 'wss://endpoint.solutions/cable'
        
        ws = websocket.WebSocketApp(
            ws_url,
            on_open=lambda ws: self._on_open(ws, device_id),
            on_message=self._on_message,
            on_error=self._on_error
        )
        
        ws.run_forever(sslopt={
            'certfile': self.cert[0],
            'keyfile': self.cert[1]
        })
        
    def _on_open(self, ws, device_id):
        subscribe_msg = {
            'command': 'subscribe',
            'identifier': json.dumps({
                'channel': 'EndpointChannel',
                'device_id': device_id
            })
        }
        ws.send(json.dumps(subscribe_msg))
        
    def _on_message(self, ws, message):
        data = json.loads(message)
        self._handle_message(data)
        
    def _gather_device_info(self):
        return {
            'hostname': platform.node(),
            'os_version': platform.mac_ver()[0],
            'hardware_id': self._get_hardware_id()
        }
        
    def _get_hardware_id(self):
        import subprocess
        result = subprocess.run(
            ['system_profiler', 'SPHardwareDataType'],
            capture_output=True,
            text=True
        )
        for line in result.stdout.split('\n'):
            if 'Hardware UUID' in line:
                return line.split(':')[1].strip()
        return None

// Swift Integration Example
import Foundation
import Network
import CryptoKit

class EndpointClient {
    let baseURL = "https://endpoint.solutions"
    let certificate: SecCertificate
    let privateKey: SecKey
    
    init(certificate: SecCertificate, privateKey: SecKey) {
        self.certificate = certificate
        self.privateKey = privateKey
    }
    
    func register(qrData: String) async throws -> RegistrationResponse {
        let url = URL(string: "\(baseURL)/endpoint/register")!
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        
        let payload = RegistrationRequest(
            qrData: qrData,
            deviceInfo: gatherDeviceInfo()
        )
        
        request.httpBody = try JSONEncoder().encode(payload)
        
        let (data, _) = try await URLSession.shared.data(for: request)
        return try JSONDecoder().decode(RegistrationResponse.self, from: data)
    }
    
    func connectWebSocket(deviceId: String) {
        let url = URL(string: "wss://endpoint.solutions/cable")!
        let request = URLRequest(url: url)
        
        let ws = URLSession.shared.webSocketTask(with: request)
        ws.resume()
        
        let subscribeMessage = [
            "command": "subscribe",
            "identifier": try! JSONEncoder().encode([
                "channel": "EndpointChannel",
                "device_id": deviceId
            ])
        ]
        
        ws.send(.string(String(data: try! JSONSerialization.data(withJSONObject: subscribeMessage), encoding: .utf8)!)) { _ in
            self.receiveMessage(from: ws)
        }
    }
    
    private func gatherDeviceInfo() -> DeviceInfo {
        var systemInfo = utsname()
        uname(&systemInfo)
        
        return DeviceInfo(
            hostname: ProcessInfo.processInfo.hostName,
            osVersion: ProcessInfo.processInfo.operatingSystemVersionString,
            hardwareId: getHardwareUUID()
        )
    }
    
    private func getHardwareUUID() -> String {
        let service = IOServiceGetMatchingService(
            kIOMasterPortDefault,
            IOServiceMatching("IOPlatformExpertDevice")
        )
        
        let cfUUID = IORegistryEntryCreateCFProperty(
            service,
            kIOPlatformUUIDKey as CFString,
            kCFAllocatorDefault,
            0
        )
        
        IOObjectRelease(service)
        return cfUUID?.takeRetainedValue() as? String ?? ""
    }
}