@sriinnu/runic 1.2.0 → 2.11.1

package/Packages/Silo/Sources/Silo/BrowserCookieMockStore.swift

@@ -1,121 +0,0 @@
-import Foundation
-
-/// In-memory cookie store for tests or ephemeral usage.
-public final class BrowserCookieMockStore {
-    public let store: BrowserCookieStore
-
-    private let lock = NSLock()
-    private var records: [BrowserCookieRecord]
-
-    public init(store: BrowserCookieStore, records: [BrowserCookieRecord] = []) {
-        self.store = store
-        self.records = records
-    }
-
-    public convenience init(
-        browser: Browser = .chrome,
-        profile: BrowserProfile = BrowserProfile(id: "Default", name: "Default"),
-        kind: BrowserCookieStoreKind = .primary,
-        label: String = "Mock",
-        databaseURL: URL? = nil,
-        records: [BrowserCookieRecord] = [])
-    {
-        self.init(
-            store: BrowserCookieStore(
-                browser: browser,
-                profile: profile,
-                kind: kind,
-                label: label,
-                databaseURL: databaseURL),
-            records: records)
-    }
-
-    public func allRecords() -> [BrowserCookieRecord] {
-        lock.lock()
-        defer { lock.unlock() }
-        return records
-    }
-
-    public func records(matching query: BrowserCookieQuery) throws -> [BrowserCookieRecord] {
-        let snapshot = allRecords()
-        return try BrowserCookieClient.apply(query: query, to: snapshot)
-    }
-
-    public func create(_ record: BrowserCookieRecord) throws {
-        lock.lock()
-        defer { lock.unlock() }
-        let key = CookieIdentity(record)
-        if records.contains(where: { CookieIdentity($0) == key }) {
-            throw BrowserCookieClient.MutationError.duplicateCookie(details: key.description)
-        }
-        records.append(record)
-    }
-
-    public func update(_ record: BrowserCookieRecord) throws {
-        lock.lock()
-        defer { lock.unlock() }
-        let key = CookieIdentity(record)
-        guard let index = records.firstIndex(where: { CookieIdentity($0) == key }) else {
-            throw BrowserCookieClient.MutationError.missingCookie(details: key.description)
-        }
-        records[index] = record
-    }
-
-    public func upsert(_ record: BrowserCookieRecord) {
-        lock.lock()
-        defer { lock.unlock() }
-        let key = CookieIdentity(record)
-        if let index = records.firstIndex(where: { CookieIdentity($0) == key }) {
-            records[index] = record
-        } else {
-            records.append(record)
-        }
-    }
-
-    @discardableResult
-    public func delete(_ record: BrowserCookieRecord) -> Bool {
-        lock.lock()
-        defer { lock.unlock() }
-        let key = CookieIdentity(record)
-        guard let index = records.firstIndex(where: { CookieIdentity($0) == key }) else {
-            return false
-        }
-        records.remove(at: index)
-        return true
-    }
-
-    @discardableResult
-    public func delete(matching query: BrowserCookieQuery) throws -> Int {
-        let snapshot = allRecords()
-        let matches = try BrowserCookieClient.apply(query: query, to: snapshot)
-        guard !matches.isEmpty else { return 0 }
-
-        let keys = Set(matches.map(CookieIdentity.init))
-        lock.lock()
-        defer { lock.unlock() }
-        let before = records.count
-        records.removeAll { keys.contains(CookieIdentity($0)) }
-        return before - records.count
-    }
-}
-
-private struct CookieIdentity: Hashable, CustomStringConvertible {
-    let domain: String
-    let name: String
-    let path: String
-    let isHostOnly: Bool
-    let partitionKey: String?
-
-    init(_ record: BrowserCookieRecord) {
-        self.domain = record.domain
-        self.name = record.name
-        self.path = record.path
-        self.isHostOnly = record.isHostOnly
-        self.partitionKey = record.partitionKey
-    }
-
-    var description: String {
-        let partition = partitionKey ?? "<none>"
-        return "domain=\(domain) name=\(name) path=\(path) hostOnly=\(isHostOnly) partition=\(partition)"
-    }
-}

package/Packages/Silo/Sources/Silo/BrowserCookieModels.swift

