enigma-memory 0.1.18 → 0.1.22

package/apps/ios/EnigmaCore/Sources/EnigmaCore/EnigmaAPIClient.swift

@@ -0,0 +1,227 @@
+import Foundation
+#if canImport(FoundationNetworking)
+import FoundationNetworking
+#endif
+
+public actor EnigmaAPIClient {
+    public typealias TokenProvider = @Sendable () async throws -> String?
+
+    private let baseURL: URL
+    private let session: URLSession
+    private let tokenProvider: TokenProvider
+    private let encoder: JSONEncoder
+    private let decoder: JSONDecoder
+
+    public init(baseURL: URL, session: URLSession = .shared, tokenProvider: @escaping TokenProvider) throws {
+        guard let scheme = baseURL.scheme?.lowercased(), let host = baseURL.host?.lowercased() else { throw EnigmaAPIError.invalidBaseURL }
+        let loopback = ["localhost", "127.0.0.1", "::1"].contains(host)
+        guard scheme == "https" || (scheme == "http" && loopback) else { throw EnigmaAPIError.invalidBaseURL }
+        self.baseURL = baseURL
+        self.session = session
+        self.tokenProvider = tokenProvider
+        encoder = JSONEncoder()
+        decoder = JSONDecoder()
+    }
+
+    public func platform() async throws -> PlatformResponse {
+        try await request(path: "/v1/platform", method: "GET", response: PlatformResponse.self)
+    }
+
+    public func models() async throws -> [PlatformModel] {
+        try await request(path: "/v1/models", method: "GET", response: ModelListResponse.self).data
+    }
+
+    public func imageModels() async throws -> [PlatformModel] {
+        try await request(path: "/v1/images/models", method: "GET", response: ModelListResponse.self).data
+    }
+
+    public func videoModels() async throws -> [PlatformModel] {
+        try await request(path: "/v1/videos/models", method: "GET", response: ModelListResponse.self).data
+    }
+
+    public func complete(_ input: ChatCompletionRequest) async throws -> ChatCompletionResponse {
+        try await request(path: "/v1/chat/completions", method: "POST", body: input, response: ChatCompletionResponse.self, maximumBytes: 8 * 1_024 * 1_024)
+    }
+
+    public func generateImage(_ input: ImageGenerationRequest) async throws -> ImageGenerationResponse {
+        try await request(path: "/v1/images/generations", method: "POST", body: input, response: ImageGenerationResponse.self, maximumBytes: 34 * 1_024 * 1_024)
+    }
+
+
+    public func queueVideo(_ input: VideoQueueRequest) async throws -> VideoJob {
+        try await request(path: "/v1/videos/queue", method: "POST", body: input, response: VideoJob.self)
+    }
+
+    public func retrieveVideo(id: String) async throws -> VideoRetrieveResponse {
+        try await request(path: "/v1/videos/retrieve", method: "POST", body: IdentifierBody(id: id), response: VideoRetrieveResponse.self, maximumBytes: 34 * 1_024 * 1_024)
+    }
+
+    public func createCodeSession() async throws -> CodeSession {
+        try await request(path: "/v1/code/sessions", method: "POST", body: LanguageBody(language: "javascript"), response: CodeSessionEnvelope.self).session
+    }
+
+    public func uploadCode(sessionID: String, source: String) async throws {
+        let _: OperationOK = try await request(
+            path: "/v1/code/sessions/\(pathSegment(sessionID))/uploads",
+            method: "POST",
+            body: CodeUploadRequest(data: source),
+            response: OperationOK.self
+        )
+    }
+
+    public func executeCode(sessionID: String) async throws -> CodeExecutionResponse {
+        try await request(
+            path: "/v1/code/sessions/\(pathSegment(sessionID))/execute",
+            method: "POST",
+            body: CodeExecuteRequest(),
+            response: CodeExecutionResponse.self
+        )
+    }
+
+    public func codeEvents(sessionID: String) async throws -> [CodeEvent] {
+        try await request(path: "/v1/code/sessions/\(pathSegment(sessionID))/events", method: "GET", response: CodeEventsResponse.self).events
+    }
+
+    public func burnCodeSession(id: String) async throws -> CodeSession {
+        try await request(path: "/v1/code/sessions/\(pathSegment(id))", method: "DELETE", response: CodeSessionEnvelope.self).session
+    }
+
+    public func createBrowserSession() async throws -> BrowserSession {
+        try await request(path: "/v1/browser/sessions", method: "POST", body: EmptyBody(), response: BrowserSessionEnvelope.self).session
+    }
+
+    public func connectBrowserSession(id: String) async throws -> BrowserSession {
+        try await request(path: "/v1/browser/sessions/\(pathSegment(id))/connect", method: "POST", body: EmptyBody(), response: BrowserSessionEnvelope.self).session
+    }
+
+    public func navigateBrowserSession(id: String, url: String) async throws -> BrowserSession {
+        try await request(path: "/v1/browser/sessions/\(pathSegment(id))/navigate", method: "POST", body: BrowserNavigateRequest(url: url), response: BrowserSessionEnvelope.self).session
+    }
+
+    public func burnBrowserSession(id: String) async throws -> BrowserSession {
+        try await request(path: "/v1/browser/sessions/\(pathSegment(id))", method: "DELETE", response: BrowserSessionEnvelope.self).session
+    }
+    public func createCreditsVault() async throws -> CreditsSessionResponse {
+        try await request(path: "/v1/credits/vaults", method: "POST", body: EmptyBody(), response: CreditsSessionResponse.self)
+    }
+
+    public func recoverCreditsVault(code: String) async throws -> CreditsSessionResponse {
+        try await request(path: "/v1/credits/recover", method: "POST", body: RecoveryBody(recoveryCode: code), response: CreditsSessionResponse.self)
+    }
+
+    public func creditsStatus(accessToken: String) async throws -> CreditsVault {
+        try await request(path: "/v1/credits", method: "GET", response: CreditsStatusResponse.self, overrideBearer: accessToken).vault
+    }
+
+    public func creditPackages() async throws -> [CreditPackage] {
+        try await request(path: "/v1/payments/packages", method: "GET", response: CreditPackagesResponse.self).packages
+    }
+
+    public func usage(days: Int = 30) async throws -> UsageAggregate {
+        let safeDays = min(400, max(1, days))
+        return try await request(path: "/v1/usage?days=\(safeDays)", method: "GET", response: UsageAggregate.self)
+    }
+
+    private func request<Response: Decodable & Sendable>(
+        path: String,
+        method: String,
+        response: Response.Type,
+        maximumBytes: Int = 2 * 1_024 * 1_024,
+        overrideBearer: String? = nil
+    ) async throws -> Response {
+        try await request(path: path, method: method, bodyData: nil, response: response, maximumBytes: maximumBytes, overrideBearer: overrideBearer)
+    }
+
+    private func request<Body: Encodable & Sendable, Response: Decodable & Sendable>(
+        path: String,
+        method: String,
+        body: Body,
+        response: Response.Type,
+        maximumBytes: Int = 2 * 1_024 * 1_024,
+        overrideBearer: String? = nil
+    ) async throws -> Response {
+        try await request(path: path, method: method, bodyData: try encoder.encode(body), response: response, maximumBytes: maximumBytes, overrideBearer: overrideBearer)
+    }
+
+    private func request<Response: Decodable & Sendable>(
+        path: String,
+        method: String,
+        bodyData: Data?,
+        response: Response.Type,
+        maximumBytes: Int,
+        overrideBearer: String?
+    ) async throws -> Response {
+        guard let url = URL(string: path, relativeTo: baseURL)?.absoluteURL,
+              url.scheme == baseURL.scheme, url.host == baseURL.host, url.port == baseURL.port else {
+            throw EnigmaAPIError.invalidBaseURL
+        }
+        var request = URLRequest(url: url, cachePolicy: .reloadIgnoringLocalCacheData, timeoutInterval: 120)
+        request.httpMethod = method
+        request.httpBody = bodyData
+        request.setValue("application/json", forHTTPHeaderField: "Accept")
+        request.setValue("no-store", forHTTPHeaderField: "Cache-Control")
+        if bodyData != nil { request.setValue("application/json", forHTTPHeaderField: "Content-Type") }
+        let token: String?
+        if let overrideBearer { token = overrideBearer }
+        else { token = try await tokenProvider() }
+        if let token, !token.isEmpty { request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization") }
+        else if path.hasPrefix("/v1/") && overrideBearer == nil { throw EnigmaAPIError.unauthenticated }
+
+        let (data, urlResponse) = try await session.data(for: request, delegate: nil)
+        guard let http = urlResponse as? HTTPURLResponse else { throw EnigmaAPIError.invalidResponse }
+        if data.count > maximumBytes { throw EnigmaAPIError.responseTooLarge }
+        guard (200..<300).contains(http.statusCode) else {
+            let envelope = try? decoder.decode(APIErrorEnvelope.self, from: data)
+            throw EnigmaAPIError.server(
+                status: http.statusCode,
+                code: envelope?.error.code,
+                message: envelope?.error.message ?? HTTPURLResponse.localizedString(forStatusCode: http.statusCode)
+            )
+        }
+        do { return try decoder.decode(Response.self, from: data) }
+        catch { throw EnigmaAPIError.invalidResponse }
+    }
+
+    private func pathSegment(_ value: String) -> String {
+        let allowed = CharacterSet.alphanumerics.union(CharacterSet(charactersIn: "-._~"))
+        return value.addingPercentEncoding(withAllowedCharacters: allowed) ?? ""
+    }
+}
+
+private struct EmptyBody: Codable, Sendable {}
+private struct RecoveryBody: Codable, Sendable { let recoveryCode: String }
+private struct IdentifierBody: Codable, Sendable { let id: String }
+private struct LanguageBody: Codable, Sendable { let language: String }
+private struct OperationOK: Codable, Sendable { let ok: Bool }
+
+public struct OAuthAuthorizationServerMetadata: Codable, Sendable {
+    public let issuer: String
+    public let authorizationEndpoint: String
+    public let tokenEndpoint: String
+    public let registrationEndpoint: String?
+    public let scopesSupported: [String]?
+
+    enum CodingKeys: String, CodingKey {
+        case issuer
+        case authorizationEndpoint = "authorization_endpoint"
+        case tokenEndpoint = "token_endpoint"
+        case registrationEndpoint = "registration_endpoint"
+        case scopesSupported = "scopes_supported"
+    }
+}
+
+public struct OAuthTokenResponse: Codable, Sendable {
+    public let accessToken: String
+    public let tokenType: String
+    public let expiresIn: Int
+    public let refreshToken: String?
+    public let scope: String
+
+    enum CodingKeys: String, CodingKey {
+        case accessToken = "access_token"
+        case tokenType = "token_type"
+        case expiresIn = "expires_in"
+        case refreshToken = "refresh_token"
+        case scope
+    }
+}

package/apps/ios/EnigmaCore/Sources/EnigmaCore/Models.swift

@@ -0,0 +1,278 @@
+import Foundation
+
+public enum EnigmaRole: String, Codable, Sendable {
+    case system, user, assistant, tool
+}
+public enum EnigmaOAuthScopes {
+    public static let iOSPlatform = [
+        "models:invoke",
+        "images:generate",
+        "video:generate",
+        "code:execute",
+        "browser:control",
+        "usage:read",
+        "credits:create",
+        "offline_access",
+    ]
+}
+
+
+public struct EnigmaMessage: Identifiable, Codable, Hashable, Sendable {
+    public let id: UUID
+    public let role: EnigmaRole
+    public var content: String
+    public let createdAt: Date
+
+    public init(id: UUID = UUID(), role: EnigmaRole, content: String, createdAt: Date = Date()) {
+        self.id = id
+        self.role = role
+        self.content = content
+        self.createdAt = createdAt
+    }
+
+    enum CodingKeys: String, CodingKey { case role, content }
+
+    public init(from decoder: Decoder) throws {
+        let values = try decoder.container(keyedBy: CodingKeys.self)
+        id = UUID()
+        role = try values.decode(EnigmaRole.self, forKey: .role)
+        content = try values.decode(String.self, forKey: .content)
+        createdAt = Date()
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        var values = encoder.container(keyedBy: CodingKeys.self)
+        try values.encode(role, forKey: .role)
+        try values.encode(content, forKey: .content)
+    }
+}
+
+public struct ChatCompletionRequest: Codable, Sendable {
+    public var messages: [EnigmaMessage]
+    public var model: String
+    public var privacyMode: String
+    public var temperature: Double
+    public var maxTokens: Int
+    public var requirePrivateRoute: Bool
+
+    public init(messages: [EnigmaMessage], model: String = "enigma-auto", privacyMode: String = "smart", temperature: Double = 0.7, maxTokens: Int = 2_048, requirePrivateRoute: Bool = false) {
+        self.messages = messages
+        self.model = model
+        self.privacyMode = privacyMode
+        self.temperature = temperature
+        self.maxTokens = maxTokens
+        self.requirePrivateRoute = requirePrivateRoute
+    }
+
+    enum CodingKeys: String, CodingKey {
+        case messages, model, temperature
+        case privacyMode = "privacy_mode"
+        case maxTokens = "max_tokens"
+        case requirePrivateRoute = "require_private_route"
+    }
+}
+
+public struct TokenUsage: Codable, Hashable, Sendable {
+    public let promptTokens: Int?
+    public let completionTokens: Int?
+    public let totalTokens: Int?
+
+    enum CodingKeys: String, CodingKey {
+        case promptTokens = "prompt_tokens"
+        case completionTokens = "completion_tokens"
+        case totalTokens = "total_tokens"
+    }
+}
+
+public struct RouteDisclosure: Codable, Hashable, Sendable {
+    public let provider: String?
+    public let model: String?
+    public let trust: String?
+    public let retentionPolicy: String?
+
+    enum CodingKeys: String, CodingKey {
+        case provider, model, trust
+        case retentionPolicy = "retention_policy"
+    }
+}
+
+public struct ChatCompletionResponse: Codable, Sendable {
+    public struct Choice: Codable, Sendable {
+        public struct Message: Codable, Sendable {
+            public let role: String
+            public let content: String
+        }
+        public let index: Int
+        public let message: Message
+        public let finishReason: String?
+
+        enum CodingKeys: String, CodingKey {
+            case index, message
+            case finishReason = "finish_reason"
+        }
+    }
+
+    public struct Parameters: Codable, Sendable {
+        public let route: RouteDisclosure?
+        public let retention: String?
+        public let elapsedMilliseconds: Int?
+
+        enum CodingKeys: String, CodingKey {
+            case route, retention
+            case elapsedMilliseconds = "elapsed_ms"
+        }
+    }
+
+    public let id: String
+    public let model: String
+    public let choices: [Choice]
+    public let usage: TokenUsage?
+    public let enigmaParameters: Parameters?
+
+    enum CodingKeys: String, CodingKey {
+        case id, model, choices, usage
+        case enigmaParameters = "enigma_parameters"
+    }
+
+    public var answer: String { choices.first?.message.content ?? "" }
+}
+
+public struct PlatformModel: Identifiable, Codable, Hashable, Sendable {
+    public var id: String { model ?? routeID ?? UUID().uuidString }
+    public let model: String?
+    public let routeID: String?
+    public let provider: String?
+    public let ownedBy: String?
+    public let trust: String?
+    public let retentionPolicy: String?
+    public let capabilities: [String]?
+
+    enum CodingKeys: String, CodingKey {
+        case model, provider, trust, capabilities
+        case routeID = "id"
+        case ownedBy = "owned_by"
+        case retentionPolicy = "retention_policy"
+    }
+}
+
+public struct ModelListResponse: Codable, Sendable {
+    public let data: [PlatformModel]
+}
+
+public struct PlatformResponse: Codable, Sendable {
+    public struct Capabilities: Codable, Sendable {
+        public let chat: Bool
+        public let images: Bool
+        public let videos: Bool
+        public let code: Bool
+        public let browser: Bool
+    }
+    public let capabilities: Capabilities
+}
+
+public struct ImageGenerationRequest: Codable, Sendable {
+    public let prompt: String
+    public let model: String
+    public let width: Int
+    public let height: Int
+    public let variants: Int
+    public let format: String
+
+    public init(prompt: String, model: String, width: Int = 1_024, height: Int = 1_024, variants: Int = 1, format: String = "webp") {
+        self.prompt = prompt
+        self.model = model
+        self.width = width
+        self.height = height
+        self.variants = variants
+        self.format = format
+    }
+}
+
+public struct GeneratedImageAsset: Codable, Hashable, Sendable {
+    public let url: String?
+    public let base64: String?
+    public let format: String
+}
+
+public struct ImageGenerationResponse: Codable, Sendable {
+    public let assets: [GeneratedImageAsset]
+    public let retention: String
+}
+
+public struct CreditsVault: Codable, Sendable {
+    public let id: String
+    public let balanceMicrocredits: Int64
+    public let reservedMicrocredits: Int64
+    public let availableMicrocredits: Int64
+    public let creditScale: Int64
+    public let recoveryVersion: Int
+    public let accountIdentityStored: Bool
+    public let privacyBoundary: String
+    public let paymentFundingBoundary: String?
+
+    public var balance: Decimal { Decimal(balanceMicrocredits) / Decimal(creditScale) }
+    public var available: Decimal { Decimal(availableMicrocredits) / Decimal(creditScale) }
+}
+
+public struct CreditsSessionResponse: Codable, Sendable {
+    public let vault: CreditsVault
+    public let recoveryCode: String
+    public let accessToken: String
+    public let accessExpiresAt: String
+    public let secretsShownOnce: Bool
+}
+
+public struct CreditsStatusResponse: Codable, Sendable {
+    public let vault: CreditsVault
+}
+
+public struct CreditPackage: Identifiable, Codable, Sendable {
+    public let id: String
+    public let label: String
+    public let creditsMicrocredits: Int64
+    public let rails: [String]
+}
+
+public struct CreditPackagesResponse: Codable, Sendable {
+    public let packages: [CreditPackage]
+}
+
+public struct UsageAggregate: Codable, Sendable {
+    public struct Totals: Codable, Sendable {
+        public let eventCount: Int
+        public let inputUnits: Int
+        public let outputUnits: Int
+        public let units: Int
+        public let knownCostMicrousd: Int
+        public let unpricedEvents: Int
+    }
+    public let totals: Totals
+    public let costBoundary: String
+    public let contentStored: Bool
+}
+
+public struct APIErrorEnvelope: Codable, Sendable {
+    public struct Detail: Codable, Sendable {
+        public let code: String?
+        public let message: String?
+    }
+    public let error: Detail
+}
+
+public enum EnigmaAPIError: LocalizedError, Sendable {
+    case invalidBaseURL
+    case unauthenticated
+    case invalidResponse
+    case server(status: Int, code: String?, message: String)
+    case responseTooLarge
+
+    public var errorDescription: String? {
+        switch self {
+        case .invalidBaseURL: return "Enter a valid HTTPS Enigma server URL."
+        case .unauthenticated: return "Connect this device to Enigma first."
+        case .invalidResponse: return "Enigma returned an invalid response."
+        case let .server(_, _, message): return message
+        case .responseTooLarge: return "Enigma returned more data than this screen accepts."
+        }
+    }
+}

package/apps/ios/EnigmaCore/Sources/EnigmaCore/PKCE.swift

@@ -0,0 +1,96 @@
+import Foundation
+
+public struct PKCEPair: Equatable, Sendable {
+    public let verifier: String
+    public let challenge: String
+
+    public init(verifier: String, challenge: String) {
+        self.verifier = verifier
+        self.challenge = challenge
+    }
+}
+
+public enum PKCE {
+    public static func create(byteCount: Int = 48) -> PKCEPair {
+        precondition((32...96).contains(byteCount))
+        var generator = SystemRandomNumberGenerator()
+        let bytes = (0..<byteCount).map { _ in UInt8.random(in: .min ... .max, using: &generator) }
+        let verifier = base64URL(Data(bytes))
+        return PKCEPair(verifier: verifier, challenge: base64URL(Data(SHA256.hash(Array(verifier.utf8)))))
+    }
+
+    public static func challenge(for verifier: String) -> String {
+        base64URL(Data(SHA256.hash(Array(verifier.utf8))))
+    }
+
+    private static func base64URL(_ data: Data) -> String {
+        data.base64EncodedString()
+            .replacingOccurrences(of: "+", with: "-")
+            .replacingOccurrences(of: "/", with: "_")
+            .replacingOccurrences(of: "=", with: "")
+    }
+}
+
+private enum SHA256 {
+    private static let initial: [UInt32] = [
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+        0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+    ]
+    private static let constants: [UInt32] = [
+        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+        0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+        0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+        0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+    ]
+
+    static func hash(_ input: [UInt8]) -> [UInt8] {
+        var message = input
+        let bitLength = UInt64(message.count) * 8
+        message.append(0x80)
+        while message.count % 64 != 56 { message.append(0) }
+        message.append(contentsOf: withUnsafeBytes(of: bitLength.bigEndian, Array.init))
+        var state = initial
+        var words = [UInt32](repeating: 0, count: 64)
+
+        for offset in stride(from: 0, to: message.count, by: 64) {
+            for index in 0..<16 {
+                let start = offset + index * 4
+                words[index] = UInt32(message[start]) << 24
+                    | UInt32(message[start + 1]) << 16
+                    | UInt32(message[start + 2]) << 8
+                    | UInt32(message[start + 3])
+            }
+            for index in 16..<64 {
+                let s0 = rotateRight(words[index - 15], 7) ^ rotateRight(words[index - 15], 18) ^ (words[index - 15] >> 3)
+                let s1 = rotateRight(words[index - 2], 17) ^ rotateRight(words[index - 2], 19) ^ (words[index - 2] >> 10)
+                words[index] = words[index - 16] &+ s0 &+ words[index - 7] &+ s1
+            }
+            var a = state[0], b = state[1], c = state[2], d = state[3]
+            var e = state[4], f = state[5], g = state[6], h = state[7]
+            for index in 0..<64 {
+                let sigma1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25)
+                let choice = (e & f) ^ ((~e) & g)
+                let temp1 = h &+ sigma1 &+ choice &+ constants[index] &+ words[index]
+                let sigma0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22)
+                let majority = (a & b) ^ (a & c) ^ (b & c)
+                let temp2 = sigma0 &+ majority
+                h = g; g = f; f = e; e = d &+ temp1
+                d = c; c = b; b = a; a = temp1 &+ temp2
+            }
+            state[0] &+= a; state[1] &+= b; state[2] &+= c; state[3] &+= d
+            state[4] &+= e; state[5] &+= f; state[6] &+= g; state[7] &+= h
+        }
+        return state.flatMap { word in
+            let value = word.bigEndian
+            return withUnsafeBytes(of: value, Array.init)
+        }
+    }
+
+    private static func rotateRight(_ value: UInt32, _ count: UInt32) -> UInt32 {
+        (value >> count) | (value << (32 - count))
+    }
+}