@modelprofile.com/mcp-crossharness 5.1.0 → 5.3.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@modelprofile.com/mcp-crossharness',
-    version: '5.1.0',
+    version: '5.3.0',
     description: 'Connection-first MCP server for explicit OpenCode HTTP and Codex WebSocket session servers'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxvQ0FBb0M7SUFDMUMsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLDRGQUE0RjtDQUMxRyxDQUFBIn0=

package/dist_ts/classes.codexappserverclient.d.ts

@@ -0,0 +1,75 @@
+import * as plugins from './plugins.js';
+export type TCodexAppServerRequestId = string | number;
+export interface ICodexAppServerNotification {
+    method: string;
+    params: Record<string, unknown>;
+}
+export interface ICodexAppServerRequest extends ICodexAppServerNotification {
+    id: TCodexAppServerRequestId;
+    signal: AbortSignal;
+}
+export type TCodexAppServerTransport = {
+    type: 'websocket';
+    url: string;
+    token?: string;
+} | {
+    type: 'stdio';
+    readable: plugins.stream.Readable;
+    writable: plugins.stream.Writable;
+};
+export interface ICodexAppServerClientOptions {
+    transport: TCodexAppServerTransport;
+    clientInfo: {
+        name: string;
+        title: string;
+        version: string;
+    };
+    experimentalApi?: boolean;
+    /** Defaults to 4 MiB; consumers of paginated native histories may opt into up to 64 MiB. */
+    maxMessageBytes?: number;
+    /** WebSocket handshake deadline, 1–120,000 ms. Defaults to 5,000 ms. */
+    handshakeTimeoutMs?: number;
+    /** Native initialize deadline, 1–120,000 ms. Defaults to 5,000 ms. */
+    initializeTimeoutMs?: number;
+    onNotification?: (notificationArg: ICodexAppServerNotification) => void;
+    /** Replies use respond()/rejectRequest(); IDs are valid only on this connection. */
+    onServerRequest?: (requestArg: ICodexAppServerRequest) => void;
+    onClose?: (errorArg: Error) => void;
+}
+/** A request failure is not evidence that a dispatched mutation did not execute. */
+export declare class CodexAppServerRequestError extends Error {
+    readonly dispatched: boolean;
+    readonly code?: number | undefined;
+    constructor(messageArg: string, dispatched: boolean, code?: number | undefined, optionsArg?: ErrorOptions);
+}
+/** Connection-scoped app-server protocol client. Process and approval policy belong to the caller. */
+export declare class CodexAppServerClient {
+    private readonly options;
+    state: 'connecting' | 'connected' | 'closed';
+    serverVersion?: string;
+    private socket?;
+    private started;
+    private requestCounter;
+    private readonly pendingRequests;
+    private readonly serverRequests;
+    private readonly maxMessageBytes;
+    private inputBuffer;
+    private readonly maxBufferedBytes;
+    constructor(options: ICodexAppServerClientOptions);
+    connect(): Promise<void>;
+    request(methodArg: string, paramsArg: unknown, timeoutMsArg?: number, signalArg?: AbortSignal): Promise<unknown>;
+    private sendRequest;
+    respond(idArg: TCodexAppServerRequestId, resultArg: unknown): boolean;
+    rejectRequest(idArg: TCodexAppServerRequestId, codeArg: number, messageArg: string): boolean;
+    close(reasonArg?: string): void;
+    private readonly handleError;
+    private readonly handleEnd;
+    private readonly handleData;
+    private sendFrame;
+    private receive;
+    private takePending;
+    private rejectPending;
+    private finishServerRequest;
+    private assertOpen;
+    private cancellationError;
+}

package/dist_ts/classes.codexappserverclient.js

