Fix false logout on refresh for v0.1.17

Resources/Info.plist

@@ -19,9 +19,9 @@
     <key>CFBundlePackageType</key>
     <string>APPL</string>
 	<key>CFBundleShortVersionString</key>
-	<string>0.1.16</string>
+	<string>0.1.17</string>
 	<key>CFBundleVersion</key>
-	<string>16</string>
+	<string>17</string>
     <key>LSMinimumSystemVersion</key>
     <string>14.0</string>
     <key>LSUIElement</key>

Sources/CodexToolbar/Networking/CodexAppServerClient.swift

@@ -461,12 +461,12 @@ actor CodexAppServerClient: CodexRateLimitClient {
             .filter { !$0.isEmpty }
             .joined(separator: "\n")
 
-        let lowercased = combined.lowercased()
-        if lowercased.contains("not logged in")
-            || lowercased.contains("operation not permitted")
-            || lowercased.contains("permission denied")
-            || lowercased.contains("os error 1")
-        {
+        // Only an explicit login-status result establishes that the user is
+        // signed out. Access failures cannot tell us whether credentials exist.
+        let reportsLoggedOut = combined.split(whereSeparator: \.isNewline).contains {
+            $0.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() == "not logged in"
+        }
+        if reportsLoggedOut {
             return .loggedOut
         }
 

Tests/CodexToolbarTests/CodexAppServerClientTests.swift

@@ -88,15 +88,31 @@ final class CodexAppServerClientTests: XCTestCase {
         XCTAssertEqual(status, .loggedOut)
     }
 
-    func testParseLoginStatusTreatsPermissionErrorsAsLoggedOut() {
+    func testParseLoginStatusTreatsPermissionErrorsAsIndeterminate() {
         let status = CodexAppServerClient.parseLoginStatus(
             exitStatus: 1,
             stdout: "",
             stderr: "Error checking login status: Operation not permitted (os error 1)\n",
             timedOut: false
         )
 
-        XCTAssertEqual(status, .loggedOut)
+        XCTAssertEqual(status, .indeterminate("Error checking login status: Operation not permitted (os error 1)"))
+    }
+
+    func testParseLoginStatusDoesNotInferLogoutFromDiagnosticText() {
+        for diagnostic in ["Permission denied", "os error 1", "Unable to determine whether user is not logged in"] {
+            XCTAssertEqual(
+                CodexAppServerClient.parseLoginStatus(exitStatus: 1, stdout: "", stderr: diagnostic, timedOut: false),
+                .indeterminate(diagnostic)
+            )
+        }
+    }
+
+    func testParseLoginStatusTimeoutDoesNotEstablishLogout() {
+        XCTAssertEqual(
+            CodexAppServerClient.parseLoginStatus(exitStatus: 1, stdout: "Not logged in", stderr: "", timedOut: true),
+            .indeterminate("Timed out checking Codex login status.")
+        )
     }
 
     func testParseLoginStatusTreatsUnknownFailuresAsIndeterminate() {

Tests/CodexToolbarTests/RateLimitStoreTests.swift

@@ -909,6 +909,57 @@ final class RateLimitStoreTests: XCTestCase {
         XCTAssertEqual(client.loadSnapshotCallCount, 2)
     }
 
+    func testManualRefreshPermissionFailureDoesNotReportSignInOrDiscardCards() async {
+        let client = FakeCodexRateLimitClient()
+        let permissionStatus = CodexAppServerClient.parseLoginStatus(
+            exitStatus: 1, stdout: "",
+            stderr: "Error checking login status: Permission denied (os error 13)",
+            timedOut: false
+        )
+        client.loginStatusResults = [.success(.loggedIn), .success(permissionStatus)]
+        let store = RateLimitStore(client: client, reconnectDelayNanoseconds: 10_000_000_000,
+                                   refreshDelayNanosecondsProvider: { 10_000_000_000 })
+        await store.start()
+        let initialRemaining = store.cards.map(\.remainingPercent)
+        await store.refreshNow()
+
+        XCTAssertEqual(client.loadSnapshotCallCount, 2)
+        XCTAssertEqual(store.state, .ready)
+        XCTAssertEqual(store.cards.map(\.remainingPercent), initialRemaining)
+        XCTAssertNil(store.staleMessage)
+        await store.stop()
+    }
+
+    func testTimeoutWithPermissionFailurePreservesStaleDataAndRecovers() async {
+        let client = FakeCodexRateLimitClient()
+        let permissionStatus = CodexAppServerClient.parseLoginStatus(
+            exitStatus: 1, stdout: "",
+            stderr: "Error checking login status: Operation not permitted (os error 1)",
+            timedOut: false
+        )
+        client.loginStatusResults = [.success(.loggedIn), .success(.loggedIn), .success(permissionStatus)]
+        let store = RateLimitStore(client: client, reconnectDelayNanoseconds: 10_000_000_000,
+                                   refreshDelayNanosecondsProvider: { 10_000_000_000 })
+        await store.start()
+        let initialCards = store.cards
+        let initialLastUpdated = store.lastUpdated
+        let timeoutMessage = "Timed out reading Codex rate limits."
+        client.loadSnapshotError = CodexAppServerError.serverError(timeoutMessage)
+        await store.refreshNow()
+
+        XCTAssertEqual(store.state, .error(timeoutMessage))
+        XCTAssertEqual(store.statusBarAccessibilityText, timeoutMessage)
+        XCTAssertEqual(store.staleMessage, timeoutMessage)
+        XCTAssertEqual(store.cards, initialCards)
+        XCTAssertEqual(store.lastUpdated, initialLastUpdated)
+
+        client.loadSnapshotError = nil
+        await store.refreshNow()
+        XCTAssertEqual(store.state, .ready)
+        XCTAssertNil(store.staleMessage)
+        await store.stop()
+    }
+
     func testStartupIgnoresRequiresOpenaiAuthWhenAccountIsPresent() async {
         let client = FakeCodexRateLimitClient()
         client.accountResponse = GetAccountResponse(