import Foundation#if os(macOS)import SweetCookieKit#endif #if os(macOS)enum MiniMaxLocalStorageImporter {    struct TokenInfo {        let accessToken: String        let groupID: String?        let sourceLabel: String    }     static func importAccessTokens(        browserDetection: BrowserDetection,        logger: ((String) -> Void)? = nil) -> [TokenInfo]    {        let log: (String) -> Void = { msg in logger?("[minimax-storage] \(msg)") }        var tokens: [TokenInfo] = []         let chromeCandidates = self.chromeLocalStorageCandidates(browserDetection: browserDetection)        if !chromeCandidates.isEmpty {            log("Chrome local storage candidates: \(chromeCandidates.count)")        }         for candidate in chromeCandidates {            guard case let .chromeLevelDB(levelDBURL) = candidate.kind else { continue }            let snapshot = self.readLocalStorage(from: levelDBURL, logger: log)            if !snapshot.tokens.isEmpty {                let groupID = snapshot.groupID ?? self.groupID(fromJWT: snapshot.tokens.first ?? "")                if groupID != nil {                    log("Found MiniMax group id in \(candidate.label)")                }                for token in snapshot.tokens {                    let hint = token.contains(".") ? "jwt" : "opaque"                    log("Found MiniMax access token in \(candidate.label): \(token.count) chars (\(hint))")                    tokens.append(TokenInfo(accessToken: token, groupID: groupID, sourceLabel: candidate.label))                }            }        }         if tokens.isEmpty {            let sessionCandidates = self.chromeSessionStorageCandidates(browserDetection: browserDetection)            if !sessionCandidates.isEmpty {                log("Chrome session storage candidates: \(sessionCandidates.count)")            }            for candidate in sessionCandidates {                let sessionTokens = self.readSessionStorageTokens(from: candidate.url, logger: log)                guard !sessionTokens.isEmpty else { continue }                for token in sessionTokens {                    let hint = token.contains(".") ? "jwt" : "opaque"                    log("Found MiniMax access token in \(candidate.label): \(token.count) chars (\(hint))")                    let groupID = self.groupID(fromJWT: token)                    tokens.append(TokenInfo(accessToken: token, groupID: groupID, sourceLabel: candidate.label))                }            }        }         if tokens.isEmpty {            let indexedCandidates = self.chromeIndexedDBCandidates(browserDetection: browserDetection)            if !indexedCandidates.isEmpty {                log("Chrome IndexedDB candidates: \(indexedCandidates.count)")            }            for candidate in indexedCandidates {                let indexedTokens = self.readIndexedDBTokens(from: candidate.url, logger: log)                guard !indexedTokens.isEmpty else { continue }                for token in indexedTokens {                    let hint = token.contains(".") ? "jwt" : "opaque"                    log("Found MiniMax access token in \(candidate.label): \(token.count) chars (\(hint))")                    let groupID = self.groupID(fromJWT: token)                    tokens.append(TokenInfo(accessToken: token, groupID: groupID, sourceLabel: candidate.label))                }            }        }         if tokens.isEmpty {            log("No MiniMax access token found in browser storage")        }         return tokens    }     static func importGroupIDs(        browserDetection: BrowserDetection,        logger: ((String) -> Void)? = nil) -> [String: String]    {        let log: (String) -> Void = { msg in logger?("[minimax-storage] \(msg)") }        var results: [String: String] = [:]         let chromeCandidates = self.chromeLocalStorageCandidates(browserDetection: browserDetection)        if !chromeCandidates.isEmpty {            log("Chrome local storage candidates: \(chromeCandidates.count)")        }         for candidate in chromeCandidates {            guard case let .chromeLevelDB(levelDBURL) = candidate.kind else { continue }            let snapshot = self.readLocalStorage(from: levelDBURL, logger: log)            if let groupID = snapshot.groupID, results[candidate.label] == nil {                log("Found MiniMax group id in \(candidate.label)")                results[candidate.label] = groupID            }        }         return results    }     // MARK: - Chrome local storage discovery     private enum LocalStorageSourceKind {        case chromeLevelDB(URL)    }     private struct LocalStorageCandidate {        let label: String        let kind: LocalStorageSourceKind    }     private struct SessionStorageCandidate {        let label: String        let url: URL    }     private struct IndexedDBCandidate {        let label: String        let url: URL    }     private static func chromeLocalStorageCandidates(browserDetection: BrowserDetection) -> [LocalStorageCandidate] {        let browsers: [Browser] = [            .chrome,            .chromeBeta,            .chromeCanary,            .edge,            .edgeBeta,            .edgeCanary,            .brave,            .braveBeta,            .braveNightly,            .vivaldi,            .arc,            .arcBeta,            .arcCanary,            .dia,            .chatgptAtlas,            .chromium,            .helium,        ]         // Filter to browsers with profile data to avoid unnecessary filesystem access        let installedBrowsers = browsers.browsersWithProfileData(using: browserDetection)         let roots = ChromiumProfileLocator            .roots(for: installedBrowsers, homeDirectories: BrowserCookieClient.defaultHomeDirectories())            .map { (url: $0.url, labelPrefix: $0.labelPrefix) }         var candidates: [LocalStorageCandidate] = []        for root in roots {            candidates.append(contentsOf: self.chromeProfileLocalStorageDirs(                root: root.url,                labelPrefix: root.labelPrefix))        }        return candidates    }     private static func chromeProfileLocalStorageDirs(root: URL, labelPrefix: String) -> [LocalStorageCandidate] {        guard let entries = try? FileManager.default.contentsOfDirectory(            at: root,            includingPropertiesForKeys: [.isDirectoryKey],            options: [.skipsHiddenFiles])        else { return [] }         let profileDirs = entries.filter { url in            guard let isDir = (try? url.resourceValues(forKeys: [.isDirectoryKey]).isDirectory), isDir else {                return false            }            let name = url.lastPathComponent            return name == "Default" || name.hasPrefix("Profile ") || name.hasPrefix("user-")        }        .sorted { $0.lastPathComponent < $1.lastPathComponent }         return profileDirs.compactMap { dir in            let levelDBURL = dir.appendingPathComponent("Local Storage").appendingPathComponent("leveldb")            guard FileManager.default.fileExists(atPath: levelDBURL.path) else { return nil }            let label = "\(labelPrefix) \(dir.lastPathComponent)"            return LocalStorageCandidate(label: label, kind: .chromeLevelDB(levelDBURL))        }    }     private static func chromeSessionStorageCandidates(browserDetection: BrowserDetection)    -> [SessionStorageCandidate] {        let browsers: [Browser] = [            .chrome,            .chromeBeta,            .chromeCanary,            .edge,            .edgeBeta,            .edgeCanary,            .brave,            .braveBeta,            .braveNightly,            .vivaldi,            .arc,            .arcBeta,            .arcCanary,            .dia,            .chatgptAtlas,            .chromium,            .helium,        ]         // Filter to browsers with profile data to avoid unnecessary filesystem access        let installedBrowsers = browsers.browsersWithProfileData(using: browserDetection)         let roots = ChromiumProfileLocator            .roots(for: installedBrowsers, homeDirectories: BrowserCookieClient.defaultHomeDirectories())            .map { (url: $0.url, labelPrefix: $0.labelPrefix) }         var candidates: [SessionStorageCandidate] = []        for root in roots {            candidates.append(contentsOf: self.chromeProfileSessionStorageDirs(                root: root.url,                labelPrefix: root.labelPrefix))        }        return candidates    }     private static func chromeProfileSessionStorageDirs(root: URL, labelPrefix: String) -> [SessionStorageCandidate] {        guard let entries = try? FileManager.default.contentsOfDirectory(            at: root,            includingPropertiesForKeys: [.isDirectoryKey],            options: [.skipsHiddenFiles])        else { return [] }         let profileDirs = entries.filter { url in            guard let isDir = (try? url.resourceValues(forKeys: [.isDirectoryKey]).isDirectory), isDir else {                return false            }            let name = url.lastPathComponent            return name == "Default" || name.hasPrefix("Profile ") || name.hasPrefix("user-")        }        .sorted { $0.lastPathComponent < $1.lastPathComponent }         return profileDirs.compactMap { dir in            let sessionURL = dir.appendingPathComponent("Session Storage")            guard FileManager.default.fileExists(atPath: sessionURL.path) else { return nil }            let label = "\(labelPrefix) \(dir.lastPathComponent) (Session Storage)"            return SessionStorageCandidate(label: label, url: sessionURL)        }    }     private static func chromeIndexedDBCandidates(browserDetection: BrowserDetection) -> [IndexedDBCandidate] {        let browsers: [Browser] = [            .chrome,            .chromeBeta,            .chromeCanary,            .edge,            .edgeBeta,            .edgeCanary,            .brave,            .braveBeta,            .braveNightly,            .vivaldi,            .arc,            .arcBeta,            .arcCanary,            .dia,            .chatgptAtlas,            .chromium,            .helium,        ]         // Filter to browsers with profile data to avoid unnecessary filesystem access        let installedBrowsers = browsers.browsersWithProfileData(using: browserDetection)         let roots = ChromiumProfileLocator            .roots(for: installedBrowsers, homeDirectories: BrowserCookieClient.defaultHomeDirectories())            .map { (url: $0.url, labelPrefix: $0.labelPrefix) }         var candidates: [IndexedDBCandidate] = []        for root in roots {            candidates.append(contentsOf: self.chromeProfileIndexedDBDirs(                root: root.url,                labelPrefix: root.labelPrefix))        }        return candidates    }     private static func chromeProfileIndexedDBDirs(root: URL, labelPrefix: String) -> [IndexedDBCandidate] {        guard let entries = try? FileManager.default.contentsOfDirectory(            at: root,            includingPropertiesForKeys: [.isDirectoryKey],            options: [.skipsHiddenFiles])        else { return [] }         let profileDirs = entries.filter { url in            guard let isDir = (try? url.resourceValues(forKeys: [.isDirectoryKey]).isDirectory), isDir else {                return false            }            let name = url.lastPathComponent            return name == "Default" || name.hasPrefix("Profile ") || name.hasPrefix("user-")        }        .sorted { $0.lastPathComponent < $1.lastPathComponent }         let targetPrefixes = [            "https_platform.minimax.io_",            "https_www.minimax.io_",            "https_minimax.io_",            "https_platform.minimaxi.com_",            "https_minimaxi.com_",            "https_www.minimaxi.com_",        ]         var candidates: [IndexedDBCandidate] = []        for dir in profileDirs {            let indexedDBRoot = dir.appendingPathComponent("IndexedDB")            guard let dbEntries = try? FileManager.default.contentsOfDirectory(                at: indexedDBRoot,                includingPropertiesForKeys: [.isDirectoryKey],                options: [.skipsHiddenFiles])            else { continue }            for entry in dbEntries {                guard let isDir = (try? entry.resourceValues(forKeys: [.isDirectoryKey]).isDirectory), isDir else {                    continue                }                let name = entry.lastPathComponent                guard targetPrefixes.contains(where: { name.hasPrefix($0) }),                      name.hasSuffix(".indexeddb.leveldb")                else { continue }                let label = "\(labelPrefix) \(dir.lastPathComponent) (IndexedDB)"                candidates.append(IndexedDBCandidate(label: label, url: entry))            }        }        return candidates    }     // MARK: - Token extraction     private struct LocalStorageSnapshot {        let tokens: [String]        let groupID: String?    }     private static func readLocalStorage(        from levelDBURL: URL,        logger: ((String) -> Void)? = nil) -> LocalStorageSnapshot    {        let origins = [            "https://platform.minimax.io",            "https://www.minimax.io",            "https://minimax.io",            "https://platform.minimaxi.com",            "https://www.minimaxi.com",            "https://minimaxi.com",        ]        var entries: [SweetCookieKit.ChromiumLocalStorageEntry] = []        for origin in origins {            entries.append(contentsOf: SweetCookieKit.ChromiumLocalStorageReader.readEntries(                for: origin,                in: levelDBURL,                logger: logger))        }         var tokens: [String] = []        var seen = Set<String>()        var groupID: String?        var hasMinimaxSignal = !entries.isEmpty         for entry in entries {            let extracted = self.extractAccessTokens(from: entry.value)            for token in extracted where !seen.contains(token) {                seen.insert(token)                tokens.append(token)            }            if groupID == nil, let match = self.extractGroupID(from: entry.value) {                groupID = match            }        }         if tokens.isEmpty {            let textEntries = SweetCookieKit.ChromiumLocalStorageReader.readTextEntries(                in: levelDBURL,                logger: logger)            let candidateEntries = textEntries.filter { entry in                let key = entry.key.lowercased()                let value = entry.value.lowercased()                return key.contains("minimax.io") || value.contains("minimax.io") ||                    key.contains("minimaxi.com") || value.contains("minimaxi.com")            }            if !candidateEntries.isEmpty {                logger?("[minimax-storage] Local storage text entries: \(candidateEntries.count)")                hasMinimaxSignal = true            }            for entry in candidateEntries {                let extracted = self.extractAccessTokens(from: entry.value)                for token in extracted where !seen.contains(token) {                    if token.contains("."), !self.isMiniMaxJWT(token) {                        continue                    }                    seen.insert(token)                    tokens.append(token)                }                if groupID == nil, let match = self.extractGroupID(from: entry.value) {                    groupID = match                }            }        }         if tokens.isEmpty, hasMinimaxSignal {            let rawCandidates = SweetCookieKit.ChromiumLocalStorageReader.readTokenCandidates(                in: levelDBURL,                minimumLength: 60,                logger: logger)            if !rawCandidates.isEmpty {                logger?("[minimax-storage] Local storage raw token candidates: \(rawCandidates.count)")            }            for candidate in rawCandidates                where self.looksLikeToken(candidate) && self.isMiniMaxJWT(candidate) && !seen.contains(candidate)            {                seen.insert(candidate)                tokens.append(candidate)                if groupID == nil {                    groupID = self.groupID(fromJWT: candidate)                }            }        }         if tokens.isEmpty, !entries.isEmpty {            let sample = entries.prefix(6).map { "\($0.key) (\($0.value.count) chars)" }            logger?("[minimax-storage] Local storage key sample: \(sample.joined(separator: ", "))")            for entry in entries                where entry.key == "user_detail" || entry.key == "persist:root" || entry.key == "access_token"            {                let preview = entry.value.prefix(200)                if entry.key == "access_token" {                    logger?("[minimax-storage] \(entry.key) preview: \(preview) (raw \(entry.rawValueLength) bytes)")                } else {                    logger?("[minimax-storage] \(entry.key) preview: \(preview)")                }                if entry.key == "persist:root" {                    self.logPersistRootKeys(entry.value, logger: logger)                }            }        }         return LocalStorageSnapshot(tokens: tokens, groupID: groupID)    }     private static func readSessionStorageTokens(        from levelDBURL: URL,        logger: ((String) -> Void)? = nil) -> [String]    {        let entries = SweetCookieKit.ChromiumLocalStorageReader.readTextEntries(            in: levelDBURL,            logger: logger)        guard !entries.isEmpty else { return [] }         let origins = [            "https://platform.minimax.io",            "https://www.minimax.io",            "https://minimax.io",            "https://platform.minimaxi.com",            "https://www.minimaxi.com",            "https://minimaxi.com",        ]        let mapIDs = self.sessionStorageMapIDs(in: entries, origins: origins, logger: logger)        if mapIDs.isEmpty {            logger?("[minimax-storage] No MiniMax session storage namespaces found")            return []        }         let mapEntries = entries.filter { entry in            guard let mapID = self.sessionStorageMapID(fromKey: entry.key) else { return false }            return mapIDs.contains(mapID)        }        if mapEntries.isEmpty {            logger?("[minimax-storage] No MiniMax session storage map entries found")            return []        }         let tokenKeySample = mapEntries            .filter { entry in                entry.key.localizedCaseInsensitiveContains("token") ||                    entry.key.localizedCaseInsensitiveContains("auth")            }            .prefix(8)            .map(\.key)        if !tokenKeySample.isEmpty {            logger?("[minimax-storage] MiniMax session storage token keys: \(tokenKeySample.joined(separator: ", "))")        }         var tokens: [String] = []        var seen = Set<String>()        for entry in mapEntries {            let extracted = self.extractAccessTokens(from: entry.value)            for token in extracted where !seen.contains(token) {                seen.insert(token)                tokens.append(token)            }        } 

Lines 1–500 of 878. Load more