enigma-memory 0.1.18 → 0.1.22

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

@@ -0,0 +1,187 @@
+import Foundation
+
+public enum PrivacyMode: String, Codable, Sendable, CaseIterable {
+    case off, smart, full
+}
+
+public enum PrivacyCategory: String, Codable, Sendable, CaseIterable {
+    case email, phone, ipv4, paymentCard, apiKey, privateKey, evmWallet, solanaWallet
+    case person, location, address, organization, medical, legalMatter, account
+}
+
+public struct SemanticPrivacyFinding: Hashable, Sendable {
+    public let range: Range<String.Index>
+    public let category: PrivacyCategory
+
+    public init(range: Range<String.Index>, category: PrivacyCategory) {
+        self.range = range
+        self.category = category
+    }
+}
+
+public protocol SemanticPrivacyTagging: Sendable {
+    func findings(in text: String) -> [SemanticPrivacyFinding]
+}
+
+public struct HeuristicSemanticPrivacyTagger: SemanticPrivacyTagging {
+    public init() {}
+
+    public func findings(in text: String) -> [SemanticPrivacyFinding] {
+        let rules: [(String, PrivacyCategory)] = [
+            (#"(?i)\b(?:my name is|i am|i'm)\s+([A-Z][\p{L}'-]+(?:\s+[A-Z][\p{L}'-]+){0,2})"#, .person),
+            (#"(?i)\b(?:i live in|i am based in|my address is)\s+([^,.!?\n]{2,80})"#, .location),
+            (#"(?i)\b(?:my employer is|i work (?:at|for))\s+([^,.!?\n]{2,80})"#, .organization),
+            (#"(?i)\b(?:my diagnosis is|i was diagnosed with)\s+([^,.!?\n]{2,80})"#, .medical),
+            (#"(?i)\b(?:my case number is|my lawyer is)\s+([^,.!?\n]{2,80})"#, .legalMatter),
+            (#"(?i)\b(?:my account number is|account id is)\s+([A-Za-z0-9_-]{4,80})"#, .account),
+        ]
+        var output: [SemanticPrivacyFinding] = []
+        let full = NSRange(text.startIndex..<text.endIndex, in: text)
+        for (pattern, category) in rules {
+            guard let regex = try? NSRegularExpression(pattern: pattern) else { continue }
+            for match in regex.matches(in: text, range: full) {
+                let target = match.numberOfRanges > 1 ? match.range(at: 1) : match.range
+                if let range = Range(target, in: text) { output.append(.init(range: range, category: category)) }
+            }
+        }
+        return output
+    }
+}
+
+public struct PrivacyReceipt: Codable, Sendable {
+    public struct Summary: Codable, Hashable, Sendable {
+        public let category: PrivacyCategory
+        public let action: String
+        public let count: Int
+    }
+
+    public let schema: String
+    public let mode: PrivacyMode
+    public let safeForExternal: Bool
+    public let inputCharacters: Int
+    public let outputCharacters: Int
+    public let summary: [Summary]
+    public let receiptReference: UUID
+
+    public init(mode: PrivacyMode, safeForExternal: Bool, inputCharacters: Int, outputCharacters: Int, summary: [Summary], receiptReference: UUID = UUID()) {
+        self.schema = "enigma.ios_privacy_receipt.v1"
+        self.mode = mode
+        self.safeForExternal = safeForExternal
+        self.inputCharacters = inputCharacters
+        self.outputCharacters = outputCharacters
+        self.summary = summary
+        self.receiptReference = receiptReference
+    }
+}
+
+public final class PrivacySession: @unchecked Sendable {
+    public let messages: [EnigmaMessage]
+    public let receipt: PrivacyReceipt
+    private let lock = NSLock()
+    private var replacements: [String: String]
+
+    init(messages: [EnigmaMessage], receipt: PrivacyReceipt, replacements: [String: String]) {
+        self.messages = messages
+        self.receipt = receipt
+        self.replacements = replacements
+    }
+
+    public func restore(_ value: String) -> String {
+        lock.lock()
+        let current = replacements
+        lock.unlock()
+        return current.reduce(value) { output, replacement in output.replacingOccurrences(of: replacement.key, with: replacement.value) }
+    }
+
+    public func dispose() {
+        lock.lock()
+        replacements.removeAll(keepingCapacity: false)
+        lock.unlock()
+    }
+
+    deinit { dispose() }
+}
+
+public struct PrivacyMinimizer: Sendable {
+    private struct Rule: Sendable {
+        let pattern: String
+        let category: PrivacyCategory
+        let validator: @Sendable (String) -> Bool
+    }
+
+    private let rules: [Rule] = [
+        .init(pattern: #"(?i)\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b"#, category: .email, validator: { _ in true }),
+        .init(pattern: #"\b(?:\+?\d[\d .()-]{7,}\d)\b"#, category: .phone, validator: { value in value.filter(\.isNumber).count >= 8 }),
+        .init(pattern: #"\b(?:\d{1,3}\.){3}\d{1,3}\b"#, category: .ipv4, validator: { value in value.split(separator: ".").allSatisfy { (0...255).contains(Int($0) ?? -1) } }),
+        .init(pattern: #"\b(?:\d[ -]*?){13,19}\b"#, category: .paymentCard, validator: Self.luhn),
+        .init(pattern: #"(?i)\b(?:sk|pk|api|token|key)[_-](?:live|test)?[_-]?[A-Za-z0-9]{16,}\b"#, category: .apiKey, validator: { _ in true }),
+        .init(pattern: #"-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----"#, category: .privateKey, validator: { _ in true }),
+        .init(pattern: #"\b0x[a-fA-F0-9]{40}\b"#, category: .evmWallet, validator: { _ in true }),
+        .init(pattern: #"\b[1-9A-HJ-NP-Za-km-z]{32,44}\b"#, category: .solanaWallet, validator: { _ in true }),
+    ]
+    private let semanticTagger: any SemanticPrivacyTagging
+
+    public init(semanticTagger: any SemanticPrivacyTagging = HeuristicSemanticPrivacyTagger()) {
+        self.semanticTagger = semanticTagger
+    }
+
+    public func minimize(_ messages: [EnigmaMessage], mode: PrivacyMode) -> PrivacySession {
+        guard mode != .off else {
+            let count = messages.reduce(0) { $0 + $1.content.count }
+            return PrivacySession(messages: messages, receipt: .init(mode: mode, safeForExternal: true, inputCharacters: count, outputCharacters: count, summary: []), replacements: [:])
+        }
+        var replacements: [String: String] = [:]
+        var counts: [PrivacyCategory: Int] = [:]
+        let inputCharacters = messages.reduce(0) { $0 + $1.content.count }
+        let minimized = messages.map { message -> EnigmaMessage in
+            guard message.role == .user || message.role == .system else { return message }
+            if mode == .full {
+                counts[.account, default: 0] += 1
+                return EnigmaMessage(id: message.id, role: message.role, content: "[PRIVATE_INPUT_WITHHELD]", createdAt: message.createdAt)
+            }
+            var text = message.content
+            var candidates: [(Range<String.Index>, PrivacyCategory)] = []
+            for rule in rules {
+                guard let regex = try? NSRegularExpression(pattern: rule.pattern) else { continue }
+                let full = NSRange(text.startIndex..<text.endIndex, in: text)
+                for match in regex.matches(in: text, range: full) {
+                    guard let range = Range(match.range, in: text), rule.validator(String(text[range])) else { continue }
+                    candidates.append((range, rule.category))
+                }
+            }
+            candidates.append(contentsOf: semanticTagger.findings(in: text).map { ($0.range, $0.category) })
+            let nonOverlapping = candidates.sorted { $0.0.lowerBound > $1.0.lowerBound }.reduce(into: [(Range<String.Index>, PrivacyCategory)]()) { accepted, candidate in
+                if !accepted.contains(where: { $0.0.overlaps(candidate.0) }) { accepted.append(candidate) }
+            }
+            for (range, category) in nonOverlapping {
+                let raw = String(text[range])
+                let token = "⟪ENIGMA_\(category.rawValue.uppercased())_\(UUID().uuidString)⟫"
+                text.replaceSubrange(range, with: token)
+                replacements[token] = raw
+                counts[category, default: 0] += 1
+            }
+            return EnigmaMessage(id: message.id, role: message.role, content: text, createdAt: message.createdAt)
+        }
+        let outputCharacters = minimized.reduce(0) { $0 + $1.content.count }
+        let summary = counts.keys.sorted { $0.rawValue < $1.rawValue }.map {
+            PrivacyReceipt.Summary(category: $0, action: mode == .full ? "withheld" : "masked", count: counts[$0] ?? 0)
+        }
+        return PrivacySession(
+            messages: minimized,
+            receipt: .init(mode: mode, safeForExternal: mode == .full || !summary.isEmpty, inputCharacters: inputCharacters, outputCharacters: outputCharacters, summary: summary),
+            replacements: replacements
+        )
+    }
+
+    private static func luhn(_ value: String) -> Bool {
+        let digits = value.compactMap(\.wholeNumberValue)
+        guard (13...19).contains(digits.count) else { return false }
+        let sum = digits.reversed().enumerated().reduce(0) { partial, element in
+            let (index, digit) = element
+            if index.isMultiple(of: 2) { return partial + digit }
+            let doubled = digit * 2
+            return partial + (doubled > 9 ? doubled - 9 : doubled)
+        }
+        return sum.isMultiple(of: 10)
+    }
+}

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

@@ -0,0 +1,129 @@
+import Foundation
+
+public struct VideoQueueRequest: Codable, Sendable {
+    public let prompt: String
+    public let model: String
+    public let duration: Int
+    public let resolution: String
+    public let aspectRatio: String
+
+    public init(prompt: String, model: String, duration: Int = 5, resolution: String = "720p", aspectRatio: String = "16:9") {
+        self.prompt = prompt
+        self.model = model
+        self.duration = duration
+        self.resolution = resolution
+        self.aspectRatio = aspectRatio
+    }
+
+    enum CodingKeys: String, CodingKey {
+        case prompt, model, duration, resolution
+        case aspectRatio = "aspect_ratio"
+    }
+}
+
+public struct VideoJob: Codable, Sendable {
+    public let id: String
+    public let model: String
+    public let provider: String
+    public let status: String
+    public let progress: Double
+    public let error: String?
+}
+
+public struct VideoAsset: Codable, Sendable {
+    public let url: String?
+    public let base64: String?
+    public let mimeType: String?
+
+    enum CodingKeys: String, CodingKey {
+        case url, base64
+        case mimeType = "mimeType"
+    }
+}
+
+public struct VideoRetrieveResponse: Decodable, Sendable {
+    public let job: VideoJob
+    public let asset: VideoAsset?
+
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: DynamicCodingKey.self)
+        if container.contains(DynamicCodingKey("job")) {
+            job = try container.decode(VideoJob.self, forKey: DynamicCodingKey("job"))
+            asset = try container.decodeIfPresent(VideoAsset.self, forKey: DynamicCodingKey("asset"))
+        } else {
+            job = try VideoJob(from: decoder)
+            asset = nil
+        }
+    }
+}
+
+public struct CodeSession: Codable, Sendable {
+    public let id: String
+    public let provider: String
+    public let status: String
+    public let language: String
+    public let network: String
+}
+
+public struct CodeSessionEnvelope: Codable, Sendable { public let session: CodeSession }
+public struct CodeUploadRequest: Codable, Sendable {
+    public let path: String
+    public let data: String
+    public let encoding: String
+    public init(path: String = "main.js", data: String, encoding: String = "utf8") {
+        self.path = path; self.data = data; self.encoding = encoding
+    }
+}
+public struct CodeExecuteRequest: Codable, Sendable {
+    public let entry: String
+    public init(entry: String = "main.js") { self.entry = entry }
+}
+public struct CodeExecutionResponse: Codable, Sendable {
+    public let ok: Bool
+    public let code: Int?
+    public let signal: String?
+    public let timedOut: Bool?
+    public let session: CodeSession
+}
+public struct CodeEventData: Codable, Sendable {
+    public let stream: String?
+    public let data: String?
+    public let message: String?
+}
+public struct CodeEvent: Codable, Identifiable, Sendable {
+    public var id: Int { cursor }
+    public let cursor: Int
+    public let type: String
+    public let data: CodeEventData?
+}
+public struct CodeEventsResponse: Codable, Sendable {
+    public let session: CodeSession
+    public let events: [CodeEvent]
+}
+
+public struct BrowserPrivacy: Codable, Sendable {
+    public let ephemeralProfile: Bool
+    public let privateNetworkBlocked: Bool
+    public let egressLayer: String?
+    public let egressPolicyHash: String?
+}
+public struct BrowserSession: Codable, Sendable {
+    public let id: String
+    public let provider: String
+    public let state: String
+    public let streamUrl: String?
+    public let privacy: BrowserPrivacy
+}
+public struct BrowserSessionEnvelope: Codable, Sendable { public let session: BrowserSession }
+public struct BrowserNavigateRequest: Codable, Sendable {
+    public let url: String
+    public init(url: String) { self.url = url }
+}
+
+private struct DynamicCodingKey: CodingKey {
+    let stringValue: String
+    let intValue: Int? = nil
+    init(_ value: String) { stringValue = value }
+    init?(stringValue: String) { self.stringValue = stringValue }
+    init?(intValue: Int) { return nil }
+}

package/apps/ios/EnigmaCore/Tests/EnigmaCoreTests/EnigmaCoreTests.swift

@@ -0,0 +1,42 @@
+import Foundation
+import Testing
+@testable import EnigmaCore
+
+@Test func pkceMatchesRFC7636Vector() {
+    let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk"
+    #expect(PKCE.challenge(for: verifier) == "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM")
+}
+@Test func iosOAuthScopeContractCoversEveryMobileSurface() {
+    #expect(Set(EnigmaOAuthScopes.iOSPlatform) == Set([
+        "models:invoke",
+        "images:generate",
+        "video:generate",
+        "code:execute",
+        "browser:control",
+        "usage:read",
+        "credits:create",
+        "offline_access",
+    ]))
+}
+
+
+@Test func smartPrivacyMasksRestoresAndKeepsReceiptContentFree() throws {
+    let canary = "Alice Smith"
+    let messages = [EnigmaMessage(role: .user, content: "My name is \(canary), email alice@example.com, and I live in Paris.")]
+    let session = PrivacyMinimizer().minimize(messages, mode: .smart)
+    #expect(!session.messages[0].content.contains(canary))
+    #expect(!session.messages[0].content.contains("alice@example.com"))
+    #expect(session.restore(session.messages[0].content).contains(canary))
+    let receipt = try JSONEncoder().encode(session.receipt)
+    let serialized = String(decoding: receipt, as: UTF8.self)
+    #expect(!serialized.contains(canary))
+    #expect(!serialized.contains("alice@example.com"))
+    session.dispose()
+    #expect(!session.restore(session.messages[0].content).contains(canary))
+}
+
+@Test func fullPrivacyWithholdsUserInput() {
+    let session = PrivacyMinimizer().minimize([EnigmaMessage(role: .user, content: "private prose")], mode: .full)
+    #expect(session.messages[0].content == "[PRIVATE_INPUT_WITHHELD]")
+    #expect(session.receipt.mode == .full)
+}