A native macOS / windows / Linux database IDE built with Swift and AppKit. Connect to PostgreSQL, MySQL, SQLite, and Redis from a single app with a fast, keyboard-driven interface.
C++
feat(keychain): add ChatGPT token bundle storage
cyenx0a1724225736
diff --git a/macos/Data/Keychain/KeychainService.swift b/macos/Data/Keychain/KeychainService.swiftindex 0ac93b0..bc5fd86 100644--- a/macos/Data/Keychain/KeychainService.swift+++ b/macos/Data/Keychain/KeychainService.swift@@ -13,6 +13,13 @@ protocol KeychainServiceProtocol: Sendable {func load(key: String) throws -> String?func delete(key: String) throwsfunc update(key: String, value: String) throws++ // ChatGPT OAuth bundle (per-provider). Implemented in terms of save/load/delete+ // above, but lives on the protocol so call sites holding only the protocol+ // type (e.g. ProviderEditSheet, SettingsView) can use them.+ func saveChatGPTTokens(providerId: UUID, bundle: ChatGPTTokenBundle) throws+ func loadChatGPTTokens(providerId: UUID) throws -> ChatGPTTokenBundle?+ func deleteChatGPTTokens(providerId: UUID) throws}final class KeychainService: KeychainServiceProtocol, Sendable {@@ -207,4 +214,38 @@ final class KeychainService: KeychainServiceProtocol, Sendable {func loadAPIKey(provider: String) throws -> String? {try load(key: "ai.apikey.\(provider)")}++ // MARK: - ChatGPT OAuth tokens+ //+ // Stored as a JSON-encoded `ChatGPTTokenBundle` under a per-provider key.+ // Single blob keeps refresh writes atomic — partial updates after a crash+ // are not possible.++ private func chatGPTTokensKey(_ providerId: UUID) -> String {+ "ai.chatgpt.tokens.\(providerId.uuidString)"+ }++ func saveChatGPTTokens(providerId: UUID, bundle: ChatGPTTokenBundle) throws {+ let encoder = JSONEncoder()+ encoder.dateEncodingStrategy = .iso8601+ let data = try encoder.encode(bundle)+ guard let json = String(data: data, encoding: .utf8) else {+ throw GridexError.keychainError("Failed to encode ChatGPT token bundle")+ }+ try save(key: chatGPTTokensKey(providerId), value: json)+ }++ func loadChatGPTTokens(providerId: UUID) throws -> ChatGPTTokenBundle? {+ guard let json = try load(key: chatGPTTokensKey(providerId)) else { return nil }+ guard let data = json.data(using: .utf8) else {+ throw GridexError.keychainError("ChatGPT token bundle keychain blob is not valid UTF-8")+ }+ let decoder = JSONDecoder()+ decoder.dateDecodingStrategy = .iso8601+ return try decoder.decode(ChatGPTTokenBundle.self, from: data)+ }++ func deleteChatGPTTokens(providerId: UUID) throws {+ try delete(key: chatGPTTokensKey(providerId))+ }}diff --git a/macos/Tests/GridexTests/ChatGPTOAuthTests.swift b/macos/Tests/GridexTests/ChatGPTOAuthTests.swiftnew file mode 100644index 0000000..fb87735--- /dev/null+++ b/macos/Tests/GridexTests/ChatGPTOAuthTests.swift@@ -0,0 +1,282 @@+// ChatGPTOAuthTests.swift — pure-logic tests for the ChatGPT OAuth foundation.+// Covers PKCE primitives, JWT payload decoding, and token bundle round-trips.+// The interactive sign-in flow + live HTTP refresh land in PR 2 with their own+// URL-protocol-mocked tests.++import XCTest+@testable import Gridex++final class ChatGPTOAuthTests: XCTestCase {++ // MARK: - Keychain fixture++ private var keychain: KeychainService!+ private var trackedProviderIds: [UUID] = []++ override func setUp() {+ super.setUp()+ keychain = KeychainService()+ }++ override func tearDown() {+ trackedProviderIds.forEach { try? keychain.deleteChatGPTTokens(providerId: $0) }+ trackedProviderIds.removeAll()+ keychain = nil+ super.tearDown()+ }++ /// Mints a fresh provider UUID and registers it for tearDown cleanup, so the+ /// test body doesn't need its own `defer { try? keychain.delete... }`.+ private func makeProviderId() -> UUID {+ let id = UUID()+ trackedProviderIds.append(id)+ return id+ }++ // MARK: - PKCE++ func test_makeVerifier_returns43CharBase64URL() {+ let v = PKCE.makeVerifier()+ // 32 bytes → 43 base64url chars (no padding)+ XCTAssertEqual(v.count, 43, "verifier should be 43 chars")+ XCTAssertFalse(v.contains("="), "no padding")+ XCTAssertFalse(v.contains("+"), "URL-safe alphabet only")+ XCTAssertFalse(v.contains("/"), "URL-safe alphabet only")+ }++ func test_makeVerifier_isUniquePerCall() {+ let a = PKCE.makeVerifier()+ let b = PKCE.makeVerifier()+ XCTAssertNotEqual(a, b, "CSPRNG should not repeat in 32 bytes of entropy")+ }++ /// RFC 7636 Appendix B test vector — locks the SHA256 + base64url contract.+ func test_challenge_matchesRFC7636Vector() {+ let verifier = "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk"+ let expected = "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM"+ XCTAssertEqual(PKCE.challenge(for: verifier), expected)+ }++ func test_makeState_returns43CharBase64URL() {+ let s = PKCE.makeState()+ XCTAssertEqual(s.count, 43)+ XCTAssertFalse(s.contains("="))+ }++ func test_base64URL_strippsPaddingAndSubstitutes() {+ // 1 byte → "AA==" in standard base64. URL-safe variant: "AA".+ XCTAssertEqual(PKCE.base64URL(Data([0])), "AA")+ // Two bytes hitting a "+" in standard base64.+ // 0xFB 0xFF → "+/8=" → "-_8" after URL-safe + strip.+ XCTAssertEqual(PKCE.base64URL(Data([0xFB, 0xFF])), "-_8")+ }++ // MARK: - JWTDecoder++ /// A hand-crafted unsigned JWT whose payload is `{"exp":1700000000,"sub":"abc","email":"[email protected]"}`.+ /// Header `{"alg":"none","typ":"JWT"}`, signature segment empty.+ private static let fixtureJWT: String = {+ let header = #"{"alg":"none","typ":"JWT"}"#+ let payload = #"{"exp":1700000000,"sub":"abc","email":"[email protected]"}"#+ let h = PKCE.base64URL(Data(header.utf8))+ let p = PKCE.base64URL(Data(payload.utf8))+ return "\(h).\(p)."+ }()++ func test_jwtPayload_decodesClaims() throws {+ let claims = try JWTDecoder.payload(of: Self.fixtureJWT)+ XCTAssertEqual(claims["sub"] as? String, "abc")+ XCTAssertEqual(claims["email"] as? String, "[email protected]")+ XCTAssertEqual(claims["exp"] as? Int, 1700000000)+ }++ func test_jwtExpiration_returnsCorrectDate() throws {+ let date = try XCTUnwrap(JWTDecoder.expiration(of: Self.fixtureJWT))+ XCTAssertEqual(date.timeIntervalSince1970, 1700000000, accuracy: 0.001)+ }++ func test_jwtPayload_throwsOnMalformedSegmentCount() {+ XCTAssertThrowsError(try JWTDecoder.payload(of: "only.two")) { error in+ guard case JWTDecoder.DecodeError.malformed = error else {+ return XCTFail("expected malformed error, got \(error)")+ }+ }+ }++ func test_jwtPayload_throwsOnInvalidBase64() {+ XCTAssertThrowsError(try JWTDecoder.payload(of: "header.@@@.sig"))+ }++ func test_jwtPayload_throwsWhenPayloadIsNotObject() throws {+ // Payload "[]" is valid JSON but not an object.+ let header = PKCE.base64URL(Data(#"{"alg":"none"}"#.utf8))+ let body = PKCE.base64URL(Data("[]".utf8))+ XCTAssertThrowsError(try JWTDecoder.payload(of: "\(header).\(body)."))+ }++ func test_jwtExpiration_returnsNilWhenClaimMissing() {+ let header = PKCE.base64URL(Data(#"{"alg":"none"}"#.utf8))+ let body = PKCE.base64URL(Data(#"{"sub":"x"}"#.utf8))+ let jwt = "\(header).\(body)."+ XCTAssertNil(JWTDecoder.expiration(of: jwt))+ }++ // MARK: - ChatGPTTokenBundle++ func test_tokenBundle_codableRoundTrip() throws {+ let original = ChatGPTTokenBundle(+ accessToken: "access.jwt.value",+ refreshToken: "refresh.jwt.value",+ idToken: "id.jwt.value",+ accountId: "acc_123",+ email: "[email protected]",+ planType: "plus",+ obtainedAt: Date(timeIntervalSince1970: 1700000000),+ schemaVersion: 1+ )++ let encoder = JSONEncoder()+ encoder.dateEncodingStrategy = .iso8601+ let data = try encoder.encode(original)++ let decoder = JSONDecoder()+ decoder.dateDecodingStrategy = .iso8601+ let decoded = try decoder.decode(ChatGPTTokenBundle.self, from: data)++ XCTAssertEqual(decoded, original)+ }++ func test_tokenBundle_optionalFieldsRoundTrip() throws {+ let original = ChatGPTTokenBundle(+ accessToken: "a", refreshToken: "r", idToken: "i"+ )+ let encoder = JSONEncoder()+ encoder.dateEncodingStrategy = .iso8601+ let data = try encoder.encode(original)+ let decoder = JSONDecoder()+ decoder.dateDecodingStrategy = .iso8601+ let decoded = try decoder.decode(ChatGPTTokenBundle.self, from: data)++ XCTAssertNil(decoded.accountId)+ XCTAssertNil(decoded.email)+ XCTAssertNil(decoded.planType)+ XCTAssertEqual(decoded.schemaVersion, 1)+ }++ // MARK: - Keychain helpers++ func test_keychain_chatGPTTokens_roundTrip() throws {+ let providerId = makeProviderId()++ // Pre-condition: nothing stored yet.+ XCTAssertNil(try keychain.loadChatGPTTokens(providerId: providerId))++ let bundle = ChatGPTTokenBundle(+ accessToken: "access",+ refreshToken: "refresh",+ idToken: "id",+ accountId: "acc",+ email: "[email protected]",+ planType: "pro",+ obtainedAt: Date(timeIntervalSince1970: 1700000000)+ )+ try keychain.saveChatGPTTokens(providerId: providerId, bundle: bundle)++ let loaded = try keychain.loadChatGPTTokens(providerId: providerId)+ XCTAssertEqual(loaded, bundle)++ try keychain.deleteChatGPTTokens(providerId: providerId)+ XCTAssertNil(try keychain.loadChatGPTTokens(providerId: providerId))+ }++ /// Locks the per-provider key namespacing — saving under one UUID must not+ /// be visible under another, and deleting under an unrelated UUID must not+ /// touch the original. Guards against a future regression where someone+ /// accidentally drops the UUID from the key (sharing a single slot).+ func test_keychain_chatGPTTokens_isolatedAcrossProviders() throws {+ let providerA = makeProviderId()+ let providerB = makeProviderId()++ let bundleA = ChatGPTTokenBundle(+ accessToken: "A", refreshToken: "rA", idToken: "iA",+ obtainedAt: Date(timeIntervalSince1970: 1700000000)+ )+ try keychain.saveChatGPTTokens(providerId: providerA, bundle: bundleA)++ XCTAssertNil(+ try keychain.loadChatGPTTokens(providerId: providerB),+ "loading under providerB must not see providerA's bundle"+ )++ try keychain.deleteChatGPTTokens(providerId: providerB)+ XCTAssertEqual(+ try keychain.loadChatGPTTokens(providerId: providerA),+ bundleA,+ "delete on providerB must not touch providerA's bundle"+ )+ }++ /// Locks "second save fully replaces the first" — this is the production+ /// path used by every token refresh in `ChatGPTOAuthService.performRefresh`.+ /// A regression where save somehow merged or appended would corrupt the+ /// bundle silently; this test catches that.+ func test_keychain_chatGPTTokens_overwriteReplacesPriorValue() throws {+ let providerId = makeProviderId()++ let first = ChatGPTTokenBundle(+ accessToken: "old", refreshToken: "old-r", idToken: "old-i",+ accountId: "acc-old",+ email: "[email protected]",+ planType: "plus",+ obtainedAt: Date(timeIntervalSince1970: 1700000000)+ )+ let second = ChatGPTTokenBundle(+ accessToken: "new", refreshToken: "new-r", idToken: "new-i",+ accountId: "acc-new",+ email: "[email protected]",+ planType: "pro",+ obtainedAt: Date(timeIntervalSince1970: 1700001000)+ )++ try keychain.saveChatGPTTokens(providerId: providerId, bundle: first)+ try keychain.saveChatGPTTokens(providerId: providerId, bundle: second)++ let loaded = try keychain.loadChatGPTTokens(providerId: providerId)+ XCTAssertEqual(loaded, second, "second save must fully replace the first")+ }++ /// Locks the current `dateEncodingStrategy = .iso8601` contract:+ /// `ISO8601DateFormatter` defaults to `[.withInternetDateTime]` (no+ /// fractional seconds), so `obtainedAt` round-trips truncated to whole+ /// seconds. This is harmless today (`ChatGPTOAuthService` uses JWT `exp`+ /// for refresh timing, not `obtainedAt`, and never compares bundles for+ /// equality), but if a future change starts depending on subsecond+ /// precision, this test will fire and flag that the encoding strategy+ /// needs `.withFractionalSeconds`.+ func test_keychain_chatGPTTokens_obtainedAtRoundTripStripsSubseconds() throws {+ let providerId = makeProviderId()++ // 0.123s past a whole-second boundary — small enough that any rounding+ // mode (truncate or round-to-nearest) lands on the floor value.+ let originalTs: TimeInterval = 1700000000.123+ let bundle = ChatGPTTokenBundle(+ accessToken: "a", refreshToken: "r", idToken: "i",+ obtainedAt: Date(timeIntervalSince1970: originalTs)+ )++ try keychain.saveChatGPTTokens(providerId: providerId, bundle: bundle)+ let loaded = try XCTUnwrap(try keychain.loadChatGPTTokens(providerId: providerId))++ XCTAssertEqual(+ loaded.obtainedAt.timeIntervalSince1970,+ 1700000000.0,+ accuracy: 0.0001,+ "iso8601 default options drop fractional seconds"+ )+ XCTAssertNotEqual(+ loaded.obtainedAt,+ bundle.obtainedAt,+ "Equatable should detect the subsecond loss — if this fails, the encoding has gained fractional-second precision and this test should become an equality assertion"+ )+ }+}