@@ -1,391 +0,0 @@
-import Foundation
-
-/// Supported browsers for cookie extraction.
-public enum Browser: String, Sendable, Hashable, CaseIterable, Codable {
-    case safari
-    case chrome
-    case chromeBeta
-    case chromeCanary
-    case arc
-    case arcBeta
-    case arcCanary
-    case chatgptAtlas
-    case chromium
-    case firefox
-    case brave
-    case braveBeta
-    case braveNightly
-    case edge
-    case edgeBeta
-    case edgeCanary
-    case helium
-    case vivaldi
-
-    public var displayName: String {
-        switch self {
-        case .safari: "Safari"
-        case .chrome: "Chrome"
-        case .chromeBeta: "Chrome Beta"
-        case .chromeCanary: "Chrome Canary"
-        case .arc: "Arc"
-        case .arcBeta: "Arc Beta"
-        case .arcCanary: "Arc Canary"
-        case .chatgptAtlas: "ChatGPT Atlas"
-        case .chromium: "Chromium"
-        case .firefox: "Firefox"
-        case .brave: "Brave"
-        case .braveBeta: "Brave Beta"
-        case .braveNightly: "Brave Nightly"
-        case .edge: "Microsoft Edge"
-        case .edgeBeta: "Microsoft Edge Beta"
-        case .edgeCanary: "Microsoft Edge Canary"
-        case .helium: "Helium"
-        case .vivaldi: "Vivaldi"
-        }
-    }
-
-    public static let defaultImportOrder: [Browser] = [
-        .safari, .chrome, .edge, .brave, .arc,
-        .chatgptAtlas, .chromium, .helium, .vivaldi, .firefox,
-        .chromeBeta, .chromeCanary, .arcBeta, .arcCanary,
-        .braveBeta, .braveNightly, .edgeBeta, .edgeCanary,
-    ]
-
-    var engine: BrowserEngine {
-        switch self {
-        case .safari: .webkit
-        case .firefox: .firefox
-        default: .chromium
-        }
-    }
-}
-
-enum BrowserEngine: Sendable {
-    case webkit
-    case chromium
-    case firefox
-}
-
-/// Domain matching strategy for cookie queries.
-public enum BrowserCookieDomainMatch: Sendable {
-    case contains
-    case suffix
-    case exact
-}
-
-/// Path matching strategy for cookie queries.
-public enum BrowserCookiePathMatch: Sendable {
-    case contains
-    case prefix
-    case exact
-}
-
-/// SameSite policy values for cookies.
-public enum BrowserCookieSameSite: String, Sendable, Codable {
-    case lax
-    case strict
-    case none
-
-    public var propertyValue: String {
-        switch self {
-        case .lax:
-            return "Lax"
-        case .strict:
-            return "Strict"
-        case .none:
-            return "None"
-        }
-    }
-}
-
-/// Cookie priority values (browser-specific scale).
-public struct BrowserCookiePriority: RawRepresentable, Sendable, Hashable, Codable {
-    public let rawValue: Int
-
-    public init(rawValue: Int) {
-        self.rawValue = rawValue
-    }
-
-    public static let low = BrowserCookiePriority(rawValue: 0)
-    public static let medium = BrowserCookiePriority(rawValue: 1)
-    public static let high = BrowserCookiePriority(rawValue: 2)
-}
-
-/// Behavior when a cookie value fails to decrypt.
-public enum BrowserCookieDecryptionFailurePolicy: Sendable {
-    /// Skip undecryptable cookies unless nothing can be returned.
-    case bestEffort
-    /// Treat any decryption failure as a hard error.
-    case strict
-}
-
-/// Redacts cookie values for safe logging.
-public enum CookieValueRedactor {
-    public static func redact(_ value: String, prefix: Int = 4, suffix: Int = 0) -> String {
-        guard !value.isEmpty else { return "" }
-        let safePrefix = max(0, prefix)
-        let safeSuffix = max(0, suffix)
-        let length = value.count
-        if safePrefix + safeSuffix >= length {
-            return String(repeating: "*", count: length)
-        }
-
-        let startIndex = value.startIndex
-        let prefixEnd = value.index(startIndex, offsetBy: safePrefix)
-        let suffixStart = value.index(value.endIndex, offsetBy: -safeSuffix)
-        let prefixValue = String(value[startIndex..<prefixEnd])
-        let suffixValue = safeSuffix > 0 ? String(value[suffixStart..<value.endIndex]) : ""
-        return "\(prefixValue)...\(suffixValue)"
-    }
-}
-
-/// Maps a cookie domain to an origin URL when building HTTPCookie values.
-public enum BrowserCookieOriginStrategy: Sendable {
-    case domainBased
-    case fixed(URL)
-    case custom(@Sendable (String) -> URL?)
-
-    func resolve(domain: String) -> URL? {
-        switch self {
-        case .domainBased:
-            URL(string: "https://\(domain)")
-        case let .fixed(url):
-            url
-        case let .custom(resolver):
-            resolver(domain)
-        }
-    }
-}
-
-/// Query definition for fetching browser cookies.
-public struct BrowserCookieQuery: Sendable {
-    public let domains: [String]
-    public let domainMatch: BrowserCookieDomainMatch
-    public let domainPattern: String?
-    public let pathPattern: String?
-    public let useRegex: Bool
-    public let paths: [String]
-    public let pathMatch: BrowserCookiePathMatch
-    public let secureOnly: Bool?
-    public let httpOnlyOnly: Bool?
-    public let excludeSession: Bool
-    public let minExpiryDate: Date?
-    public let maxExpiryDate: Date?
-    public let sameSite: BrowserCookieSameSite?
-    public let origin: BrowserCookieOriginStrategy
-    public let includeExpired: Bool
-    public let referenceDate: Date
-
-    public init(
-        domains: [String] = [],
-        domainMatch: BrowserCookieDomainMatch = .contains,
-        domainPattern: String? = nil,
-        pathPattern: String? = nil,
-        useRegex: Bool = false,
-        paths: [String] = [],
-        pathMatch: BrowserCookiePathMatch = .contains,
-        secureOnly: Bool? = nil,
-        httpOnlyOnly: Bool? = nil,
-        excludeSession: Bool = false,
-        minExpiryDate: Date? = nil,
-        maxExpiryDate: Date? = nil,
-        sameSite: BrowserCookieSameSite? = nil,
-        origin: BrowserCookieOriginStrategy = .domainBased,
-        includeExpired: Bool = false,
-        referenceDate: Date = Date())
-    {
-        self.domains = domains
-        self.domainMatch = domainMatch
-        self.domainPattern = domainPattern
-        self.pathPattern = pathPattern
-        self.useRegex = useRegex
-        self.paths = paths
-        self.pathMatch = pathMatch
-        self.secureOnly = secureOnly
-        self.httpOnlyOnly = httpOnlyOnly
-        self.excludeSession = excludeSession
-        self.minExpiryDate = minExpiryDate
-        self.maxExpiryDate = maxExpiryDate
-        self.sameSite = sameSite
-        self.origin = origin
-        self.includeExpired = includeExpired
-        self.referenceDate = referenceDate
-    }
-}
-
-/// A browser profile identifier.
-public struct BrowserProfile: Sendable, Hashable {
-    public let id: String
-    public let name: String
-
-    public init(id: String, name: String) {
-        self.id = id
-        self.name = name
-    }
-}
-
-/// Which cookie store a browser profile represents.
-public enum BrowserCookieStoreKind: String, Sendable, Codable {
-    case primary
-    case network
-    case safari
-}
-
-/// A concrete cookie store for a browser profile.
-public struct BrowserCookieStore: Sendable, Hashable {
-    public let browser: Browser
-    public let profile: BrowserProfile
-    public let kind: BrowserCookieStoreKind
-    public let label: String
-    public let databaseURL: URL?
-
-    public init(
-        browser: Browser,
-        profile: BrowserProfile,
-        kind: BrowserCookieStoreKind,
-        label: String,
-        databaseURL: URL?)
-    {
-        self.browser = browser
-        self.profile = profile
-        self.kind = kind
-        self.label = label
-        self.databaseURL = databaseURL
-    }
-}
-
-/// A browser cookie record normalized for cross-browser handling.
-public struct BrowserCookieRecord: Sendable {
-    public let domain: String
-    public let isHostOnly: Bool
-    public let name: String
-    public let path: String
-    public let value: String
-    public let expires: Date?
-    public let createdAt: Date?
-    public let lastAccessedAt: Date?
-    public let isSecure: Bool
-    public let isHTTPOnly: Bool
-    public let sameSite: BrowserCookieSameSite?
-    public let priority: BrowserCookiePriority?
-    public let partitionKey: String?
-    public let isSameParty: Bool?
-
-    public var isDomainCookie: Bool { !self.isHostOnly }
-    public var isSession: Bool { self.expires == nil }
-    public var redactedValue: String { CookieValueRedactor.redact(self.value) }
-
-    public func redactedValue(prefix: Int = 4, suffix: Int = 0) -> String {
-        CookieValueRedactor.redact(self.value, prefix: prefix, suffix: suffix)
-    }
-
-    public init(
-        domain: String,
-        name: String,
-        path: String,
-        value: String,
-        expires: Date?,
-        createdAt: Date? = nil,
-        lastAccessedAt: Date? = nil,
-        isSecure: Bool,
-        isHTTPOnly: Bool,
-        isHostOnly: Bool? = nil,
-        sameSite: BrowserCookieSameSite? = nil,
-        priority: BrowserCookiePriority? = nil,
-        partitionKey: String? = nil,
-        isSameParty: Bool? = nil)
-    {
-        let (normalizedDomain, hostOnly) = Self.parseDomain(domain, isHostOnly: isHostOnly)
-        self.domain = normalizedDomain
-        self.isHostOnly = hostOnly
-        self.name = name
-        self.path = path
-        self.value = value
-        self.expires = expires
-        self.createdAt = createdAt
-        self.lastAccessedAt = lastAccessedAt
-        self.isSecure = isSecure
-        self.isHTTPOnly = isHTTPOnly
-        self.sameSite = sameSite
-        self.priority = priority
-        self.partitionKey = partitionKey
-        self.isSameParty = isSameParty
-    }
-
-    private static func parseDomain(_ raw: String, isHostOnly: Bool?) -> (String, Bool) {
-        let trimmed = raw.trimmingCharacters(in: .whitespacesAndNewlines)
-        let normalized = trimmed.hasPrefix(".") ? String(trimmed.dropFirst()) : trimmed
-        if let isHostOnly {
-            return (normalized, isHostOnly)
-        }
-        return (normalized, !trimmed.hasPrefix("."))
-    }
-}
-
-/// Cookie records loaded from a specific browser store.
-public struct BrowserCookieStoreRecords: Sendable {
-    public let store: BrowserCookieStore
-    public let records: [BrowserCookieRecord]
-
-    public init(store: BrowserCookieStore, records: [BrowserCookieRecord]) {
-        self.store = store
-        self.records = records
-    }
-
-    public var label: String { self.store.label }
-    public var browser: Browser { self.store.browser }
-
-    public func cookies(origin: BrowserCookieOriginStrategy = .domainBased) -> [HTTPCookie] {
-        BrowserCookieClient.makeHTTPCookies(self.records, origin: origin)
-    }
-}
-
-/// Errors raised when reading browser cookies.
-public enum BrowserCookieError: LocalizedError, Sendable {
-    case notFound(browser: Browser, details: String)
-    case accessDenied(browser: Browser, details: String)
-    case loadFailed(browser: Browser, details: String)
-
-    public var errorDescription: String? {
-        switch self {
-        case let .notFound(browser, details):
-            "\(browser.displayName) cookies not found: \(details)"
-        case let .accessDenied(browser, details):
-            "\(browser.displayName) access denied: \(details)"
-        case let .loadFailed(browser, details):
-            "\(browser.displayName) load failed: \(details)"
-        }
-    }
-
-    public var accessDeniedHint: String {
-        switch self {
-        case .accessDenied:
-            #if os(macOS)
-            return "Enable Full Disk Access in System Settings → Privacy & Security"
-            #elseif os(Linux)
-            return "Check file permissions for browser profile directories"
-            #elseif os(Windows)
-            return "Check DPAPI access and user profile permissions"
-            #else
-            return "Check permissions for cookie storage"
-            #endif
-        default:
-            return ""
-        }
-    }
-}
-
-/// Errors raised when building or applying cookie queries.
-public enum BrowserCookieQueryError: LocalizedError, Sendable {
-    case invalidDomainPattern(String)
-    case invalidPathPattern(String)
-
-    public var errorDescription: String? {
-        switch self {
-        case let .invalidDomainPattern(pattern):
-            "Invalid domain regex pattern: \(pattern)"
-        case let .invalidPathPattern(pattern):
-            "Invalid path regex pattern: \(pattern)"
-        }
-    }
-}