@@ -0,0 +1,304 @@
+import * as plugins from './plugins.js';
+import * as helpers from './helpers.js';
+/** A request failure is not evidence that a dispatched mutation did not execute. */
+export class CodexAppServerRequestError extends Error {
+    dispatched;
+    code;
+    constructor(messageArg, dispatched, code, optionsArg) {
+        super(messageArg, optionsArg);
+        this.dispatched = dispatched;
+        this.code = code;
+        this.name = 'CodexAppServerRequestError';
+    }
+}
+/** Connection-scoped app-server protocol client. Process and approval policy belong to the caller. */
+export class CodexAppServerClient {
+    options;
+    state = 'connecting';
+    serverVersion;
+    socket;
+    started = false;
+    requestCounter = 0;
+    pendingRequests = new Map();
+    serverRequests = new Map();
+    maxMessageBytes;
+    inputBuffer = Buffer.alloc(0);
+    maxBufferedBytes = 4 * 1024 * 1024;
+    constructor(options) {
+        this.options = options;
+        this.maxMessageBytes = options.maxMessageBytes ?? 4 * 1024 * 1024;
+        if (!Number.isSafeInteger(this.maxMessageBytes)
+            || this.maxMessageBytes < 1024 || this.maxMessageBytes > 64 * 1024 * 1024) {
+            throw new Error('Codex maxMessageBytes must be between 1 KiB and 64 MiB');
+        }
+        for (const name of ['handshakeTimeoutMs', 'initializeTimeoutMs']) {
+            const value = options[name];
+            if (value !== undefined && (!Number.isSafeInteger(value) || value < 1 || value > 120_000)) {
+                throw new Error(`Codex ${name} must be an integer between 1 and 120000 ms`);
+            }
+        }
+        if (options.transport.type === 'websocket') {
+            const url = new URL(options.transport.url);
+            if (!['ws:', 'wss:'].includes(url.protocol) || url.username || url.password || url.hash) {
+                throw new Error('Codex app-server requires an explicit ws/wss URL without credentials or fragment');
+            }
+        }
+    }
+    async connect() {
+        if (this.started || this.state === 'closed')
+            throw new Error('Codex client has already been started');
+        this.started = true;
+        try {
+            const transport = this.options.transport;
+            if (transport.type === 'websocket') {
+                const socket = new plugins.WsWebSocket(transport.url, {
+                    perMessageDeflate: false,
+                    followRedirects: false,
+                    maxPayload: this.maxMessageBytes,
+                    headers: transport.token ? { authorization: `Bearer ${transport.token}` } : {},
+                });
+                this.socket = socket;
+                socket.on('message', (data) => this.receive(data.toString()));
+                socket.on('error', this.handleError);
+                socket.on('close', this.handleEnd);
+                await new Promise((resolve, reject) => {
+                    const cleanup = () => {
+                        clearTimeout(timer);
+                        socket.off('open', opened);
+                        socket.off('error', failed);
+                        socket.off('close', closed);
+                    };
+                    const opened = () => { cleanup(); resolve(); };
+                    const failed = (errorArg) => { cleanup(); reject(errorArg); };
+                    const closed = () => failed(new Error('Codex server WebSocket closed during handshake'));
+                    const timer = setTimeout(() => failed(new Error('Codex server WebSocket handshake timed out')), this.options.handshakeTimeoutMs ?? 5000);
+                    socket.once('open', opened);
+                    socket.once('error', failed);
+                    socket.once('close', closed);
+                });
+            }
+            else {
+                if (transport.readable.destroyed || transport.writable.destroyed || transport.writable.writableEnded) {
+                    throw new Error('Codex app-server streams are closed');
+                }
+                transport.readable.on('data', this.handleData);
+                transport.readable.on('error', this.handleError);
+                transport.readable.on('end', this.handleEnd);
+                transport.readable.on('close', this.handleEnd);
+                transport.writable.on('error', this.handleError);
+                transport.writable.on('close', this.handleEnd);
+            }
+            const initialized = await this.sendRequest('initialize', {
+                clientInfo: this.options.clientInfo,
+                capabilities: { experimentalApi: this.options.experimentalApi ?? false, requestAttestation: false },
+            }, this.options.initializeTimeoutMs ?? 5000, undefined, true);
+            if (!helpers.isRecord(initialized) || typeof initialized.userAgent !== 'string') {
+                throw new Error('Codex server returned an invalid initialize response');
+            }
+            this.serverVersion = initialized.userAgent.match(/\/(\d+\.\d+\.\d+[^\s]*)/)?.[1];
+            this.sendFrame({ method: 'initialized' });
+            this.assertOpen();
+            this.state = 'connected';
+        }
+        catch (error) {
+            this.close(helpers.errorMessage(error));
+            throw error;
+        }
+    }
+    request(methodArg, paramsArg, timeoutMsArg = 30000, signalArg) {
+        return this.sendRequest(methodArg, paramsArg, timeoutMsArg, signalArg);
+    }
+    sendRequest(methodArg, paramsArg, timeoutMsArg, signalArg, allowInitializingArg = false) {
+        if ((!allowInitializingArg && this.state !== 'connected') || this.state === 'closed') {
+            return Promise.reject(new CodexAppServerRequestError('Codex client is not connected', false));
+        }
+        if (this.pendingRequests.size >= 256) {
+            return Promise.reject(new CodexAppServerRequestError('Codex connection has too many active requests', false));
+        }
+        if (!Number.isFinite(timeoutMsArg) || timeoutMsArg <= 0 || timeoutMsArg > 2_147_483_647) {
+            return Promise.reject(new CodexAppServerRequestError('Codex request timeout is invalid', false));
+        }
+        if (signalArg?.aborted)
+            return Promise.reject(this.cancellationError(signalArg, false));
+        return new Promise((resolve, reject) => {
+            const id = ++this.requestCounter;
+            const timer = setTimeout(() => this.rejectPending(id, new CodexAppServerRequestError(`Codex request timed out: ${methodArg}`, true)), timeoutMsArg);
+            const pending = { resolve, reject, timer, signal: signalArg };
+            if (signalArg) {
+                pending.abortHandler = () => this.rejectPending(id, this.cancellationError(signalArg, true));
+                signalArg.addEventListener('abort', pending.abortHandler, { once: true });
+            }
+            this.pendingRequests.set(id, pending);
+            try {
+                this.sendFrame({ id, method: methodArg, params: paramsArg });
+            }
+            catch (error) {
+                this.rejectPending(id, new CodexAppServerRequestError(helpers.errorMessage(error), false, undefined, { cause: error }));
+            }
+        });
+    }
+    respond(idArg, resultArg) {
+        if (!this.finishServerRequest(idArg) || this.state === 'closed')
+            return false;
+        this.sendFrame({ id: idArg, result: resultArg });
+        return true;
+    }
+    rejectRequest(idArg, codeArg, messageArg) {
+        if (!this.finishServerRequest(idArg) || this.state === 'closed')
+            return false;
+        this.sendFrame({ id: idArg, error: { code: codeArg, message: messageArg } });
+        return true;
+    }
+    close(reasonArg = 'Codex server connection closed') {
+        if (this.state === 'closed')
+            return;
+        this.state = 'closed';
+        const error = new CodexAppServerRequestError(reasonArg, true);
+        for (const id of this.pendingRequests.keys())
+            this.rejectPending(id, error);
+        for (const id of this.serverRequests.keys())
+            this.finishServerRequest(id);
+        this.inputBuffer = Buffer.alloc(0);
+        const transport = this.options.transport;
+        if (transport.type === 'websocket') {
+            if (this.socket && this.socket.readyState !== plugins.WsWebSocket.CLOSED)
+                this.socket.terminate();
+        }
+        else {
+            transport.readable.off('data', this.handleData);
+            transport.readable.off('end', this.handleEnd);
+            transport.readable.off('close', this.handleEnd);
+            transport.writable.off('close', this.handleEnd);
+            // End only these caller-supplied streams; the caller owns the subprocess.
+            transport.writable.end();
+            transport.readable.destroy();
+        }
+        this.options.onClose?.(error);
+    }
+    handleError = (errorArg) => { this.close(errorArg.message); };
+    handleEnd = () => { this.close('Codex server connection closed'); };
+    handleData = (dataArg) => {
+        const data = Buffer.isBuffer(dataArg) ? dataArg : Buffer.from(dataArg);
+        let offset = 0;
+        while (offset < data.length && this.state !== 'closed') {
+            const newline = data.indexOf(10, offset);
+            const end = newline < 0 ? data.length : newline;
+            if (this.inputBuffer.length + end - offset > this.maxMessageBytes) {
+                this.close('Codex app-server frame exceeded the response limit');
+                return;
+            }
+            this.inputBuffer = Buffer.concat([this.inputBuffer, data.subarray(offset, end)]);
+            if (newline < 0)
+                break;
+            const raw = this.inputBuffer.toString('utf8');
+            this.inputBuffer = Buffer.alloc(0);
+            if (raw.trim())
+                this.receive(raw);
+            offset = newline + 1;
+        }
+    };
+    sendFrame(frameArg) {
+        const payload = JSON.stringify(frameArg);
+        const payloadBytes = Buffer.byteLength(payload, 'utf8');
+        const transport = this.options.transport;
+        const buffered = transport.type === 'websocket'
+            ? this.socket?.bufferedAmount ?? 0 : transport.writable.writableLength;
+        if (this.state === 'closed')
+            throw new Error('Codex server connection is closed');
+        if (buffered + payloadBytes + 1 > this.maxBufferedBytes) {
+            const error = new Error('Codex send buffer exceeded the 4 MiB limit');
+            this.close(error.message);
+            throw error;
+        }
+        if (transport.type === 'websocket') {
+            if (!this.socket || this.socket.readyState !== plugins.WsWebSocket.OPEN) {
+                throw new Error('Codex server WebSocket is not open');
+            }
+            this.socket.send(payload, (error) => { if (error)
+                this.handleError(error); });
+        }
+        else {
+            if (transport.writable.destroyed || transport.writable.writableEnded)
+                throw new Error('Codex server input is closed');
+            transport.writable.write(`${payload}\n`, (error) => { if (error)
+                this.handleError(error); });
+        }
+    }
+    receive(rawArg) {
+        if (this.state === 'closed')
+            return;
+        try {
+            const message = JSON.parse(rawArg);
+            if (!helpers.isRecord(message))
+                throw new Error('Codex server returned a malformed frame');
+            if (typeof message.method === 'string') {
+                const params = message.params ?? {};
+                if (!helpers.isRecord(params))
+                    throw new Error(`Codex returned malformed ${message.method} params`);
+                if (message.id !== undefined) {
+                    if ((typeof message.id !== 'string' && typeof message.id !== 'number')
+                        || this.serverRequests.has(message.id) || this.serverRequests.size >= 256) {
+                        throw new Error('Codex server request identity or capacity is invalid');
+                    }
+                    const controller = new AbortController();
+                    this.serverRequests.set(message.id, controller);
+                    if (this.options.onServerRequest)
+                        this.options.onServerRequest({ id: message.id, method: message.method, params, signal: controller.signal });
+                    else
+                        this.rejectRequest(message.id, -32601, `Client does not implement ${message.method}`);
+                }
+                else {
+                    if (message.method === 'serverRequest/resolved'
+                        && (typeof params.requestId === 'number' || typeof params.requestId === 'string')) {
+                        this.finishServerRequest(params.requestId);
+                    }
+                    this.options.onNotification?.({ method: message.method, params });
+                }
+                return;
+            }
+            if (typeof message.id !== 'number')
+                return;
+            const pending = this.takePending(message.id);
+            if (!pending)
+                return;
+            if (message.error !== undefined) {
+                const code = helpers.isRecord(message.error) && typeof message.error.code === 'number' ? message.error.code : undefined;
+                pending.reject(new CodexAppServerRequestError(`Codex server rejected request: ${JSON.stringify(message.error).slice(0, 4000)}`, true, code));
+            }
+            else
+                pending.resolve(message.result);
+        }
+        catch (error) {
+            this.close(helpers.errorMessage(error));
+        }
+    }
+    takePending(idArg) {
+        const pending = this.pendingRequests.get(idArg);
+        if (!pending)
+            return undefined;
+        this.pendingRequests.delete(idArg);
+        clearTimeout(pending.timer);
+        if (pending.abortHandler)
+            pending.signal?.removeEventListener('abort', pending.abortHandler);
+        return pending;
+    }
+    rejectPending(idArg, errorArg) {
+        this.takePending(idArg)?.reject(errorArg);
+    }
+    finishServerRequest(idArg) {
+        const controller = this.serverRequests.get(idArg);
+        if (!controller)
+            return false;
+        this.serverRequests.delete(idArg);
+        controller.abort();
+        return true;
+    }
+    assertOpen() {
+        if (this.state === 'closed')
+            throw new Error('Codex server connection is closed');
+    }
+    cancellationError(signalArg, dispatchedArg) {
+        return new CodexAppServerRequestError(signalArg.reason instanceof Error ? signalArg.reason.message : 'operation cancelled', dispatchedArg, undefined, { cause: signalArg.reason });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.codexappserverclient.js","sourceRoot":"","sources":["../ts/classes.codexappserverclient.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.connection.codex.d.ts

@@ -9,9 +9,7 @@ export declare class CodexConnection implements interfaces.IHarnessConnection {
     state: interfaces.TConnectionState;
     private connectedAt;
     private serverVersion;
-    private socket;
-    private requestCounter;
-    private pendingRequests;
+    private client?;
     private pendingTurns;
     private threadQueues;
     private activeThreads;
@@ -32,9 +30,6 @@ export declare class CodexConnection implements interfaces.IHarnessConnection {
     private parseThread;
     private assertThreadIdentity;
     private request;
-    private sendNotification;
-    private sendFrame;
-    private handleMessage;
     private handleNotification;
     private handleTurnNotification;
     private bindTurnId;
@@ -49,7 +44,6 @@ export declare class CodexConnection implements interfaces.IHarnessConnection {
     private appendTurnDelta;
     private remainingSendMs;
     private clearQueueEntryResources;
-    private clearPendingRequestResources;
     private abortError;
     private assertChatId;
     private bufferEarlyNotification;
@@ -59,8 +53,6 @@ export declare class CodexConnection implements interfaces.IHarnessConnection {
     private settleTurn;
     private respondToServerRequest;
     private handleSocketFailure;
-    private handleSocketClose;
     private finishClosed;
     private rejectAll;
-    private closeSocket;
 }