Clear session auth state on logout

Author: benbrandt

src/CodexAcpServer.ts

@@ -162,7 +162,8 @@ export class CodexAcpServer {
         this.availableCommands = new CodexCommands(
             connection,
             codexAcpClient,
-            (operation) => this.runWithProcessCheck(operation)
+            (operation) => this.runWithProcessCheck(operation),
+            () => this.markSessionsLoggedOut()
         );
     }
 

src/CodexCommands.ts

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

src/__tests__/CodexACPAgent/CodexAcpClient.test.ts

@@ -1419,6 +1419,54 @@ describe('ACP server test', { timeout: 40_000 }, () => {
         await expect(fixture.getAcpConnectionDump(["sessionId"])).toMatchFileSnapshot("data/command-logout.json");
     });
 
+    it('clears active session auth state when logout command signs out', async () => {
+        const mockFixture = createCodexMockTestFixture();
+        const codexAcpAgent = mockFixture.getCodexAcpAgent();
+        const codexAcpClient = mockFixture.getCodexAcpClient();
+        const model = createTestModel();
+        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, "newSession")
+            .mockResolvedValueOnce({
+                sessionId: "session-1",
+                currentModelId,
+                models: [model],
+                additionalDirectories: [],
+            })
+            .mockResolvedValueOnce({
+                sessionId: "session-2",
+                currentModelId,
+                models: [model],
+                additionalDirectories: [],
+            });
+        const logoutSpy = vi.spyOn(codexAcpClient, "logout").mockResolvedValue();
+
+        const session1 = await codexAcpAgent.newSession({cwd: "/workspace", mcpServers: []});
+        const session2 = await codexAcpAgent.newSession({cwd: "/workspace", mcpServers: []});
+        expect(codexAcpAgent.getSessionState(session1.sessionId).authConfigured).toBe(true);
+        expect(codexAcpAgent.getSessionState(session2.sessionId).authConfigured).toBe(true);
+
+        await codexAcpAgent.prompt({
+            sessionId: session1.sessionId,
+            prompt: [{ type: "text", text: "/logout" }],
+        });
+
+        expect(logoutSpy).toHaveBeenCalledOnce();
+        expect(codexAcpAgent.getSessionState(session1.sessionId)).toMatchObject({
+            account: null,
+            authConfigured: false,
+        });
+        expect(codexAcpAgent.getSessionState(session2.sessionId)).toMatchObject({
+            account: null,
+            authConfigured: false,
+        });
+    });
+
     it('handles skills command', async () => {
         const codexAcpAgent = fixture.getCodexAcpAgent();
         await codexAcpAgent.initialize({protocolVersion: 1});