@modelprofile.com/mcp-crossharness 5.0.0

package/dist_ts/classes.connectionregistry.js

@@ -0,0 +1,246 @@
+import * as plugins from './plugins.js';
+import { OpencodeConnection } from './classes.connection.opencode.js';
+import { CodexConnection } from './classes.connection.codex.js';
+export class ConnectionRegistry {
+    connections = new Map();
+    connecting = new Map();
+    closingConnections = new Map();
+    allowedServerUrls;
+    maxConnections;
+    openCodeCredentials;
+    closing = false;
+    closingTasks = new Map();
+    shutdownPromise;
+    constructor(optionsArg = {}) {
+        const configured = optionsArg.allowedServerUrls ??
+            (process.env.CROSSHARNESS_ALLOWED_SERVER_URLS ?? '')
+                .split(',')
+                .map((entry) => entry.trim())
+                .filter(Boolean);
+        this.allowedServerUrls = new Set(configured.map((entry) => this.normalizeUrl(entry).toString()));
+        this.maxConnections = optionsArg.maxConnections ?? 32;
+        if (!Number.isInteger(this.maxConnections) || this.maxConnections < 1) {
+            throw new Error('maxConnections must be a positive integer');
+        }
+        if (optionsArg.openCodeCredentials) {
+            const { serverUrl, username, password } = optionsArg.openCodeCredentials;
+            const credentialUrl = this.normalizeUrl(serverUrl);
+            if (serverUrl.length > 2048
+                || serverUrl.includes('?')
+                || serverUrl.includes('#')
+                || credentialUrl.username
+                || credentialUrl.password
+                || credentialUrl.search
+                || credentialUrl.hash
+                || credentialUrl.pathname !== '/'
+                || !['http:', 'https:'].includes(credentialUrl.protocol)
+                || !this.allowedServerUrls.has(credentialUrl.toString())
+                || (credentialUrl.protocol === 'http:'
+                    && !['127.0.0.1', '[::1]', '::1', 'localhost'].includes(credentialUrl.hostname))
+                || typeof password !== 'string'
+                || password.length === 0
+                || Buffer.byteLength(password, 'utf8') > 1024
+                || password.includes('\r')
+                || password.includes('\n')
+                || (username !== undefined && (typeof username !== 'string'
+                    || username.length === 0
+                    || Buffer.byteLength(username, 'utf8') > 1024
+                    || username.includes('\r')
+                    || username.includes('\n'))))
+                throw new Error('openCodeCredentials are invalid');
+            this.openCodeCredentials = {
+                serverUrl: credentialUrl.toString(),
+                password,
+                ...(username === undefined ? {} : { username }),
+            };
+        }
+    }
+    async connect(harnessArg, serverUrlArg, directoryArg, signalArg) {
+        if (signalArg?.aborted)
+            throw this.abortError(signalArg.reason);
+        if (this.closing) {
+            throw new Error('connection registry is closing');
+        }
+        if (harnessArg === 'claudecode') {
+            throw new Error('Claude Code 2.1.219 exposes no URL-addressable session server; connection-first Crossharness cannot connect to it');
+        }
+        if (!directoryArg.startsWith('/')) {
+            throw new Error('connection directory must be an absolute path on the harness server');
+        }
+        if (directoryArg.length > 4096) {
+            throw new Error('connection directory exceeds 4096 characters');
+        }
+        if (serverUrlArg.length > 2048) {
+            throw new Error('server URL exceeds 2048 characters');
+        }
+        const url = this.validateAllowedUrl(harnessArg, serverUrlArg);
+        if (this.connections.size + this.connecting.size + this.closingConnections.size >=
+            this.maxConnections) {
+            throw new Error(`connection registry is full (maximum ${this.maxConnections})`);
+        }
+        const duplicate = [
+            ...this.connections.values(),
+            ...this.connecting.values(),
+            ...this.closingConnections.values(),
+        ].find((connection) => connection.harness === harnessArg &&
+            connection.serverUrl === url.toString() &&
+            connection.directory === directoryArg);
+        if (duplicate) {
+            throw new Error(`a ${harnessArg} connection already exists for ${url.toString()} and ${directoryArg}`);
+        }
+        const connectionId = `c-${plugins.crypto.randomBytes(8).toString('hex')}`;
+        const markClosingConnection = () => {
+            this.connections.delete(connectionId);
+            this.connecting.delete(connectionId);
+            this.closingConnections.set(connectionId, connection);
+        };
+        const removeClosedConnection = () => {
+            this.connections.delete(connectionId);
+            this.connecting.delete(connectionId);
+            this.closingConnections.delete(connectionId);
+        };
+        const connection = harnessArg === 'opencode'
+            ? new OpencodeConnection(connectionId, url.toString(), directoryArg, markClosingConnection, removeClosedConnection, this.openCodeCredentials?.serverUrl === url.toString()
+                ? this.openCodeCredentials
+                : undefined)
+            : new CodexConnection(connectionId, url.toString(), directoryArg, markClosingConnection, removeClosedConnection);
+        this.connecting.set(connectionId, connection);
+        let abortCleanupTask;
+        const abortHandler = signalArg
+            ? () => {
+                abortCleanupTask ??= this.closeConnection(connection, this.abortError(signalArg.reason).message);
+                void abortCleanupTask.catch(() => undefined);
+            }
+            : undefined;
+        if (abortHandler)
+            signalArg.addEventListener('abort', abortHandler, { once: true });
+        try {
+            await connection.connect();
+            if (signalArg?.aborted)
+                throw this.abortError(signalArg.reason);
+            if (this.closing) {
+                throw new Error('connection registry closed during setup');
+            }
+            this.connections.set(connectionId, connection);
+            return connection.getInfo();
+        }
+        catch (errorArg) {
+            const operationError = signalArg?.aborted ? this.abortError(signalArg.reason) : errorArg;
+            try {
+                await (abortCleanupTask ?? this.closeConnection(connection, 'connection setup failed'));
+            }
+            catch (cleanupErrorArg) {
+                throw new AggregateError([operationError, cleanupErrorArg], 'Connection setup failed and cleanup is incomplete.');
+            }
+            throw operationError;
+        }
+        finally {
+            if (abortHandler)
+                signalArg.removeEventListener('abort', abortHandler);
+            this.connecting.delete(connectionId);
+        }
+    }
+    get(connectionIdArg) {
+        const connection = this.connections.get(connectionIdArg);
+        if (!connection) {
+            throw new Error(`unknown connectionId ${connectionIdArg}`);
+        }
+        return connection;
+    }
+    list() {
+        return [...this.connections.values()].map((connection) => connection.getInfo());
+    }
+    async disconnect(connectionIdArg) {
+        const connection = this.connections.get(connectionIdArg)
+            ?? this.closingConnections.get(connectionIdArg);
+        if (!connection)
+            throw new Error(`unknown connectionId ${connectionIdArg}`);
+        await this.closeConnection(connection, 'connection explicitly disconnected');
+        return connection.getInfo();
+    }
+    async closeAll() {
+        if (this.shutdownPromise)
+            return this.shutdownPromise;
+        this.closing = true;
+        const connections = [
+            ...new Set([
+                ...this.connections.values(),
+                ...this.connecting.values(),
+                ...this.closingConnections.values(),
+            ]),
+        ];
+        const shutdownPromise = Promise.allSettled(connections.map((connection) => this.closeConnection(connection, 'Crossharness MCP transport closed'))).then((results) => {
+            const errors = results.flatMap((result) => (result.status === 'rejected' ? [result.reason] : []));
+            if (errors.length === 1)
+                throw errors[0];
+            if (errors.length > 1) {
+                throw new AggregateError(errors, 'Closing Crossharness connections failed.');
+            }
+        });
+        this.shutdownPromise = shutdownPromise;
+        try {
+            await shutdownPromise;
+        }
+        finally {
+            if (this.shutdownPromise === shutdownPromise)
+                this.shutdownPromise = undefined;
+        }
+    }
+    closeConnection(connectionArg, reasonArg) {
+        const connectionId = connectionArg.connectionId;
+        const existing = this.closingTasks.get(connectionId);
+        if (existing)
+            return existing;
+        this.connections.delete(connectionId);
+        this.connecting.delete(connectionId);
+        this.closingConnections.set(connectionId, connectionArg);
+        let task;
+        task = Promise.resolve().then(() => connectionArg.close(reasonArg)).then(() => {
+            if (this.closingConnections.get(connectionId) === connectionArg) {
+                this.closingConnections.delete(connectionId);
+            }
+        }, (errorArg) => {
+            this.connections.delete(connectionId);
+            this.connecting.delete(connectionId);
+            this.closingConnections.set(connectionId, connectionArg);
+            throw errorArg;
+        }).finally(() => {
+            if (this.closingTasks.get(connectionId) === task)
+                this.closingTasks.delete(connectionId);
+        });
+        this.closingTasks.set(connectionId, task);
+        return task;
+    }
+    validateAllowedUrl(harnessArg, valueArg) {
+        const url = this.normalizeUrl(valueArg);
+        if (url.username || url.password || url.search || url.hash) {
+            throw new Error('server URL must not contain credentials, query parameters, or a fragment');
+        }
+        if (url.pathname !== '/') {
+            throw new Error('server URL must be an origin with no path');
+        }
+        const protocols = harnessArg === 'opencode' ? ['http:', 'https:'] : ['ws:', 'wss:'];
+        if (!protocols.includes(url.protocol)) {
+            throw new Error(`${harnessArg} server URL must use ${protocols.join(' or ')}`);
+        }
+        if (!this.allowedServerUrls.has(url.toString())) {
+            throw new Error(`server URL ${url.toString()} is not in CROSSHARNESS_ALLOWED_SERVER_URLS`);
+        }
+        return url;
+    }
+    normalizeUrl(valueArg) {
+        let url;
+        try {
+            url = new URL(valueArg);
+        }
+        catch {
+            throw new Error(`invalid server URL: ${valueArg}`);
+        }
+        url.pathname = url.pathname || '/';
+        return url;
+    }
+    abortError(reasonArg) {
+        return reasonArg instanceof Error ? reasonArg : new Error('connection cancelled');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.connectionregistry.js","sourceRoot":"","sources":["../ts/classes.connectionregistry.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.dispatchregistry.d.ts

@@ -0,0 +1,39 @@
+import type * as interfaces from './interfaces.js';
+export type TDispatchStatus = 'working' | 'completed' | 'failed';
+export interface IDispatchRecord {
+    dispatchId: string;
+    connectionId: string;
+    harness: interfaces.THarnessName;
+    chatId: string;
+    startedAt: string;
+    completedAt?: string;
+    status: TDispatchStatus;
+    reply?: string;
+    via?: string;
+    error?: string;
+}
+export interface IDispatchRegistryOptions {
+    maxRecords?: number;
+    completedTtlMs?: number;
+}
+export declare class DispatchRegistry {
+    private options;
+    private records;
+    private expiryTimers;
+    private waiters;
+    private waiterCount;
+    private counter;
+    private instancePrefix;
+    private disposed;
+    constructor(options?: IDispatchRegistryOptions);
+    track(connectionIdArg: string, harnessArg: interfaces.THarnessName, chatIdArg: string, sendFactoryArg: () => Promise<interfaces.ISendResult>): IDispatchRecord;
+    get(connectionIdArg: string, dispatchIdArg: string): IDispatchRecord | undefined;
+    waitFor(connectionIdArg: string, dispatchIdArg: string, waitMsArg: number, signalArg?: AbortSignal): Promise<IDispatchRecord | undefined>;
+    dispose(): void;
+    private prune;
+    private scheduleExpiry;
+    private reserveCapacity;
+    private forget;
+    private notifyWaiters;
+    private removeWaiter;
+}

package/dist_ts/classes.dispatchregistry.js

@@ -0,0 +1,177 @@
+export class DispatchRegistry {
+    options;
+    records = new Map();
+    expiryTimers = new Map();
+    waiters = new Map();
+    waiterCount = 0;
+    counter = 0;
+    instancePrefix = Math.random().toString(36).slice(2, 7);
+    disposed = false;
+    constructor(options = {}) {
+        this.options = options;
+        if (!Number.isInteger(options.maxRecords ?? 100) || (options.maxRecords ?? 100) < 1) {
+            throw new Error('dispatch maxRecords must be a positive integer');
+        }
+        if ((options.completedTtlMs ?? 2 * 60 * 60 * 1000) < 0) {
+            throw new Error('dispatch completedTtlMs must not be negative');
+        }
+    }
+    track(connectionIdArg, harnessArg, chatIdArg, sendFactoryArg) {
+        if (this.disposed)
+            throw new Error('dispatch registry is closed');
+        this.reserveCapacity();
+        const record = {
+            dispatchId: `d-${this.instancePrefix}-${++this.counter}`,
+            connectionId: connectionIdArg,
+            harness: harnessArg,
+            chatId: chatIdArg,
+            startedAt: new Date().toISOString(),
+            status: 'working',
+        };
+        this.records.set(record.dispatchId, record);
+        Promise.resolve().then(sendFactoryArg).then((result) => {
+            if (this.disposed || record.status !== 'working')
+                return;
+            record.status = 'completed';
+            record.completedAt = new Date().toISOString();
+            record.reply = result.reply.slice(0, 100000);
+            record.via = result.via;
+            this.notifyWaiters(record.dispatchId, record);
+            this.scheduleExpiry(record.dispatchId);
+            this.prune();
+        }, (error) => {
+            if (this.disposed || record.status !== 'working')
+                return;
+            record.status = 'failed';
+            record.completedAt = new Date().toISOString();
+            record.error = (error instanceof Error ? error.message : String(error)).slice(0, 4000);
+            this.notifyWaiters(record.dispatchId, record);
+            this.scheduleExpiry(record.dispatchId);
+            this.prune();
+        });
+        return record;
+    }
+    get(connectionIdArg, dispatchIdArg) {
+        this.prune();
+        const record = this.records.get(dispatchIdArg);
+        return record?.connectionId === connectionIdArg ? record : undefined;
+    }
+    async waitFor(connectionIdArg, dispatchIdArg, waitMsArg, signalArg) {
+        const deadline = Date.now() + waitMsArg;
+        const record = this.get(connectionIdArg, dispatchIdArg);
+        if (!record || record.status !== 'working' || waitMsArg <= 0)
+            return record;
+        if (signalArg?.aborted)
+            return record;
+        if (this.waiterCount >= 1000)
+            return record;
+        return new Promise((resolve) => {
+            const waiter = {
+                resolve,
+                timer: setTimeout(() => {
+                    this.removeWaiter(dispatchIdArg, waiter);
+                    resolve(this.get(connectionIdArg, dispatchIdArg));
+                }, Math.max(0, deadline - Date.now())),
+                signal: signalArg,
+            };
+            if (signalArg) {
+                waiter.abortHandler = () => {
+                    this.removeWaiter(dispatchIdArg, waiter);
+                    resolve(this.get(connectionIdArg, dispatchIdArg));
+                };
+                signalArg.addEventListener('abort', waiter.abortHandler, { once: true });
+            }
+            const dispatchWaiters = this.waiters.get(dispatchIdArg) ?? new Set();
+            dispatchWaiters.add(waiter);
+            this.waiterCount++;
+            this.waiters.set(dispatchIdArg, dispatchWaiters);
+            const current = this.get(connectionIdArg, dispatchIdArg);
+            if (!current || current.status !== 'working') {
+                this.notifyWaiters(dispatchIdArg, current);
+            }
+        });
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        for (const timer of this.expiryTimers.values())
+            clearTimeout(timer);
+        this.expiryTimers.clear();
+        for (const dispatchId of [...this.waiters.keys()]) {
+            this.notifyWaiters(dispatchId, undefined);
+        }
+        this.records.clear();
+    }
+    prune() {
+        const completedTtlMs = this.options.completedTtlMs ?? 2 * 60 * 60 * 1000;
+        const now = Date.now();
+        for (const [dispatchId, record] of this.records) {
+            if (record.status !== 'working' &&
+                record.completedAt &&
+                now - Date.parse(record.completedAt) > completedTtlMs) {
+                this.forget(dispatchId);
+            }
+        }
+    }
+    scheduleExpiry(dispatchIdArg) {
+        const existingTimer = this.expiryTimers.get(dispatchIdArg);
+        if (existingTimer)
+            clearTimeout(existingTimer);
+        const timer = setTimeout(() => {
+            this.expiryTimers.delete(dispatchIdArg);
+            this.records.delete(dispatchIdArg);
+        }, this.options.completedTtlMs ?? 2 * 60 * 60 * 1000);
+        this.expiryTimers.set(dispatchIdArg, timer);
+        timer.unref();
+    }
+    reserveCapacity() {
+        this.prune();
+        const maxRecords = this.options.maxRecords ?? 100;
+        for (const [dispatchId, record] of this.records) {
+            if (this.records.size < maxRecords)
+                break;
+            if (record.status !== 'working')
+                this.forget(dispatchId);
+        }
+        if (this.records.size >= maxRecords) {
+            throw new Error('dispatch registry is full of active sends');
+        }
+    }
+    forget(dispatchIdArg) {
+        this.records.delete(dispatchIdArg);
+        const timer = this.expiryTimers.get(dispatchIdArg);
+        if (timer)
+            clearTimeout(timer);
+        this.expiryTimers.delete(dispatchIdArg);
+        this.notifyWaiters(dispatchIdArg, undefined);
+    }
+    notifyWaiters(dispatchIdArg, recordArg) {
+        const dispatchWaiters = this.waiters.get(dispatchIdArg);
+        if (!dispatchWaiters)
+            return;
+        this.waiters.delete(dispatchIdArg);
+        this.waiterCount -= dispatchWaiters.size;
+        for (const waiter of dispatchWaiters) {
+            clearTimeout(waiter.timer);
+            if (waiter.abortHandler)
+                waiter.signal?.removeEventListener('abort', waiter.abortHandler);
+            waiter.resolve(recordArg);
+        }
+    }
+    removeWaiter(dispatchIdArg, waiterArg) {
+        const dispatchWaiters = this.waiters.get(dispatchIdArg);
+        if (!dispatchWaiters)
+            return;
+        if (dispatchWaiters.delete(waiterArg)) {
+            this.waiterCount--;
+            clearTimeout(waiterArg.timer);
+            if (waiterArg.abortHandler) {
+                waiterArg.signal?.removeEventListener('abort', waiterArg.abortHandler);
+            }
+        }
+        if (dispatchWaiters.size === 0)
+            this.waiters.delete(dispatchIdArg);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.dispatchregistry.js","sourceRoot":"","sources":["../ts/classes.dispatchregistry.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.mcpserver.d.ts

@@ -0,0 +1,21 @@
+import * as plugins from './plugins.js';
+import { ConnectionRegistry } from './classes.connectionregistry.js';
+import { DispatchRegistry } from './classes.dispatchregistry.js';
+export declare class CrossHarnessMcpServer {
+    readonly connections: ConnectionRegistry;
+    readonly dispatches: DispatchRegistry;
+    private activeServer;
+    private stdinEndHandler;
+    private stdinEndSource;
+    private closePromise;
+    private resourceShutdownPromise;
+    private startCalled;
+    constructor(connectionsArg?: ConnectionRegistry, dispatchesArg?: DispatchRegistry);
+    start(transportArg?: plugins.Transport, stdinArg?: NodeJS.ReadableStream): Promise<void>;
+    close(): Promise<void>;
+    private triggerClose;
+    private ensureResourceShutdown;
+    private clearTransportReferences;
+    private describeConnection;
+    private wrapToolCall;
+}