@modelprofile.com/mcp-crossharness 5.0.0 → 5.2.0

package/ts/classes.connection.codex.ts

@@ -1,11 +1,9 @@
 import * as plugins from './plugins.js';
 import * as helpers from './helpers.js';
 import { commitinfo } from './00_commitinfo_data.js';
+import { CodexAppServerClient } from './classes.codexappserverclient.js';
 import type * as interfaces from './interfaces.js';
 
-const appServerVersion = '0.146.0';
-const maxSocketMessageBytes = 4 * 1024 * 1024;
-const maxSocketBufferedBytes = 4 * 1024 * 1024;
 const maxTurnTextChars = 1024 * 1024;
 const maxTurnDeltaChunks = 4096;
 const maxEarlyNotifications = 100;
@@ -28,14 +26,6 @@ interface ICodexNotification {
   params: Record<string, unknown>;
 }
 
-interface IPendingRequest {
-  resolve: (valueArg: unknown) => void;
-  reject: (errorArg: Error) => void;
-  timer: ReturnType<typeof setTimeout>;
-  signal?: AbortSignal;
-  abortHandler?: () => void;
-}
-
 interface IPendingTurn {
   threadId: string;
   turnId?: string;
@@ -70,9 +60,7 @@ export class CodexConnection implements interfaces.IHarnessConnection {
   public state: interfaces.TConnectionState = 'connecting';
   private connectedAt = new Date().toISOString();
   private serverVersion: string | undefined;
-  private socket: InstanceType<typeof plugins.WsWebSocket> | undefined;
-  private requestCounter = 0;
-  private pendingRequests = new Map<number, IPendingRequest>();
+  private client?: CodexAppServerClient;
   private pendingTurns = new Set<IPendingTurn>();
   private threadQueues = new Map<string, IThreadQueueEntry[]>();
   private activeThreads = new Set<string>();
@@ -93,79 +81,20 @@ export class CodexConnection implements interfaces.IHarnessConnection {
       throw new Error(`Codex connection ${this.connectionId} has already been started`);
     }
     this.connectStarted = true;
-    const headers: Record<string, string> = {};
-    const token = process.env.CODEX_REMOTE_TOKEN;
-    if (token) headers.authorization = `Bearer ${token}`;
-    const socket = new plugins.WsWebSocket(this.serverUrl, {
-      perMessageDeflate: false,
-      headers,
-      followRedirects: false,
-      maxPayload: maxSocketMessageBytes,
-    });
-    this.socket = socket;
-    socket.on('message', (data) => this.handleMessage(data.toString()));
-    socket.on('error', (error) => this.handleSocketFailure(error));
-    socket.on('close', () => this.handleSocketClose());
-    await new Promise<void>((resolve, reject) => {
-      const cleanup = () => {
-        clearTimeout(timer);
-        socket.off('open', handleOpen);
-        socket.off('error', handleError);
-        socket.off('close', handleClose);
-      };
-      const handleOpen = () => {
-        cleanup();
-        resolve();
-      };
-      const handleError = (errorArg: Error) => {
-        cleanup();
-        reject(errorArg);
-      };
-      const handleClose = () => {
-        cleanup();
-        reject(new Error('Codex server WebSocket closed during handshake'));
-      };
-      const timer = setTimeout(() => {
-        cleanup();
-        socket.terminate();
-        reject(new Error('Codex server WebSocket handshake timed out'));
-      }, 5000);
-      socket.once('open', handleOpen);
-      socket.once('error', handleError);
-      socket.once('close', handleClose);
+    const client = new CodexAppServerClient({
+      transport: { type: 'websocket', url: this.serverUrl, token: process.env.CODEX_REMOTE_TOKEN },
+      clientInfo: { name: 'mcp-crossharness', title: 'mcp-crossharness', version: commitinfo.version },
+      onNotification: ({ method, params }) => this.handleNotification(method, params),
+      onServerRequest: (request) => this.respondToServerRequest(request),
+      onClose: (error) => this.handleSocketFailure(error),
     });
-    try {
-      const initialized = await this.request(
-        'initialize',
-        {
-          clientInfo: {
-            name: 'mcp-crossharness',
-            title: 'mcp-crossharness',
-            version: commitinfo.version,
-          },
-          capabilities: {
-            experimentalApi: false,
-            requestAttestation: false,
-          },
-        },
-        5000,
-        true,
-      );
-      if (!helpers.isRecord(initialized) || typeof initialized.userAgent !== 'string') {
-        throw new Error(
-          `Codex server returned an invalid initialize response (expected app-server ${appServerVersion})`,
-        );
-      }
-      this.serverVersion = initialized.userAgent.match(/\/(\d+\.\d+\.\d+[^\s]*)/)?.[1];
-      if (this.state !== 'connecting' || socket.readyState !== plugins.WsWebSocket.OPEN) {
-        throw new Error('Codex server connection closed during initialization');
-      }
-      this.sendNotification('initialized');
-      this.state = 'connected';
-    } catch (error) {
-      socket.terminate();
-      throw error;
+    this.client = client;
+    await client.connect();
+    if (this.state !== 'connecting' || client.state !== 'connected') {
+      throw new Error('Codex server connection closed during initialization');
     }
+    this.serverVersion = client.serverVersion;
+    this.state = 'connected';
   }
 
   public getInfo(): interfaces.IConnectionInfo {
@@ -418,7 +347,7 @@ export class CodexConnection implements interfaces.IHarnessConnection {
       this.onClosing?.();
       this.onClosing = undefined;
     }
-    await this.closeSocket();
+    this.client?.close(reasonArg);
     this.finishClosed();
   }
 
@@ -476,118 +405,13 @@ export class CodexConnection implements interfaces.IHarnessConnection {
     methodArg: string,
     paramsArg: unknown,
     timeoutMsArg = 30000,
-    allowConnectingArg = false,
+    _allowConnectingArg = false,
     signalArg?: AbortSignal,
   ): Promise<unknown> {
-    if (!allowConnectingArg && this.state !== 'connected') {
+    if (this.state !== 'connected' || !this.client) {
       return Promise.reject(new Error(`Codex connection ${this.connectionId} is ${this.state}`));
     }
-    const socket = this.socket;
-    if (!socket || socket.readyState !== plugins.WsWebSocket.OPEN) {
-      return Promise.reject(new Error('Codex server WebSocket is not open'));
-    }
-    if (this.pendingRequests.size >= 256) {
-      return Promise.reject(new Error('Codex connection has too many active requests'));
-    }
-    if (signalArg?.aborted) return Promise.reject(this.abortError(signalArg.reason));
-    return new Promise((resolve, reject) => {
-      const id = ++this.requestCounter;
-      const timer = setTimeout(() => {
-        const pending = this.pendingRequests.get(id);
-        if (!pending) return;
-        this.pendingRequests.delete(id);
-        this.clearPendingRequestResources(pending);
-        reject(new Error(`Codex request timed out: ${methodArg}`));
-      }, timeoutMsArg);
-      const pending: IPendingRequest = { resolve, reject, timer, signal: signalArg };
-      if (signalArg) {
-        pending.abortHandler = () => {
-          if (!this.pendingRequests.delete(id)) return;
-          this.clearPendingRequestResources(pending);
-          reject(this.abortError(signalArg.reason));
-        };
-        signalArg.addEventListener('abort', pending.abortHandler, { once: true });
-      }
-      this.pendingRequests.set(id, pending);
-      const failSend = (errorArg: Error) => {
-        const current = this.pendingRequests.get(id);
-        if (!current) return;
-        this.pendingRequests.delete(id);
-        this.clearPendingRequestResources(current);
-        current.reject(errorArg);
-      };
-      try {
-        this.sendFrame({ id, method: methodArg, params: paramsArg });
-      } catch (error) {
-        failSend(error instanceof Error ? error : new Error(String(error)));
-      }
-    });
-  }
-
-  private sendNotification(methodArg: string, paramsArg?: unknown): void {
-    this.sendFrame(
-      paramsArg === undefined
-        ? { method: methodArg }
-        : { method: methodArg, params: paramsArg },
-    );
-  }
-
-  private sendFrame(frameArg: Record<string, unknown>): void {
-    const socket = this.socket;
-    const payload = JSON.stringify(frameArg);
-    const payloadBytes = Buffer.byteLength(payload, 'utf8');
-    if (!socket || socket.readyState !== plugins.WsWebSocket.OPEN) {
-      const error = new Error('Codex server WebSocket is not open');
-      this.handleSocketFailure(error);
-      throw error;
-    }
-    if (socket.bufferedAmount + payloadBytes > maxSocketBufferedBytes) {
-      const error = new Error('Codex WebSocket send buffer exceeded the 4 MiB limit');
-      this.handleSocketFailure(error);
-      throw error;
-    }
-    try {
-      socket.send(payload, (error) => {
-        if (error) this.handleSocketFailure(error);
-      });
-    } catch (error) {
-      const sendError = error instanceof Error ? error : new Error(String(error));
-      this.handleSocketFailure(sendError);
-      throw sendError;
-    }
-  }
-
-  private handleMessage(rawArg: string): void {
-    const message = helpers.parseJson(rawArg);
-    if (!helpers.isRecord(message)) return;
-    if (message.id !== undefined && typeof message.method === 'string') {
-      this.respondToServerRequest(message);
-      return;
-    }
-    if (typeof message.id === 'number' && this.pendingRequests.has(message.id)) {
-      const pending = this.pendingRequests.get(message.id)!;
-      this.pendingRequests.delete(message.id);
-      this.clearPendingRequestResources(pending);
-      if (message.error !== undefined) {
-        pending.reject(
-          new Error(
-            `Codex server rejected request: ${JSON.stringify(message.error).slice(0, 4000)}`,
-          ),
-        );
-      } else {
-        pending.resolve(message.result);
-      }
-      return;
-    }
-    if (typeof message.method === 'string') {
-      if (!helpers.isRecord(message.params)) {
-        if (message.method === 'turn/completed') {
-          this.handleSocketFailure(new Error('Codex returned malformed turn/completed params'));
-        }
-        return;
-      }
-      this.handleNotification(message.method, message.params);
-    }
+    return this.client.request(methodArg, paramsArg, timeoutMsArg, signalArg);
   }
 
   private handleNotification(methodArg: string, paramsArg: Record<string, unknown>): void {
@@ -898,13 +722,6 @@ export class CodexConnection implements interfaces.IHarnessConnection {
     }
   }
 
-  private clearPendingRequestResources(pendingArg: IPendingRequest): void {
-    clearTimeout(pendingArg.timer);
-    if (pendingArg.abortHandler) {
-      pendingArg.signal?.removeEventListener('abort', pendingArg.abortHandler);
-    }
-  }
-
   private abortError(reasonArg: unknown): Error {
     return reasonArg instanceof Error ? reasonArg : new Error('operation cancelled');
   }
@@ -1002,7 +819,7 @@ export class CodexConnection implements interfaces.IHarnessConnection {
     return true;
   }
 
-  private respondToServerRequest(messageArg: Record<string, unknown>): void {
+  private respondToServerRequest(messageArg: { id: string | number; method: string; params: Record<string, unknown> }): void {
     const method = String(messageArg.method);
     let result: unknown;
     switch (method) {
@@ -1025,15 +842,12 @@ export class CodexConnection implements interfaces.IHarnessConnection {
         break;
       default:
         try {
-          this.sendFrame({
-            id: messageArg.id,
-            error: { code: -32601, message: `Crossharness does not implement ${method}` },
-          });
+          this.client?.rejectRequest(messageArg.id, -32601, `Crossharness does not implement ${method}`);
         } catch {}
         return;
     }
     try {
-      this.sendFrame({ id: messageArg.id, result });
+      this.client?.respond(messageArg.id, result);
     } catch {}
   }
 
@@ -1045,21 +859,7 @@ export class CodexConnection implements interfaces.IHarnessConnection {
       this.onClosing?.();
       this.onClosing = undefined;
     }
-    const socket = this.socket;
-    if (socket && socket.readyState !== plugins.WsWebSocket.CLOSED) {
-      socket.terminate();
-    } else {
-      this.finishClosed();
-    }
-  }
-
-  private handleSocketClose(): void {
-    if (this.state !== 'closing' && this.state !== 'closed') {
-      this.state = 'closing';
-      this.rejectAll(new Error('Codex server connection closed'));
-      this.onClosing?.();
-      this.onClosing = undefined;
-    }
+    this.client?.close(errorArg.message);
     this.finishClosed();
   }
 
@@ -1072,11 +872,6 @@ export class CodexConnection implements interfaces.IHarnessConnection {
   }
 
   private rejectAll(errorArg: Error): void {
-    for (const pending of this.pendingRequests.values()) {
-      this.clearPendingRequestResources(pending);
-      pending.reject(errorArg);
-    }
-    this.pendingRequests.clear();
     for (const turn of [...this.pendingTurns]) this.failTurn(turn, errorArg);
     for (const [threadId, queue] of this.threadQueues) {
       const activeOffset = this.activeThreads.has(threadId) ? 1 : 0;
@@ -1088,33 +883,4 @@ export class CodexConnection implements interfaces.IHarnessConnection {
     this.threadQueues.clear();
   }
 
-  private async closeSocket(): Promise<void> {
-    const socket = this.socket;
-    if (!socket || socket.readyState === plugins.WsWebSocket.CLOSED) return;
-    await new Promise<void>((resolve) => {
-      let settled = false;
-      const finish = () => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
-        socket.off('close', finish);
-        resolve();
-      };
-      const timer = setTimeout(() => {
-        socket.terminate();
-        finish();
-      }, 1000);
-      socket.once('close', finish);
-      try {
-        if (socket.readyState === plugins.WsWebSocket.CONNECTING) {
-          socket.terminate();
-        } else {
-          socket.close();
-        }
-      } catch {
-        socket.terminate();
-        finish();
-      }
-    });
-  }
 }