Track and handle codex process exit codes to pass better error message to a user

Author: xtmq

src/CodexAcpServer.ts

@@ -17,24 +17,27 @@ export class CodexAcpServer implements acp.Agent {
     private readonly codexAcpClient: CodexAcpClient;
     private readonly connection: acp.AgentSideConnection;
     private readonly defaultAuthRequest: CodexAuthRequest | null;
+    private readonly getExitCode: () => number | null;
 
     private readonly sessions: Map<string, SessionState>;
 
     constructor(
         connection: acp.AgentSideConnection,
         codexAcpClient: CodexAcpClient,
         defaultAuthRequest?: CodexAuthRequest,
+        getExitCode?: () => number | null,
     ) {
         this.sessions = new Map();
         this.connection = connection;
-        this.defaultAuthRequest = defaultAuthRequest ?? null;
         this.codexAcpClient = codexAcpClient;
+        this.defaultAuthRequest = defaultAuthRequest ?? null;
+        this.getExitCode = getExitCode ?? (() => null);
     }
 
     async initialize(
         _params: acp.InitializeRequest,
     ): Promise<acp.InitializeResponse> {
-        await this.codexAcpClient.initialize(_params);
+        await this.runWithProcessCheck(() => this.codexAcpClient.initialize(_params));
         return {
             protocolVersion: acp.PROTOCOL_VERSION,
             agentCapabilities: {
@@ -47,15 +50,15 @@ export class CodexAcpServer implements acp.Agent {
     async newSession(
         _params: acp.NewSessionRequest,
     ): Promise<acp.NewSessionResponse> {
-        if (await this.codexAcpClient.authRequired()) {
+        if (await this.runWithProcessCheck(() => this.codexAcpClient.authRequired())) {
             if (this.defaultAuthRequest) {
                 await this.authenticate(this.defaultAuthRequest)
             } else {
                 throw RequestError.authRequired();
             }
         }
 
-        const sessionMetadata = await this.codexAcpClient.newSession(_params);
+        const sessionMetadata = await this.runWithProcessCheck(() => this.codexAcpClient.newSession(_params));
         const {sessionId, currentModelId, models} = sessionMetadata;
         this.sessions.set(sessionId, {
             sessionMetadata: sessionMetadata,
@@ -76,7 +79,7 @@ export class CodexAcpServer implements acp.Agent {
     async authenticate(
         _params: acp.AuthenticateRequest,
     ): Promise<acp.AuthenticateResponse> {
-        const isAuthenticated = await this.codexAcpClient.authenticate(_params);
+        const isAuthenticated = await this.runWithProcessCheck(() => this.codexAcpClient.authenticate(_params));
         if (!isAuthenticated) {
             throw RequestError.invalidParams();
         }
@@ -118,10 +121,10 @@ export class CodexAcpServer implements acp.Agent {
         }
 
 
-        await this.codexAcpClient.setModel({
+        await this.runWithProcessCheck(() => this.codexAcpClient.setModel({
             model: model.model,
             reasoningEffort,
-        });
+        }));
         sessionState.sessionMetadata.currentModelId = ModelId.fromComponents(model, reasoningEffort).toString();
 
         return {};
@@ -155,7 +158,7 @@ export class CodexAcpServer implements acp.Agent {
 
         try {
             const messageHandler = new CodexEventHandler(this.connection, sessionState);
-            await this.codexAcpClient.sendPrompt(params, (event) => messageHandler.handleNotification(event));
+            await this.runWithProcessCheck(() => this.codexAcpClient.sendPrompt(params, (event) => messageHandler.handleNotification(event)));
         } catch (err) {
             if (sessionState.pendingPrompt.signal.aborted) {
                 return {stopReason: "cancelled"};
@@ -171,6 +174,22 @@ export class CodexAcpServer implements acp.Agent {
         };
     }
 
+    private async runWithProcessCheck<T>(operation: () => Promise<T>): Promise<T> {
+        try {
+            return await operation();
+        } catch (err) {
+            const exitCode = this.getExitCode();
+            const requestErrorCode = 1001 // Just some magic number
+            if (exitCode == 3221225781) {
+                throw new RequestError(requestErrorCode, `VC++ redistributable should be installed`);
+            }
+            if (exitCode !== null) {
+                throw new RequestError(requestErrorCode, `Codex process has exited with code ${exitCode}`);
+            }
+            throw err;
+        }
+    }
+
     async cancel(params: acp.CancelNotification): Promise<void> {
         //TODO not supported yet
         this.sessions.get(params.sessionId)?.pendingPrompt?.abort();

src/CodexJsonRpcConnection.ts

@@ -7,7 +7,12 @@ import fs from "node:fs";
 import path from "node:path";
 import {createJSONRPCReader, createJSONRPCWriter} from "./StdUtils";
 
-export function startCodexConnection(codexPath: string, logPath?: string): MessageConnection {
+export interface CodexConnection {
+    readonly connection: MessageConnection
+    readonly process: ChildProcessWithoutNullStreams;
+}
+
+export function startCodexConnection(codexPath: string, logPath?: string): CodexConnection {
     const codex: ChildProcessWithoutNullStreams = spawn(`"${codexPath}" app-server`, {
         shell: process.platform === 'win32'
     });
@@ -28,7 +33,7 @@ export function startCodexConnection(codexPath: string, logPath?: string): Messa
         connection.dispose();
     });
 
-    return connection;
+    return {connection: connection, process: codex};
 }
 
 function attachLogs(proc: ChildProcessWithoutNullStreams, logPath: string) {

src/__tests__/acp-test-utils.ts

@@ -41,10 +41,10 @@ export function createTestFixture(): TestFixture {
         acpEventHandlers.forEach(handler => handler(event));
     });
     const codexConnection = startCodexConnection(pathToCodex);
-    const codexAppServerClient = new CodexAppServerClient(codexConnection);
+    const codexAppServerClient = new CodexAppServerClient(codexConnection.connection);
 
     const codexAcpClient = new CodexAcpClient(codexAppServerClient);
-    const codexAcpAgent = new CodexAcpServer(acpConnection, codexAcpClient);
+    const codexAcpAgent = new CodexAcpServer(acpConnection, codexAcpClient, undefined, () => codexConnection.process.exitCode);
 
     const transportEvents: CodexConnectionEvent[] = []
     const codexEventHandlers: ((event: CodexConnectionEvent) => void)[] = [];

src/index.ts

@@ -17,7 +17,7 @@ if (process.argv.includes("--version")) {
 const codexPath = process.env["CODEX_PATH"] ?? "codex";
 const logPath = process.env["APP_SERVER_LOGS"];
 
-const appServerConnection = startCodexConnection(codexPath, logPath);
+const codexConnection = startCodexConnection(codexPath, logPath);
 const acpJsonStream = createJsonStream(process.stdin, process.stdout);
 
 function createAgent(connection: acp.AgentSideConnection): CodexAcpServer {
@@ -27,9 +27,9 @@ function createAgent(connection: acp.AgentSideConnection): CodexAcpServer {
     const authRequestString = process.env["DEFAULT_AUTH_REQUEST"];
     const parsedRequest = authRequestString ? JSON.parse(authRequestString) : undefined;
     const defaultAuthRequest = parsedRequest && isCodexAuthRequest(parsedRequest) ? parsedRequest : undefined;
-    const appServerClient = new CodexAppServerClient(appServerConnection);
+    const appServerClient = new CodexAppServerClient(codexConnection.connection);
     const codexClient = new CodexAcpClient(appServerClient, config, modelProvider)
-    return new CodexAcpServer(connection, codexClient, defaultAuthRequest);
+    return new CodexAcpServer(connection, codexClient, defaultAuthRequest, () => codexConnection.process.exitCode);
 }
 
 new acp.AgentSideConnection(createAgent, acpJsonStream);