test: add basic tests to check app-server communication

AlexandrSuhinin · AlexandrSuhinin · commit 641885eb2390 · 2025-12-12T10:42:52.000+02:00
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -17,7 +17,7 @@
     "package:darwin-arm64": "cd dist/bin && zip codex-acp-arm64-darwin.zip codex-acp-arm64-darwin",
     "package:win-x64": "cd dist/bin && zip codex-acp-x64-windows.zip codex-acp-x64-windows.exe",
     "start": "bun run src/index.ts",
-    "generate-types": "codex app-server generate-ts --out src/app-server",
+    "generate-types": "./node_modules/.bin/codex app-server generate-ts --out src/app-server",
     "test": "vitest run",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit"
@@ -28,6 +28,7 @@
   "type": "module",
   "devDependencies": {
     "@types/node": "^24.10.1",
+    "@openai/codex": "^0.65.0",
     "tsx": "^4.20.6",
     "typescript": "^5.9.3",
     "vitest": "^4.0.10"
diff --git a/src/CodexAcpClient.ts b/src/CodexAcpClient.ts
@@ -58,9 +58,14 @@ export class CodexAcpClient {
         return result.success;
     }
 
+    async logout(): Promise<void> {
+        await this.codexClient.accountLogout();
+        await this.codexClient.awaitAccountUpdated();
+    }
+
     async authRequired(): Promise<Boolean> {
         const response = await this.codexClient.accountRead({refreshToken: false})
-        return response.requiresOpenaiAuth || !response.account;
+        return response.requiresOpenaiAuth && !response.account;
     }
 
     /**
diff --git a/src/CodexAppServerClient.ts b/src/CodexAppServerClient.ts
@@ -7,9 +7,9 @@ import type {
     ServerNotification
 } from "./app-server";
 import type {
-    AccountLoginCompletedNotification,
+    AccountLoginCompletedNotification, AccountUpdatedNotification,
     GetAccountParams,
-    GetAccountResponse, LoginAccountParams, LoginAccountResponse,
+    GetAccountResponse, LoginAccountParams, LoginAccountResponse, LogoutAccountResponse,
     ThreadStartParams,
     ThreadStartResponse,
     TurnCompletedNotification,
@@ -26,6 +26,11 @@ export class CodexAppServerClient {
 
     constructor(connection: MessageConnection) {
         this.connection = connection;
+        this.onServerNotification((notification) => {
+            for (const callback of this.transportEventHandlers) {
+                callback({ eventType: "notification", ...notification});
+            }
+        });
     }
 
     async initialize(params: InitializeParams): Promise<InitializeResponse> {
@@ -44,6 +49,10 @@ export class CodexAppServerClient {
         return await this.sendRequest({ method: "account/login/start", params: params });
     }
 
+    async accountLogout(): Promise<LogoutAccountResponse> {
+        return await this.sendRequest({ method: "account/logout", params: undefined });
+    }
+
     async awaitLoginCompleted(): Promise<AccountLoginCompletedNotification> {
         return await new Promise((resolve) => {
             this.connection.onNotification("account/login/completed", (event: AccountLoginCompletedNotification) => {
@@ -52,6 +61,14 @@ export class CodexAppServerClient {
         });
     }
 
+    async awaitAccountUpdated(): Promise<AccountUpdatedNotification> {
+        return await new Promise((resolve) => {
+            this.connection.onNotification("account/updated", (event: AccountUpdatedNotification) => {
+                resolve(event);
+            });
+        });
+    }
+
     async accountRead(params: GetAccountParams): Promise<GetAccountResponse> {
         return await this.sendRequest({ method: "account/read", params: params });
     }
@@ -87,11 +104,31 @@ export class CodexAppServerClient {
         return (params as { msg?: EventMsg })?.msg ?? null;
     }
 
+    private transportEventHandlers: Array<(event: ClientTransportEvent) => void> = [];
+    onClientTransportEvent(callback: (event: ClientTransportEvent) => void){
+        this.transportEventHandlers.push(callback);
+    }
+
     private async sendRequest<R>(request: CodexRequest): Promise<R> {
-        return await this.connection.sendRequest(request.method, request.params);
+        for (const callback of this.transportEventHandlers) {
+            callback({ eventType: "request", ...request});
+        }
+        let result: any;
+        if (request.params) {
+            result = await this.connection.sendRequest<R>(request.method, request.params)
+        }
+        else {
+            await this.connection.sendRequest<R>(request.method);
+        }
+        for (const callback of this.transportEventHandlers) {
+            callback({ eventType: "response", ...result});
+        }
+        return result;
     }
 }
 
+export type ClientTransportEvent = { eventType: "request" } & CodexRequest | { eventType: "response" } & unknown | { eventType: "notification" } & ServerNotification;
+
 type CodexRequest = DistributiveOmit<ClientRequest, "id">
 
 type DistributiveOmit<T, K extends keyof any> = T extends any
diff --git a/src/__tests__/CodexACPAgent/CodexAcpClient.test.ts b/src/__tests__/CodexACPAgent/CodexAcpClient.test.ts
@@ -0,0 +1,57 @@
+import {describe, expect, it, vi, beforeEach} from 'vitest';
+import type {CodexAuthRequest} from "../../CodexAuthMethod";
+import {createTestFixture, type TestFixture} from "../acp-test-utils";
+
+describe('ACP server test', () => {
+
+    let fixture: TestFixture;
+    beforeEach(() => {
+        fixture = createTestFixture();
+        vi.clearAllMocks();
+    });
+
+    const ignoredFields = ["thread", "cwd", "id", "createdAt", "path", "threadId", "userAgent"];
+
+    it('should start conversation', async () => {
+        const codexAcpAgent = fixture.getCodexAcpAgent();
+        await codexAcpAgent.initialize({protocolVersion: 1});
+
+        fixture.getCodexAcpClient().authRequired = vi.fn().mockResolvedValue(false);
+        const newSessionResponse = await codexAcpAgent.newSession({cwd: "", mcpServers: []});
+        codexAcpAgent.prompt({ sessionId: newSessionResponse.sessionId, prompt: [{type: "text", text: "Hi!"}] });
+
+        const transportDump = fixture.getTransportDump(ignoredFields);
+        await expect(transportDump).toMatchFileSnapshot("data/start-conversation.json");
+    });
+
+    it('should throw error without authentication', async () => {
+        const codexAcpAgent = fixture.getCodexAcpAgent();
+
+        await codexAcpAgent.initialize({protocolVersion: 1});
+        await fixture.getCodexAcpClient().logout();
+        fixture.clearTransportDump();
+
+        await expect(
+            codexAcpAgent.newSession({cwd: "", mcpServers: []})
+        ).rejects.toThrow("Authentication required");
+
+        const transportDump = fixture.getTransportDump(ignoredFields);
+        await expect(transportDump).toMatchFileSnapshot("data/auth-failed.json");
+    });
+
+    it('should authenticate with key', async () => {
+        const codexAcpAgent = fixture.getCodexAcpAgent();
+
+        await codexAcpAgent.initialize({protocolVersion: 1});
+        await fixture.getCodexAcpClient().logout();
+        fixture.clearTransportDump();
+
+        const authRequest: CodexAuthRequest = { methodId: "api-key", _meta: {apiKey: "TOKEN"} }
+        await codexAcpAgent.authenticate(authRequest);
+        const newSessionResponse = await codexAcpAgent.newSession({cwd: "", mcpServers: []});
+        expect(newSessionResponse.sessionId).toBeDefined()
+
+        const transportDump = fixture.getTransportDump(ignoredFields);
+        await expect(transportDump).toMatchFileSnapshot("data/auth-with-key.json");
+    });
+});
diff --git a/src/__tests__/CodexACPAgent/data/auth-failed.json b/src/__tests__/CodexACPAgent/data/auth-failed.json
@@ -0,0 +1,12 @@
+{
+  "eventType": "request",
+  "method": "account/read",
+  "params": {
+    "refreshToken": false
+  }
+}
+{
+  "eventType": "response",
+  "account": null,
+  "requiresOpenaiAuth": true
+}
diff --git a/src/__tests__/CodexACPAgent/data/auth-with-key.json b/src/__tests__/CodexACPAgent/data/auth-with-key.json
@@ -0,0 +1,56 @@
+{
+  "eventType": "request",
+  "method": "account/login/start",
+  "params": {
+    "type": "apiKey",
+    "apiKey": "TOKEN"
+  }
+}
+{
+  "eventType": "response",
+  "type": "apiKey"
+}
+{
+  "eventType": "request",
+  "method": "account/read",
+  "params": {
+    "refreshToken": false
+  }
+}
+{
+  "eventType": "response",
+  "account": {
+    "type": "apiKey"
+  },
+  "requiresOpenaiAuth": true
+}
+{
+  "eventType": "request",
+  "method": "thread/start",
+  "params": {
+    "config": null,
+    "modelProvider": null,
+    "model": null,
+    "cwd": "cwd",
+    "approvalPolicy": "never",
+    "sandbox": null,
+    "baseInstructions": null,
+    "developerInstructions": null
+  }
+}
+{
+  "eventType": "response",
+  "thread": "thread",
+  "model": "gpt-5.1-codex-max",
+  "modelProvider": "openai",
+  "cwd": "cwd",
+  "approvalPolicy": "never",
+  "sandbox": {
+    "type": "workspaceWrite",
+    "writableRoots": [],
+    "networkAccess": false,
+    "excludeTmpdirEnvVar": false,
+    "excludeSlashTmp": false
+  },
+  "reasoningEffort": "medium"
+}
diff --git a/src/__tests__/CodexACPAgent/data/start-conversation.json b/src/__tests__/CodexACPAgent/data/start-conversation.json
@@ -0,0 +1,64 @@
+{
+  "eventType": "request",
+  "method": "initialize",
+  "params": {
+    "clientInfo": {
+      "name": "codex-acp",
+      "version": "0.0.5",
+      "title": "Codex ACP"
+    }
+  }
+}
+{
+  "eventType": "response",
+  "userAgent": "userAgent"
+}
+{
+  "eventType": "request",
+  "method": "thread/start",
+  "params": {
+    "config": null,
+    "modelProvider": null,
+    "model": null,
+    "cwd": "cwd",
+    "approvalPolicy": "never",
+    "sandbox": null,
+    "baseInstructions": null,
+    "developerInstructions": null
+  }
+}
+{
+  "eventType": "response",
+  "thread": "thread",
+  "model": "gpt-5.1-codex-max",
+  "modelProvider": "openai",
+  "cwd": "cwd",
+  "approvalPolicy": "never",
+  "sandbox": {
+    "type": "workspaceWrite",
+    "writableRoots": [],
+    "networkAccess": false,
+    "excludeTmpdirEnvVar": false,
+    "excludeSlashTmp": false
+  },
+  "reasoningEffort": "medium"
+}
+{
+  "eventType": "request",
+  "method": "turn/start",
+  "params": {
+    "threadId": "threadId",
+    "input": [
+      {
+        "type": "text",
+        "text": "Hi!"
+      }
+    ],
+    "approvalPolicy": null,
+    "sandboxPolicy": null,
+    "summary": null,
+    "cwd": "cwd",
+    "effort": null,
+    "model": null
+  }
+}
diff --git a/src/__tests__/CodexACPAgent/initialize.test.ts b/src/__tests__/CodexACPAgent/initialize.test.ts
@@ -29,7 +29,6 @@ describe('CodexACPAgent - initialize', () => {
             protocolVersion: acp.PROTOCOL_VERSION
         };
         const result = await agent.initialize(params);
-
         expect(result).toEqual({
             protocolVersion: acp.PROTOCOL_VERSION,
             agentCapabilities: {
diff --git a/src/__tests__/acp-test-utils.ts b/src/__tests__/acp-test-utils.ts
diff --git a/src/index.ts b/src/index.ts

Original file line number	Diff line number	Diff line change
`@@ -58,9 +58,14 @@ export class CodexAcpClient {`
`58`	`58`	`return result.success;`
`59`	`59`	`}`
`60`	`60`
	`61`	`+ async logout(): Promise<void> {`
	`62`	`+ await this.codexClient.accountLogout();`
	`63`	`+ await this.codexClient.awaitAccountUpdated();`
	`64`	`+ }`
	`65`	`+`
`61`	`66`	`async authRequired(): Promise<Boolean> {`
`62`	`67`	`const response = await this.codexClient.accountRead({refreshToken: false})`
`63`		`- return response.requiresOpenaiAuth \|\| !response.account;`
	`68`	`+ return response.requiresOpenaiAuth && !response.account;`
`64`	`69`	`}`
`65`	`70`
`66`	`71`	`/**`