diff --git a/CHANGELOG.md b/CHANGELOG.md index d615c76bc312..e279bd517a31 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,12 @@ All notable changes to cmux are documented here. +## [Unreleased] + +### Fixed + +- Surface Settings > Sign In failures in Account settings instead of only logging ASWebAuthenticationSession and callback errors ([#3617](https://github.com/manaflow-ai/cmux/issues/3617)) + ## [0.64.10] - 2026-05-23 ### Added @@ -190,13 +196,16 @@ All notable changes to cmux are documented here. ## [0.64.6] - 2026-05-14 ### Added + - Command palette toggles for boolean Settings rows, including iMessage Mode ([f85cc56a](https://github.com/manaflow-ai/cmux/commit/f85cc56ae99c235c61ea6ef091e88ccca6d4171d)) ### Changed + - Improve Cloud VM error guidance with sign-in steps, unknown-flag suggestions, and usage examples ([#4094](https://github.com/manaflow-ai/cmux/pull/4094)) - Use transparent backgrounds for file preview panels so previews follow the active Ghostty theme opacity ([#4088](https://github.com/manaflow-ai/cmux/pull/4088)) ### Fixed + - Fix `cmux ssh` dropping keystrokes after connecting — the backgrounded ssh inside the startup wrapper now inherits the wrapper's stdin so typing reaches the remote shell ([#4135](https://github.com/manaflow-ai/cmux/pull/4135)) -- thanks @kays0x for the fix, @kenfdev and @liudp1988 for the reports! - Keep the selected workspace visible after sidebar reorders ([#4083](https://github.com/manaflow-ai/cmux/pull/4083)) - Fix Pi Vault icon and JSONL session titles ([#4120](https://github.com/manaflow-ai/cmux/pull/4120)) @@ -410,6 +419,7 @@ All notable changes to cmux are documented here. - Cursor and Gemini CLI agent integrations with `setup-hooks` ([#2717](https://github.com/manaflow-ai/cmux/pull/2717)) - iMessage mode for agent prompts ([#3252](https://github.com/manaflow-ai/cmux/pull/3252)) - Settings sidebar shell and unified config utility window with cmux, Ghostty, and synced tabs ([#3024](https://github.com/manaflow-ai/cmux/pull/3024), [#3244](https://github.com/manaflow-ai/cmux/pull/3244), [#3400](https://github.com/manaflow-ai/cmux/pull/3400)) +- Settings > Sign In for connecting a cmux account from Account settings - Make `cmux.json` the canonical settings file with JSONC parsing and legacy `settings.json` fallback ([#3409](https://github.com/manaflow-ai/cmux/pull/3409), [#3424](https://github.com/manaflow-ai/cmux/pull/3424)) - Configurable `cmux.json` workspace and tab bar plus-button actions ([#3084](https://github.com/manaflow-ai/cmux/pull/3084), [#3348](https://github.com/manaflow-ai/cmux/pull/3348)) - Configurable surface tab bar font size ([#2645](https://github.com/manaflow-ai/cmux/pull/2645)) diff --git a/Resources/Localizable.xcstrings b/Resources/Localizable.xcstrings index d4a17085e6ca..b4b627024779 100644 --- a/Resources/Localizable.xcstrings +++ b/Resources/Localizable.xcstrings @@ -144247,6 +144247,125 @@ } } }, + "settings.account.error.signInFailed": { + "extractionState": "manual", + "localizations": { + "ar": { + "stringUnit": { + "state": "translated", + "value": "فشل تسجيل الدخول. حاول مرة أخرى." + } + }, + "bs": { + "stringUnit": { + "state": "translated", + "value": "Prijava nije uspjela. Pokušajte ponovo." + } + }, + "da": { + "stringUnit": { + "state": "translated", + "value": "Login mislykkedes. Prøv igen." + } + }, + "de": { + "stringUnit": { + "state": "translated", + "value": "Anmeldung fehlgeschlagen. Versuchen Sie es erneut." + } + }, + "en": { + "stringUnit": { + "state": "translated", + "value": "Sign in failed. Try again." + } + }, + "es": { + "stringUnit": { + "state": "translated", + "value": "No se pudo iniciar sesión. Inténtalo de nuevo." + } + }, + "fr": { + "stringUnit": { + "state": "translated", + "value": "Échec de la connexion. Réessayez." + } + }, + "it": { + "stringUnit": { + "state": "translated", + "value": "Accesso non riuscito. Riprova." + } + }, + "ja": { + "stringUnit": { + "state": "translated", + "value": "サインインに失敗しました。もう一度お試しください。" + } + }, + "ko": { + "stringUnit": { + "state": "translated", + "value": "로그인에 실패했습니다. 다시 시도하세요." + } + }, + "nb": { + "stringUnit": { + "state": "translated", + "value": "Innlogging mislyktes. Prøv igjen." + } + }, + "pl": { + "stringUnit": { + "state": "translated", + "value": "Logowanie nie powiodło się. Spróbuj ponownie." + } + }, + "pt-BR": { + "stringUnit": { + "state": "translated", + "value": "Falha ao entrar. Tente novamente." + } + }, + "ru": { + "stringUnit": { + "state": "translated", + "value": "Не удалось войти. Попробуйте ещё раз." + } + }, + "th": { + "stringUnit": { + "state": "translated", + "value": "ลงชื่อเข้าใช้ไม่สำเร็จ ลองอีกครั้ง" + } + }, + "tr": { + "stringUnit": { + "state": "translated", + "value": "Oturum açma başarısız. Tekrar deneyin." + } + }, + "uk": { + "stringUnit": { + "state": "translated", + "value": "Не вдалося ввійти. Спробуйте ще раз." + } + }, + "zh-Hans": { + "stringUnit": { + "state": "translated", + "value": "登录失败。请重试。" + } + }, + "zh-Hant": { + "stringUnit": { + "state": "translated", + "value": "登入失敗。請再試一次。" + } + } + } + }, "rightSidebar.mode.feed": { "extractionState": "manual", "localizations": { diff --git a/Sources/Auth/AuthManager.swift b/Sources/Auth/AuthManager.swift index 842940a29404..f6303584d374 100644 --- a/Sources/Auth/AuthManager.swift +++ b/Sources/Auth/AuthManager.swift @@ -32,32 +32,6 @@ private final class AuthPresentationContext: NSObject, ASWebAuthenticationPresen } } -enum AuthManagerError: LocalizedError { - case invalidCallback - case missingAccessToken - case missingRefreshToken - - var errorDescription: String? { - switch self { - case .invalidCallback: - return String( - localized: "settings.account.error.invalidCallback", - defaultValue: "The sign-in callback was invalid." - ) - case .missingAccessToken: - return String( - localized: "settings.account.error.missingAccessToken", - defaultValue: "Account access token is unavailable." - ) - case .missingRefreshToken: - return String( - localized: "settings.account.error.missingRefreshToken", - defaultValue: "Account refresh token is unavailable." - ) - } - } -} - protocol StackAuthTokenStoreProtocol: TokenStoreProtocol, Sendable { func seed(accessToken: String, refreshToken: String) async func clear() async @@ -159,6 +133,7 @@ final class AuthManager: ObservableObject { @Published private(set) var isLoading = false @Published private(set) var isRestoringSession = false @Published private(set) var didCompleteBrowserSignIn = false + @Published private(set) var lastSignInError: AuthSignInError? @Published var selectedTeamID: String? { didSet { guard selectedTeamID != oldValue else { return } @@ -176,6 +151,7 @@ final class AuthManager: ObservableObject { private let tokenStore: any StackAuthTokenStoreProtocol private let settingsStore: AuthSettingsStore private let urlOpener: (URL) -> Void + private let credentialSignIn: @Sendable (_ email: String, _ password: String) async throws -> SignInResult /// Resolves when the on-launch session restoration finishes (success or failure). /// Any probe that needs a definitive `isAuthenticated` value must `await` this @@ -188,12 +164,16 @@ final class AuthManager: ObservableObject { client: (any AuthClientProtocol)? = nil, tokenStore: any StackAuthTokenStoreProtocol = KeychainStackTokenStore(), settingsStore: AuthSettingsStore = AuthSettingsStore(), - urlOpener: ((URL) -> Void)? = nil + urlOpener: ((URL) -> Void)? = nil, + credentialSignIn: (@Sendable (_ email: String, _ password: String) async throws -> SignInResult)? = nil ) { self.tokenStore = tokenStore self.settingsStore = settingsStore self.client = client ?? Self.makeDefaultClient(tokenStore: tokenStore) self.urlOpener = urlOpener ?? Self.defaultURLOpener + self.credentialSignIn = credentialSignIn ?? { email, password in + try await Self.signInWithCredentialDirectly(email: email, password: password) + } let cachedUser = settingsStore.cachedUser() self.currentUser = cachedUser self.selectedTeamID = settingsStore.selectedTeamID @@ -225,15 +205,37 @@ final class AuthManager: ObservableObject { case restore case signIn case signOut + case signInCancellation + + var clearsSupersededAuthState: Bool { + switch self { + case .signOut, .signInCancellation: + return true + case .restore, .signIn: + return false + } + } } + private struct AuthMutationSupersededError: Error, Sendable {} + #if DEBUG func markBrowserSignInLoadingForTesting() { _ = startBrowserSignInAttempt() } + + func markCredentialSignInLoadingForTesting() { + _ = beginAuthMutation(.signIn) + isLoading = true + } + + func markBrowserSignInTimedOutForTesting() { + timeOutBrowserSignInAttempt() + } #endif func beginSignIn() { + lastSignInError = nil loginPollTask?.cancel() webAuthSession?.cancel() webAuthSession = nil @@ -253,10 +255,21 @@ final class AuthManager: ObservableObject { self.finishBrowserSignInAttempt(attemptID) } if let error { + let nsError = error as NSError + if Self.shouldSuppressWebAuthError(nsError) { + self.authLog("auth.webauth cancelled by user") + return + } + self.lastSignInError = .message(nsError.localizedDescription) + self.authLog("auth.webauth failed: \(error)") + return + } + guard let callbackURL else { + let error = AuthManagerError.invalidCallback + self.lastSignInError = .authManager(error) self.authLog("auth.webauth failed: \(error)") return } - guard let callbackURL else { return } let callbackPayload = AuthCallbackRouter.callbackPayload(from: callbackURL) do { try await self.handleCallbackURL(callbackURL) @@ -284,6 +297,7 @@ final class AuthManager: ObservableObject { webAuthSession = session } else { authLog("auth.webauth: session.start() returned false") + lastSignInError = .message("auth.webauth session.start returned false") finishBrowserSignInAttempt(attemptID) } } @@ -296,7 +310,15 @@ final class AuthManager: ObservableObject { func beginSignInAndAwait(timeout: TimeInterval) async -> Bool { if isAuthenticated { return true } beginSignIn() - return await waitForSignInSettled(timeout: timeout) + if !isLoading { return isAuthenticated } + let signedIn = await waitForSignInSettled(timeout: timeout) + if signedIn || isAuthenticated { + return true + } + if isLoading { + timeOutBrowserSignInAttempt() + } + return isAuthenticated } /// Signs out and awaits the state to flip. signOut() is already async and @@ -456,7 +478,11 @@ final class AuthManager: ObservableObject { func handleCallbackURL(_ url: URL) async throws { guard let payload = AuthCallbackRouter.callbackPayload(from: url) else { - throw AuthManagerError.invalidCallback + let error = AuthManagerError.invalidCallback + if hasActiveBrowserSignInAttempt { + lastSignInError = .authManager(error) + } + throw error } let mutationGeneration = beginAuthMutation(.signIn) @@ -484,6 +510,17 @@ final class AuthManager: ObservableObject { refreshToken: payload.refreshToken ) return + } catch { + guard isCurrentAuthMutation(mutationGeneration) else { + _ = await keepAuthMutationIfCurrent( + mutationGeneration, + accessToken: payload.accessToken, + refreshToken: payload.refreshToken + ) + return + } + lastSignInError = Self.signInError(from: error) + throw error } guard await keepAuthMutationIfCurrent( mutationGeneration, @@ -493,6 +530,7 @@ final class AuthManager: ObservableObject { return } didCompleteBrowserSignIn = true + lastSignInError = nil } func seedTokensFromCLI(refreshToken: String, accessToken: String?) async { @@ -521,12 +559,13 @@ final class AuthManager: ObservableObject { do { try await refreshSession() authLog("seedTokensFromCLI: success user=\(currentUser?.primaryEmail ?? "nil")") + lastSignInError = nil } catch { authLog("seedTokensFromCLI: refreshSession failed: \(error)") } } - struct SignInResult { + struct SignInResult: Sendable { let accessToken: String let refreshToken: String let email: String? @@ -576,88 +615,74 @@ final class AuthManager: ObservableObject { teams: teams) } - func applySignInResult(_ result: SignInResult) { - // Cache access token for fast synchronous reads - lastKnownAccessToken = result.accessToken - // Store tokens in keychain (fire-and-forget) - let store = tokenStore - Task.detached { - await store.setTokens(accessToken: result.accessToken, refreshToken: result.refreshToken) + func applySignInResult(_ result: SignInResult) async { + lastSignInError = nil + let mutationGeneration = beginAuthMutation(.signIn) + isLoading = true + defer { + if isCurrentAuthMutation(mutationGeneration) { + isLoading = false + } } - // Update published state synchronously on main actor - let user = CMUXAuthUser(id: result.userId, primaryEmail: result.email, displayName: result.displayName) - currentUser = user - settingsStore.saveCachedUser(user) - availableTeams = result.teams - isAuthenticated = true - selectedTeamID = Self.resolveTeamID(selectedTeamID: selectedTeamID, teams: result.teams) - didCompleteBrowserSignIn = true + await tokenStore.setTokens(accessToken: result.accessToken, refreshToken: result.refreshToken) + guard await keepAuthMutationIfCurrent( + mutationGeneration, + accessToken: result.accessToken, + refreshToken: result.refreshToken + ) else { + return + } + + publishSignInResult(result) authLog("applySignInResult: user=\(result.email ?? "nil") teams=\(result.teams.count) teamID=\(selectedTeamID ?? "nil")") } func signInWithCredential(email: String, password: String) async throws { authLog("signInWithCredential: email=\(email)") + lastSignInError = nil + let mutationGeneration = beginAuthMutation(.signIn) isLoading = true - defer { isLoading = false } + defer { + if isCurrentAuthMutation(mutationGeneration) { + isLoading = false + } + } // Sign in directly via the Stack Auth API and store tokens ourselves, // bypassing the StackClientApp which has token refresh issues. - let json = try await Self.stackAPIRequest( - url: "\(AuthEnvironment.stackBaseURL.absoluteString)/api/v1/auth/password/sign-in", - body: try JSONSerialization.data(withJSONObject: ["email": email, "password": password]), - projectID: AuthEnvironment.stackProjectID, - clientKey: AuthEnvironment.stackPublishableClientKey - ) - guard let accessToken = json["access_token"] as? String, - let refreshToken = json["refresh_token"] as? String else { - throw AuthManagerError.invalidCallback - } - await tokenStore.setTokens(accessToken: accessToken, refreshToken: refreshToken) - lastKnownAccessToken = accessToken - - // Fetch user info directly with the access token - let userJSON = try await Self.stackAPIRequest( - url: "\(AuthEnvironment.stackBaseURL.absoluteString)/api/v1/users/me", - body: Data(), - projectID: AuthEnvironment.stackProjectID, - clientKey: AuthEnvironment.stackPublishableClientKey, - extraHeaders: ["x-stack-access-token": accessToken], - method: "GET" - ) - let user = CMUXAuthUser( - id: userJSON["id"] as? String ?? "", - primaryEmail: userJSON["primary_email"] as? String, - displayName: userJSON["display_name"] as? String - ) - - // Fetch teams - let teamsJSON = try await Self.stackAPIRequest( - url: "\(AuthEnvironment.stackBaseURL.absoluteString)/api/v1/teams?user_id=me", - body: Data(), - projectID: AuthEnvironment.stackProjectID, - clientKey: AuthEnvironment.stackPublishableClientKey, - extraHeaders: ["x-stack-access-token": accessToken], - method: "GET" - ) - var teams: [AuthTeamSummary] = [] - if let items = teamsJSON["items"] as? [[String: Any]] { - for item in items { - if let id = item["id"] as? String { - teams.append(AuthTeamSummary( - id: id, - displayName: item["display_name"] as? String ?? "" - )) - } + do { + let result = try await credentialSignIn(email, password) + await tokenStore.setTokens(accessToken: result.accessToken, refreshToken: result.refreshToken) + guard await keepAuthMutationIfCurrent( + mutationGeneration, + accessToken: result.accessToken, + refreshToken: result.refreshToken + ) else { + throw AuthMutationSupersededError() + } + publishSignInResult(result) + authLog("signInWithCredential: success user=\(result.email ?? "nil") teams=\(result.teams.count) teamID=\(selectedTeamID ?? "nil")") + } catch is AuthMutationSupersededError { + authLog("signInWithCredential: superseded by a newer auth mutation") + return + } catch { + if isCurrentAuthMutation(mutationGeneration) { + lastSignInError = Self.signInError(from: error) } + throw error } + } + private func publishSignInResult(_ result: SignInResult) { + lastKnownAccessToken = result.accessToken + let user = CMUXAuthUser(id: result.userId, primaryEmail: result.email, displayName: result.displayName) currentUser = user settingsStore.saveCachedUser(user) - availableTeams = teams + availableTeams = result.teams isAuthenticated = true - selectedTeamID = Self.resolveTeamID(selectedTeamID: selectedTeamID, teams: teams) - authLog("signInWithCredential: success user=\(user.primaryEmail ?? "nil") teams=\(teams.count) teamID=\(selectedTeamID ?? "nil")") + selectedTeamID = Self.resolveTeamID(selectedTeamID: selectedTeamID, teams: result.teams) didCompleteBrowserSignIn = true + lastSignInError = nil } func signOut() async { @@ -673,6 +698,7 @@ final class AuthManager: ObservableObject { ) guard isCurrentAuthMutation(signOutGeneration) else { return } clearSessionState(clearSelectedTeam: true) + lastSignInError = nil } /// Cached access token for fast reads after sign-in or session restoration. @@ -886,7 +912,9 @@ final class AuthManager: ObservableObject { accessToken: accessToken, refreshToken: refreshToken ) - if cachedMatches || storedCleared || currentAuthMutationKind == .signOut { + let shouldClearSupersededAuthState = + currentAuthMutationKind?.clearsSupersededAuthState == true + if cachedMatches || storedCleared || shouldClearSupersededAuthState { clearSessionState(clearSelectedTeam: true) } return false @@ -908,6 +936,10 @@ final class AuthManager: ObservableObject { && signOutCancelledBrowserSignInAttemptID != attemptID } + private var hasActiveBrowserSignInAttempt: Bool { + activeBrowserSignInAttemptID != nil + } + private func finishBrowserSignInAttempt(_ attemptID: UInt64) { guard activeBrowserSignInAttemptID == attemptID else { return } isLoading = false @@ -918,6 +950,18 @@ final class AuthManager: ObservableObject { } } + private func timeOutBrowserSignInAttempt() { + lastSignInError = .message("auth.webauth sign-in attempt timed out") + _ = beginAuthMutation(.signInCancellation) + webAuthSession?.cancel() + if let attemptID = activeBrowserSignInAttemptID { + finishBrowserSignInAttempt(attemptID) + } else { + webAuthSession = nil + isLoading = false + } + } + private func cancelBrowserSignInForSignOut() { if let attemptID = activeBrowserSignInAttemptID { signOutCancelledBrowserSignInAttemptID = attemptID diff --git a/Sources/Auth/AuthManagerErrors.swift b/Sources/Auth/AuthManagerErrors.swift new file mode 100644 index 000000000000..23b399a08763 --- /dev/null +++ b/Sources/Auth/AuthManagerErrors.swift @@ -0,0 +1,58 @@ +import AuthenticationServices +import Foundation + +enum AuthManagerError: LocalizedError, Equatable, Sendable { + case invalidCallback + case missingAccessToken + case missingRefreshToken + + var errorDescription: String? { + switch self { + case .invalidCallback: + return String( + localized: "settings.account.error.invalidCallback", + defaultValue: "The sign-in callback was invalid." + ) + case .missingAccessToken: + return String( + localized: "settings.account.error.missingAccessToken", + defaultValue: "Account access token is unavailable." + ) + case .missingRefreshToken: + return String( + localized: "settings.account.error.missingRefreshToken", + defaultValue: "Account refresh token is unavailable." + ) + } + } +} + +enum AuthSignInError: Equatable, Sendable { + case authManager(AuthManagerError) + case message(String) + + var localizedMessage: String { + Self.genericLocalizedMessage + } + + private static var genericLocalizedMessage: String { + String( + localized: "settings.account.error.signInFailed", + defaultValue: "Sign in failed. Try again." + ) + } +} + +extension AuthManager { + nonisolated static func signInError(from error: Error) -> AuthSignInError { + if let authError = error as? AuthManagerError { + return .authManager(authError) + } + return .message((error as NSError).localizedDescription) + } + + nonisolated static func shouldSuppressWebAuthError(_ error: NSError) -> Bool { + error.domain == ASWebAuthenticationSessionError.errorDomain + && error.code == ASWebAuthenticationSessionError.canceledLogin.rawValue + } +} diff --git a/Sources/Settings/AuthSettingsRow.swift b/Sources/Settings/AuthSettingsRow.swift new file mode 100644 index 000000000000..3b27ab2caba1 --- /dev/null +++ b/Sources/Settings/AuthSettingsRow.swift @@ -0,0 +1,96 @@ +import SwiftUI + +struct AuthSettingsRow: View { + @ObservedObject var authManager: AuthManager + + var body: some View { + HStack(alignment: .top, spacing: 12) { + VStack(alignment: .leading, spacing: 2) { + Text(titleText) + .font(.system(size: 13, weight: .medium)) + if let subtitle = subtitleText { + Text(subtitle) + .font(.system(size: 11)) + .foregroundColor(.secondary) + } + } + Spacer(minLength: 12) + if authManager.isLoading || authManager.isRestoringSession { + ProgressView().controlSize(.small) + .padding(.top, 2) + } + VStack(alignment: .trailing, spacing: 4) { + Button(action: buttonAction) { + Text(buttonTitle) + } + .controlSize(.small) + .disabled(authManager.isLoading || authManager.isRestoringSession) + if let signInErrorText { + Text(signInErrorText) + .font(.system(size: 11)) + .foregroundStyle(.red) + .multilineTextAlignment(.trailing) + .fixedSize(horizontal: false, vertical: true) + .frame(maxWidth: 220, alignment: .trailing) + } + } + } + .padding(.horizontal, 14) + .padding(.vertical, 10) + } + + private var titleText: String { + if authManager.isAuthenticated { + if let email = authManager.currentUser?.primaryEmail, !email.isEmpty { + return email + } + return String( + localized: "settings.account.signedIn.title", + defaultValue: "Signed in" + ) + } + return String( + localized: "settings.account.signedOut.title", + defaultValue: "Not signed in" + ) + } + + private var subtitleText: String? { + if authManager.isAuthenticated { + return authManager.currentUser?.displayName + } + return String( + localized: "settings.account.signedOut.subtitle", + defaultValue: "Sign in with your cmux account to enable sync across devices." + ) + } + + private var signInErrorText: String? { + guard !authManager.isAuthenticated else { return nil } + return authManager.lastSignInError?.localizedMessage + } + + private var buttonTitle: String { + if authManager.isAuthenticated { + return String( + localized: "settings.account.signOut", + defaultValue: "Sign Out" + ) + } + return String( + localized: "settings.account.signIn", + defaultValue: "Sign In…" + ) + } + + private func buttonAction() { + guard !authManager.isLoading && !authManager.isRestoringSession else { return } + if authManager.isAuthenticated { + Task { @MainActor in + await authManager.signOut() + } + } else { + authManager.beginSignIn() + } + } +} diff --git a/Sources/cmuxApp.swift b/Sources/cmuxApp.swift index 2b360061d1e7..7c71c610e108 100644 --- a/Sources/cmuxApp.swift +++ b/Sources/cmuxApp.swift @@ -8628,84 +8628,6 @@ struct SettingsSectionHeader: View { } } -private struct AuthSettingsRow: View { - @ObservedObject var authManager: AuthManager - - var body: some View { - HStack(alignment: .center, spacing: 12) { - VStack(alignment: .leading, spacing: 2) { - Text(titleText) - .font(.system(size: 13, weight: .medium)) - if let subtitle = subtitleText { - Text(subtitle) - .font(.system(size: 11)) - .foregroundColor(.secondary) - } - } - Spacer(minLength: 12) - if authManager.isLoading || authManager.isRestoringSession { - ProgressView().controlSize(.small) - } - Button(action: buttonAction) { - Text(buttonTitle) - } - .controlSize(.small) - .disabled(authManager.isLoading || authManager.isRestoringSession) - } - .padding(.horizontal, 14) - .padding(.vertical, 10) - } - - private var titleText: String { - if authManager.isAuthenticated { - if let email = authManager.currentUser?.primaryEmail, !email.isEmpty { - return email - } - return String( - localized: "settings.account.signedIn.title", - defaultValue: "Signed in" - ) - } - return String( - localized: "settings.account.signedOut.title", - defaultValue: "Not signed in" - ) - } - - private var subtitleText: String? { - if authManager.isAuthenticated { - return authManager.currentUser?.displayName - } - return String( - localized: "settings.account.signedOut.subtitle", - defaultValue: "Sign in with your cmux account to enable sync across devices." - ) - } - - private var buttonTitle: String { - if authManager.isAuthenticated { - return String( - localized: "settings.account.signOut", - defaultValue: "Sign Out" - ) - } - return String( - localized: "settings.account.signIn", - defaultValue: "Sign In…" - ) - } - - private func buttonAction() { - if authManager.isAuthenticated { - Task { @MainActor in - await authManager.signOut() - } - } else { - authManager.beginSignIn() - } - } -} - private struct WorkspaceGroupNewWorkspacePlacementSettingsRow: View { let controlWidth: CGFloat @Binding var selection: String diff --git a/cmux.xcodeproj/project.pbxproj b/cmux.xcodeproj/project.pbxproj index 5c35b929bcbf..7c675e7794fa 100644 --- a/cmux.xcodeproj/project.pbxproj +++ b/cmux.xcodeproj/project.pbxproj @@ -37,6 +37,9 @@ 36CE99ED050785B5E96B72BB /* AuthCallbackRouter.swift in Sources */ = {isa = PBXBuildFile; fileRef = 61A19A4145F034965110CF87 /* AuthCallbackRouter.swift */; }; D9FEC58D5BACCF76459F1BBE /* AuthEnvironment.swift in Sources */ = {isa = PBXBuildFile; fileRef = 43430FA5929121E2EAAB3091 /* AuthEnvironment.swift */; }; 350DAC5EBD38642A3E81471A /* AuthManager.swift in Sources */ = {isa = PBXBuildFile; fileRef = 312DE7503B4658DD173121B8 /* AuthManager.swift */; }; + A36170000000000000000003 /* AuthManagerErrors.swift in Sources */ = {isa = PBXBuildFile; fileRef = A36170000000000000000004 /* AuthManagerErrors.swift */; }; + A36170000000000000000001 /* AuthManagerSignInErrorTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = A36170000000000000000002 /* AuthManagerSignInErrorTests.swift */; }; + A36170000000000000000005 /* AuthSettingsRow.swift in Sources */ = {isa = PBXBuildFile; fileRef = A36170000000000000000006 /* AuthSettingsRow.swift */; }; 698944F99A6ADFBA24A7BFB9 /* AuthSettingsStore.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5B1EA8948C5F126FE63CFB4E /* AuthSettingsStore.swift */; }; B9000012A1B2C3D4E5F60719 /* AutomationSocketUITests.swift in Sources */ = {isa = PBXBuildFile; fileRef = B9000011A1B2C3D4E5F60719 /* AutomationSocketUITests.swift */; }; C0DE35860000000000000001 /* BackgroundWorkspacePrimeCoordinator.swift in Sources */ = {isa = PBXBuildFile; fileRef = C0DE35860000000000000002 /* BackgroundWorkspacePrimeCoordinator.swift */; }; @@ -679,6 +682,9 @@ 61A19A4145F034965110CF87 /* AuthCallbackRouter.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; path = AuthCallbackRouter.swift; sourceTree = ""; }; 43430FA5929121E2EAAB3091 /* AuthEnvironment.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; path = AuthEnvironment.swift; sourceTree = ""; }; 312DE7503B4658DD173121B8 /* AuthManager.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; path = AuthManager.swift; sourceTree = ""; }; + A36170000000000000000004 /* AuthManagerErrors.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; path = AuthManagerErrors.swift; sourceTree = ""; }; + A36170000000000000000002 /* AuthManagerSignInErrorTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AuthManagerSignInErrorTests.swift; sourceTree = ""; }; + A36170000000000000000006 /* AuthSettingsRow.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Settings/AuthSettingsRow.swift; sourceTree = ""; }; 5B1EA8948C5F126FE63CFB4E /* AuthSettingsStore.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; path = AuthSettingsStore.swift; sourceTree = ""; }; B9000011A1B2C3D4E5F60719 /* AutomationSocketUITests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AutomationSocketUITests.swift; sourceTree = ""; }; C0DE35860000000000000002 /* BackgroundWorkspacePrimeCoordinator.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BackgroundWorkspacePrimeCoordinator.swift; sourceTree = ""; }; @@ -1275,6 +1281,7 @@ 61A19A4145F034965110CF87 /* AuthCallbackRouter.swift */, 43430FA5929121E2EAAB3091 /* AuthEnvironment.swift */, 312DE7503B4658DD173121B8 /* AuthManager.swift */, + A36170000000000000000004 /* AuthManagerErrors.swift */, 5B1EA8948C5F126FE63CFB4E /* AuthSettingsStore.swift */, CD0CFE6100000000CD0CFE61 /* HostAccountFlow.swift */, ); @@ -1370,6 +1377,7 @@ children = ( 3023B1003023B1003023B100 /* ConfigSource.swift */, 3023B1013023B1013023B101 /* ConfigSettingsView.swift */, + A36170000000000000000006 /* AuthSettingsRow.swift */, A11EAB000000000000000001 /* AppearanceSettings.swift */, A11EAC000000000000000001 /* GhosttyTerminalAppearance.swift */, A11EAD000000000000000001 /* WorkspaceAppearanceResolution.swift */, @@ -1780,6 +1788,7 @@ C0DEC0DE000000000000F201 /* CommandPaletteNucleoFFILibrarySupport.swift */, C0DEC0DE000000000000F203 /* CommandPaletteNucleoFixtures.swift */, A50019B3 /* SettingsSearchIndexTests.swift */, + A36170000000000000000002 /* AuthManagerSignInErrorTests.swift */, D36090010000000000000004 /* SettingsWindowPresenterTests.swift */, 970226F3C99D0D937CD00539 /* BrowserConfigTests.swift */, D3622001A1B2C3D4E5F60718 /* BrowserArrowKeyForwardingTests.swift */, @@ -2191,6 +2200,8 @@ 36CE99ED050785B5E96B72BB /* AuthCallbackRouter.swift in Sources */, D9FEC58D5BACCF76459F1BBE /* AuthEnvironment.swift in Sources */, 350DAC5EBD38642A3E81471A /* AuthManager.swift in Sources */, + A36170000000000000000003 /* AuthManagerErrors.swift in Sources */, + A36170000000000000000005 /* AuthSettingsRow.swift in Sources */, 698944F99A6ADFBA24A7BFB9 /* AuthSettingsStore.swift in Sources */, C0DE35860000000000000001 /* BackgroundWorkspacePrimeCoordinator.swift in Sources */, A50012F1 /* Backport.swift in Sources */, @@ -2599,6 +2610,7 @@ C34670010000000000000001 /* AppDelegateRenameShortcutContextTests.swift in Sources */, F6000000A1B2C3D4E5F60718 /* AppDelegateShortcutRoutingTests.swift in Sources */, A11EAA000000000000000000 /* AppearanceSettingsTests.swift in Sources */, + A36170000000000000000001 /* AuthManagerSignInErrorTests.swift in Sources */, D3622000A1B2C3D4E5F60718 /* BrowserArrowKeyForwardingTests.swift in Sources */, E12E88F82733EC42F32C36A3 /* BrowserConfigTests.swift in Sources */, A5008381 /* BrowserFindJavaScriptTests.swift in Sources */, diff --git a/cmuxTests/AuthManagerSignInErrorTests.swift b/cmuxTests/AuthManagerSignInErrorTests.swift new file mode 100644 index 000000000000..cfc315871ec9 --- /dev/null +++ b/cmuxTests/AuthManagerSignInErrorTests.swift @@ -0,0 +1,483 @@ +import CMUXAuthCore +import XCTest + +#if canImport(cmux_DEV) +@testable import cmux_DEV +#elseif canImport(cmux) +@testable import cmux +#endif + +@MainActor +final class AuthManagerSignInErrorTests: XCTestCase { + func testInvalidCallbackStoresVisibleSignInError() async throws { + let suiteName = "AuthManagerSignInErrorTests.InvalidCallback.\(UUID().uuidString)" + guard let defaults = UserDefaults(suiteName: suiteName) else { + XCTFail("Failed to create isolated UserDefaults suite") + return + } + defer { defaults.removePersistentDomain(forName: suiteName) } + + let manager = AuthManager( + tokenStore: TestTokenStore(), + settingsStore: AuthSettingsStore(userDefaults: defaults) + ) + await manager.awaitBootstrapped() + + manager.markBrowserSignInLoadingForTesting() + do { + try await manager.handleCallbackURL(URL(string: "cmux://auth-callback?stack_refresh=refresh-token")!) + XCTFail("Expected invalid callback to throw") + } catch AuthManagerError.invalidCallback { + // Expected path. + } catch { + XCTFail("Expected invalidCallback, got \(error)") + } + + guard case .authManager(.invalidCallback)? = manager.lastSignInError else { + XCTFail("Expected invalid callback to be stored as the visible sign-in error") + return + } + XCTAssertNotEqual( + manager.lastSignInError?.localizedMessage, + AuthManagerError.invalidCallback.errorDescription + ) + XCTAssertEqual( + manager.lastSignInError?.localizedMessage, + AuthSignInError.message("diagnostic detail").localizedMessage + ) + } + + func testStaleInvalidCallbackDoesNotStoreVisibleSignInError() async throws { + let suiteName = "AuthManagerSignInErrorTests.StaleInvalidCallback.\(UUID().uuidString)" + guard let defaults = UserDefaults(suiteName: suiteName) else { + XCTFail("Failed to create isolated UserDefaults suite") + return + } + defer { defaults.removePersistentDomain(forName: suiteName) } + + let manager = AuthManager( + tokenStore: TestTokenStore(), + settingsStore: AuthSettingsStore(userDefaults: defaults) + ) + await manager.awaitBootstrapped() + + do { + try await manager.handleCallbackURL(URL(string: "cmux://auth-callback?stack_refresh=refresh-token")!) + XCTFail("Expected invalid callback to throw") + } catch AuthManagerError.invalidCallback { + // Expected path. + } catch { + XCTFail("Expected invalidCallback, got \(error)") + } + + XCTAssertNil(manager.lastSignInError) + } + + func testApplySignInResultDoesNotRestoreAuthAfterConcurrentSignOut() async throws { + let suiteName = "AuthManagerSignInErrorTests.ConcurrentSignOut.\(UUID().uuidString)" + guard let defaults = UserDefaults(suiteName: suiteName) else { + XCTFail("Failed to create isolated UserDefaults suite") + return + } + defer { defaults.removePersistentDomain(forName: suiteName) } + + let tokenStore = BlockingSetTokenStore() + let manager = AuthManager( + client: TestAuthClient(), + tokenStore: tokenStore, + settingsStore: AuthSettingsStore(userDefaults: defaults) + ) + await manager.awaitBootstrapped() + + let result = AuthManager.SignInResult( + accessToken: "access-token", + refreshToken: "refresh-token", + email: "user@example.com", + displayName: "Test User", + userId: "user-id", + selectedTeamId: nil, + teams: [] + ) + let applyTask = Task { + await manager.applySignInResult(result) + } + + await tokenStore.waitForBlockedSet() + await manager.signOut() + await tokenStore.releaseBlockedSet() + await applyTask.value + + XCTAssertFalse(manager.isAuthenticated) + XCTAssertNil(manager.currentUser) + let storedAccessToken = await tokenStore.currentAccessToken() + let storedRefreshToken = await tokenStore.currentRefreshToken() + XCTAssertNil(storedAccessToken) + XCTAssertNil(storedRefreshToken) + } + + func testApplySignInResultClearsSupersededCredentialLoadingState() async throws { + let suiteName = "AuthManagerSignInErrorTests.ApplyClearsLoading.\(UUID().uuidString)" + guard let defaults = UserDefaults(suiteName: suiteName) else { + XCTFail("Failed to create isolated UserDefaults suite") + return + } + defer { defaults.removePersistentDomain(forName: suiteName) } + + let manager = AuthManager( + tokenStore: TestTokenStore(), + settingsStore: AuthSettingsStore(userDefaults: defaults) + ) + await manager.awaitBootstrapped() + + manager.markCredentialSignInLoadingForTesting() + XCTAssertTrue(manager.isLoading) + + await manager.applySignInResult(makeSignInResult()) + + XCTAssertTrue(manager.isAuthenticated) + XCTAssertFalse(manager.isLoading) + XCTAssertNil(manager.lastSignInError) + } + + func testApplySignInResultClearsVisibleErrorBeforeTokenPersistence() async throws { + let suiteName = "AuthManagerSignInErrorTests.ApplyClearsErrorBeforePersistence.\(UUID().uuidString)" + guard let defaults = UserDefaults(suiteName: suiteName) else { + XCTFail("Failed to create isolated UserDefaults suite") + return + } + defer { defaults.removePersistentDomain(forName: suiteName) } + + let tokenStore = BlockingSetTokenStore() + let manager = AuthManager( + tokenStore: tokenStore, + settingsStore: AuthSettingsStore(userDefaults: defaults) + ) + await manager.awaitBootstrapped() + + manager.markBrowserSignInLoadingForTesting() + do { + try await manager.handleCallbackURL(URL(string: "cmux://auth-callback?stack_refresh=refresh-token")!) + XCTFail("Expected invalid callback to throw") + } catch AuthManagerError.invalidCallback { + // Expected path. + } catch { + XCTFail("Expected invalidCallback, got \(error)") + } + XCTAssertNotNil(manager.lastSignInError) + + let applyTask = Task { + await manager.applySignInResult(makeSignInResult()) + } + await tokenStore.waitForBlockedSet() + + XCTAssertNil(manager.lastSignInError) + + await tokenStore.releaseBlockedSet() + await applyTask.value + XCTAssertTrue(manager.isAuthenticated) + XCTAssertNil(manager.lastSignInError) + } + + func testSupersededCredentialSignInDoesNotLeakInternalError() async throws { + let suiteName = "AuthManagerSignInErrorTests.CredentialSuperseded.\(UUID().uuidString)" + guard let defaults = UserDefaults(suiteName: suiteName) else { + XCTFail("Failed to create isolated UserDefaults suite") + return + } + defer { defaults.removePersistentDomain(forName: suiteName) } + + let tokenStore = TestTokenStore() + let credentialSignIn = BlockingCredentialSignIn(result: makeSignInResult()) + let manager = AuthManager( + client: TestAuthClient(), + tokenStore: tokenStore, + settingsStore: AuthSettingsStore(userDefaults: defaults), + credentialSignIn: { _, _ in + try await credentialSignIn.signIn() + } + ) + await manager.awaitBootstrapped() + + let signInTask = Task { + try await manager.signInWithCredential(email: "user@example.com", password: "password") + } + await credentialSignIn.waitForRequest() + XCTAssertTrue(manager.isLoading) + + await manager.signOut() + await credentialSignIn.release() + + do { + try await signInTask.value + } catch { + XCTFail("Expected superseded credential sign-in to return without leaking an internal error, got \(error)") + } + + XCTAssertFalse(manager.isAuthenticated) + XCTAssertFalse(manager.isLoading) + XCTAssertNil(manager.currentUser) + XCTAssertNil(manager.lastSignInError) + let storedAccessToken = await tokenStore.currentAccessToken() + let storedRefreshToken = await tokenStore.currentRefreshToken() + XCTAssertNil(storedAccessToken) + XCTAssertNil(storedRefreshToken) + } + + func testStaleCallbackFailureDoesNotOverwriteSignOutState() async throws { + let suiteName = "AuthManagerSignInErrorTests.StaleCallbackFailure.\(UUID().uuidString)" + guard let defaults = UserDefaults(suiteName: suiteName) else { + XCTFail("Failed to create isolated UserDefaults suite") + return + } + defer { defaults.removePersistentDomain(forName: suiteName) } + + let client = BlockingFailureAuthClient() + let manager = AuthManager( + client: client, + tokenStore: TestTokenStore(), + settingsStore: AuthSettingsStore(userDefaults: defaults) + ) + await manager.awaitBootstrapped() + + let callbackURL = try XCTUnwrap(URL(string: "cmux://auth-callback?stack_refresh=refresh-token&stack_access=access-token")) + let callbackTask = Task { + try await manager.handleCallbackURL(callbackURL) + } + + await client.waitForCurrentUserRequest() + await manager.signOut() + await client.failCurrentUserRequest() + try await callbackTask.value + + XCTAssertFalse(manager.isAuthenticated) + XCTAssertNil(manager.currentUser) + XCTAssertNil(manager.lastSignInError) + } + + func testTimedOutBrowserSignInDoesNotAuthenticateFromInFlightCallback() async throws { + let suiteName = "AuthManagerSignInErrorTests.TimeoutSupersedesCallback.\(UUID().uuidString)" + guard let defaults = UserDefaults(suiteName: suiteName) else { + XCTFail("Failed to create isolated UserDefaults suite") + return + } + defer { defaults.removePersistentDomain(forName: suiteName) } + + let tokenStore = BlockingSetTokenStore() + let manager = AuthManager( + client: TestAuthClient(), + tokenStore: tokenStore, + settingsStore: AuthSettingsStore(userDefaults: defaults) + ) + await manager.awaitBootstrapped() + + manager.markBrowserSignInLoadingForTesting() + let callbackURL = try XCTUnwrap(URL( + string: "cmux://auth-callback?stack_refresh=refresh-token&stack_access=access-token" + )) + let callbackTask = Task { + try await manager.handleCallbackURL(callbackURL) + } + + await tokenStore.waitForBlockedSet() + manager.markBrowserSignInTimedOutForTesting() + + XCTAssertFalse(manager.isAuthenticated) + XCTAssertFalse(manager.isLoading) + XCTAssertNotNil(manager.lastSignInError) + + await tokenStore.releaseBlockedSet() + try await callbackTask.value + + XCTAssertFalse(manager.isAuthenticated) + XCTAssertFalse(manager.isLoading) + XCTAssertNil(manager.currentUser) + XCTAssertNotNil(manager.lastSignInError) + let storedAccessToken = await tokenStore.currentAccessToken() + let storedRefreshToken = await tokenStore.currentRefreshToken() + XCTAssertNil(storedAccessToken) + XCTAssertNil(storedRefreshToken) + } +} + +private struct TestAuthClient: AuthClientProtocol { + func currentUser() async throws -> CMUXAuthUser? { nil } + func listTeams() async throws -> [AuthTeamSummary] { [] } + func currentAccessToken() async throws -> String? { nil } + func signOut() async throws {} +} + +private func makeSignInResult() -> AuthManager.SignInResult { + AuthManager.SignInResult( + accessToken: "access-token", + refreshToken: "refresh-token", + email: "user@example.com", + displayName: "Test User", + userId: "user-id", + selectedTeamId: nil, + teams: [] + ) +} + +private actor BlockingCredentialSignIn { + private let result: AuthManager.SignInResult + private var signInContinuation: CheckedContinuation? + private var requestWaiters: [CheckedContinuation] = [] + + init(result: AuthManager.SignInResult) { + self.result = result + } + + func signIn() async throws -> AuthManager.SignInResult { + try await withCheckedThrowingContinuation { continuation in + signInContinuation = continuation + let waiters = requestWaiters + requestWaiters.removeAll() + for waiter in waiters { + waiter.resume() + } + } + } + + func waitForRequest() async { + if signInContinuation != nil { + return + } + await withCheckedContinuation { continuation in + requestWaiters.append(continuation) + } + } + + func release() { + let continuation = signInContinuation + signInContinuation = nil + continuation?.resume(returning: result) + } +} + +private actor BlockingFailureAuthClient: AuthClientProtocol { + private var currentUserContinuation: CheckedContinuation? + private var currentUserWaiter: CheckedContinuation? + + func currentUser() async throws -> CMUXAuthUser? { + try await withCheckedThrowingContinuation { continuation in + currentUserContinuation = continuation + currentUserWaiter?.resume() + currentUserWaiter = nil + } + } + + func waitForCurrentUserRequest() async { + if currentUserContinuation != nil { + return + } + await withCheckedContinuation { continuation in + currentUserWaiter = continuation + } + } + + func failCurrentUserRequest() { + let continuation = currentUserContinuation + currentUserContinuation = nil + continuation?.resume(throwing: AuthManagerError.missingAccessToken) + } + + func listTeams() async throws -> [AuthTeamSummary] { [] } + func currentAccessToken() async throws -> String? { nil } + func signOut() async throws {} +} + +private actor TestTokenStore: StackAuthTokenStoreProtocol { + private var accessToken: String? + private var refreshToken: String? + + func getStoredAccessToken() async -> String? { + accessToken + } + + func getStoredRefreshToken() async -> String? { + refreshToken + } + + func setTokens(accessToken: String?, refreshToken: String?) async { + self.accessToken = accessToken + self.refreshToken = refreshToken + } + + func clearTokens() async { + accessToken = nil + refreshToken = nil + } + + func compareAndSet( + compareRefreshToken: String, + newRefreshToken: String?, + newAccessToken: String? + ) async { + guard refreshToken == compareRefreshToken else { return } + refreshToken = newRefreshToken + accessToken = newAccessToken + } +} + +private actor BlockingSetTokenStore: StackAuthTokenStoreProtocol { + private var accessToken: String? + private var refreshToken: String? + private var shouldBlockNextSet = true + private var setIsBlocked = false + private var setStartedWaiters: [CheckedContinuation] = [] + private var releaseSetContinuation: CheckedContinuation? + + func waitForBlockedSet() async { + if setIsBlocked { return } + await withCheckedContinuation { continuation in + setStartedWaiters.append(continuation) + } + } + + func releaseBlockedSet() { + guard let continuation = releaseSetContinuation else { return } + releaseSetContinuation = nil + continuation.resume() + } + + func getStoredAccessToken() async -> String? { + accessToken + } + + func getStoredRefreshToken() async -> String? { + refreshToken + } + + func setTokens(accessToken: String?, refreshToken: String?) async { + if shouldBlockNextSet { + shouldBlockNextSet = false + setIsBlocked = true + let waiters = setStartedWaiters + setStartedWaiters.removeAll() + for waiter in waiters { + waiter.resume() + } + await withCheckedContinuation { continuation in + releaseSetContinuation = continuation + } + setIsBlocked = false + } + self.accessToken = accessToken + self.refreshToken = refreshToken + } + + func clearTokens() async { + accessToken = nil + refreshToken = nil + } + + func compareAndSet( + compareRefreshToken: String, + newRefreshToken: String?, + newAccessToken: String? + ) async { + guard refreshToken == compareRefreshToken else { return } + refreshToken = newRefreshToken + accessToken = newAccessToken + } +}