Skip to content

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.swift
index 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) throws
func 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.swift
new file mode 100644
index 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"
+ )
+ }
+}