Refresh session auth state after logout

Author: benbrandt

src/CodexAcpClient.ts

@@ -217,6 +217,10 @@ export class CodexAcpClient {
         return response.requiresOpenaiAuth && !response.account;
     }
 
+    hasGatewayAuth(): boolean {
+        return this.gatewayConfig !== null;
+    }
+
     async getAccount(): Promise<GetAccountResponse> {
         return this.codexClient.accountRead({refreshToken: false});
     }

src/CodexAcpServer.ts

@@ -163,7 +163,7 @@ export class CodexAcpServer {
             connection,
             codexAcpClient,
             (operation) => this.runWithProcessCheck(operation),
-            () => this.markSessionsLoggedOut()
+            () => this.refreshSessionsAuthState()
         );
     }
 
@@ -410,7 +410,7 @@ export class CodexAcpServer {
     }
 
     private async getActiveAuthState(): Promise<ActiveAuthState> {
-        if (this.codexAcpClient.getModelProvider()) {
+        if (this.codexAcpClient.hasGatewayAuth()) {
             return {
                 account: null,
                 authConfigured: true,
@@ -586,15 +586,15 @@ export class CodexAcpServer {
     async logout(_params: acp.LogoutRequest): Promise<void> {
         logger.log("Logout request received");
         await this.runWithProcessCheck(() => this.codexAcpClient.logout());
-        this.markSessionsLoggedOut();
+        await this.refreshSessionsAuthState();
         logger.log("Logout request completed");
     }
 
-    private markSessionsLoggedOut(): void {
-        const authConfigured = this.codexAcpClient.getModelProvider() !== null;
+    private async refreshSessionsAuthState(): Promise<void> {
+        const authState = await this.getActiveAuthState();
         for (const sessionState of this.sessions.values()) {
-            sessionState.account = null;
-            sessionState.authConfigured = authConfigured;
+            sessionState.account = authState.account;
+            sessionState.authConfigured = authState.authConfigured;
         }
     }
 

src/CodexCommands.ts

@@ -21,7 +21,7 @@ export type CommandHandleOptions = {
     onTurnStarted?: (turnId: string, threadId: string) => void;
 };
 
-export type LogoutHandler = () => void;
+export type LogoutHandler = () => void | Promise<void>;
 
 export class CodexCommands {
     private readonly connection: AcpClientConnection;
@@ -203,7 +203,7 @@ export class CodexCommands {
             }
             case "logout": {
                 await this.runWithProcessCheck(() => this.codexAcpClient.logout());
-                this.onLogout();
+                await this.onLogout();
                 const session = new ACPSessionConnection(this.connection, sessionId);
                 await session.update({
                     sessionUpdate: "agent_message_chunk",

src/__tests__/CodexACPAgent/CodexAcpClient.test.ts

@@ -1427,10 +1427,20 @@ describe('ACP server test', { timeout: 40_000 }, () => {
         const currentModelId = ModelId.create(model.id, model.defaultReasoningEffort).toString();
 
         vi.spyOn(codexAcpClient, "authRequired").mockResolvedValue(false);
-        vi.spyOn(codexAcpClient, "getAccount").mockResolvedValue({
-            account: { type: "apiKey" },
-            requiresOpenaiAuth: false,
-        });
+        vi.spyOn(codexAcpClient, "getModelProvider").mockReturnValue("openai");
+        const getAccountSpy = vi.spyOn(codexAcpClient, "getAccount")
+            .mockResolvedValueOnce({
+                account: { type: "apiKey" },
+                requiresOpenaiAuth: false,
+            })
+            .mockResolvedValueOnce({
+                account: { type: "apiKey" },
+                requiresOpenaiAuth: false,
+            })
+            .mockResolvedValueOnce({
+                account: null,
+                requiresOpenaiAuth: true,
+            });
         vi.spyOn(codexAcpClient, "newSession")
             .mockResolvedValueOnce({
                 sessionId: "session-1",
@@ -1457,6 +1467,7 @@ describe('ACP server test', { timeout: 40_000 }, () => {
         });
 
         expect(logoutSpy).toHaveBeenCalledOnce();
+        expect(getAccountSpy).toHaveBeenCalledTimes(3);
         expect(codexAcpAgent.getSessionState(session1.sessionId)).toMatchObject({
             account: null,
             authConfigured: false,