@modelprofile.com/mcp-crossharness 5.0.0

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

@@ -0,0 +1,34 @@
+import type * as interfaces from './interfaces.js';
+import type { IOpenCodeCredentials } from './classes.connectionregistry.js';
+export declare class OpencodeConnection implements interfaces.IHarnessConnection {
+    readonly connectionId: string;
+    readonly serverUrl: string;
+    readonly directory: string;
+    private onClosing?;
+    private onClosed?;
+    private readonly credentials?;
+    readonly harness: "opencode";
+    state: interfaces.TConnectionState;
+    private connectedAt;
+    private serverVersion;
+    private activeControllers;
+    private connectStarted;
+    constructor(connectionId: string, serverUrl: string, directory: string, onClosing?: (() => void) | undefined, onClosed?: (() => void) | undefined, credentials?: IOpenCodeCredentials | undefined);
+    connect(): Promise<void>;
+    getInfo(): interfaces.IConnectionInfo;
+    getStatus(): Promise<interfaces.IConnectionStatus>;
+    listChats(limitArg: number): Promise<interfaces.IChatSummary[]>;
+    readChat(chatIdArg: string, limitArg: number, maxCharsArg: number): Promise<interfaces.IChatTranscript>;
+    sendMessage(chatIdArg: string, messageArg: string, timeoutSecondsArg: number, signalArg?: AbortSignal): Promise<interfaces.ISendResult>;
+    close(reasonArg?: string): Promise<void>;
+    private requireSession;
+    private parseSession;
+    private parseMessage;
+    private parseMessageEnvelope;
+    private requestJson;
+    private readResponseText;
+    private authHeaders;
+    private redactCredentials;
+    private remainingSendMs;
+    private assertChatId;
+}

package/dist_ts/classes.connection.opencode.js

@@ -0,0 +1,365 @@
+import * as plugins from './plugins.js';
+import * as helpers from './helpers.js';
+const serverApiVersion = '1.18.13';
+export class OpencodeConnection {
+    connectionId;
+    serverUrl;
+    directory;
+    onClosing;
+    onClosed;
+    credentials;
+    harness = 'opencode';
+    state = 'connecting';
+    connectedAt = new Date().toISOString();
+    serverVersion;
+    activeControllers = new Set();
+    connectStarted = false;
+    constructor(connectionId, serverUrl, directory, onClosing, onClosed, credentials) {
+        this.connectionId = connectionId;
+        this.serverUrl = serverUrl;
+        this.directory = directory;
+        this.onClosing = onClosing;
+        this.onClosed = onClosed;
+        this.credentials = credentials;
+    }
+    async connect() {
+        if (this.connectStarted) {
+            throw new Error(`OpenCode connection ${this.connectionId} has already been started`);
+        }
+        this.connectStarted = true;
+        const health = await this.requestJson('/global/health', { timeoutMs: 5000 }, true);
+        if (!helpers.isRecord(health) || health.healthy !== true || typeof health.version !== 'string') {
+            throw new Error(`OpenCode server at ${this.serverUrl} returned an invalid health response (expected API verified against ${serverApiVersion})`);
+        }
+        this.serverVersion = health.version;
+        this.state = 'connected';
+    }
+    getInfo() {
+        return {
+            connectionId: this.connectionId,
+            harness: this.harness,
+            serverUrl: this.serverUrl,
+            directory: this.directory,
+            state: this.state,
+            connectedAt: this.connectedAt,
+            serverVersion: this.serverVersion,
+        };
+    }
+    async getStatus() {
+        if (this.state !== 'connected') {
+            return { ...this.getInfo(), healthy: false, detail: `connection is ${this.state}` };
+        }
+        try {
+            const health = await this.requestJson('/global/health', { timeoutMs: 5000 });
+            const healthy = helpers.isRecord(health) && health.healthy === true;
+            return {
+                ...this.getInfo(),
+                healthy,
+                detail: healthy ? 'OpenCode /global/health reported healthy' : 'invalid health response',
+            };
+        }
+        catch (error) {
+            return { ...this.getInfo(), healthy: false, detail: helpers.errorMessage(error) };
+        }
+    }
+    async listChats(limitArg) {
+        const payload = await this.requestJson('/session', {
+            query: { directory: this.directory, roots: 'true', limit: String(limitArg) },
+            timeoutMs: 30000,
+        });
+        if (!Array.isArray(payload)) {
+            throw new Error('OpenCode server returned an invalid session list');
+        }
+        const sessions = payload.map((entry) => this.parseSession(entry));
+        if (sessions.some((session) => session.directory !== this.directory)) {
+            throw new Error('OpenCode server returned a session outside the connection directory');
+        }
+        return sessions
+            .filter((session) => session.parentID === undefined)
+            .slice(0, limitArg)
+            .map((session) => ({
+            harness: this.harness,
+            chatId: session.id,
+            title: session.title,
+            directory: session.directory,
+            updatedAt: new Date(session.updatedMs).toISOString(),
+            isActive: Date.now() - session.updatedMs < 120000,
+        }));
+    }
+    async readChat(chatIdArg, limitArg, maxCharsArg) {
+        this.assertChatId(chatIdArg);
+        const session = await this.requireSession(chatIdArg);
+        const payload = await this.requestJson(`/session/${encodeURIComponent(chatIdArg)}/message`, {
+            query: { directory: this.directory, limit: String(limitArg) },
+            timeoutMs: 30000,
+        });
+        if (!Array.isArray(payload)) {
+            throw new Error('OpenCode server returned an invalid message list');
+        }
+        const messages = payload.map((entry) => this.parseMessage(entry, chatIdArg, maxCharsArg));
+        return {
+            harness: this.harness,
+            chatId: chatIdArg,
+            title: session.title,
+            directory: session.directory,
+            messages,
+        };
+    }
+    async sendMessage(chatIdArg, messageArg, timeoutSecondsArg, signalArg) {
+        this.assertChatId(chatIdArg);
+        if (messageArg.length > 1024 * 1024) {
+            throw new Error('OpenCode message exceeds the 1 MiB character limit');
+        }
+        const deadline = Date.now() + timeoutSecondsArg * 1000;
+        await this.requireSession(chatIdArg, this.remainingSendMs(deadline, timeoutSecondsArg), signalArg);
+        const requestMessageId = `msg_${plugins.crypto.randomUUID().replaceAll('-', '')}`;
+        let payload;
+        try {
+            payload = await this.requestJson(`/session/${encodeURIComponent(chatIdArg)}/message`, {
+                method: 'POST',
+                query: { directory: this.directory },
+                body: {
+                    messageID: requestMessageId,
+                    parts: [{ type: 'text', text: messageArg }],
+                },
+                timeoutMs: this.remainingSendMs(deadline, timeoutSecondsArg),
+                signal: signalArg,
+            });
+        }
+        catch (error) {
+            throw new Error(`OpenCode send failed; the server may still have queued or started the turn, and Crossharness did not retry: ${helpers.errorMessage(error)}`, { cause: error });
+        }
+        const parsed = this.parseMessageEnvelope(payload, chatIdArg);
+        if (parsed.info.role !== 'assistant' || parsed.info.parentID !== requestMessageId) {
+            throw new Error('OpenCode server returned an assistant response for a different prompt');
+        }
+        if (parsed.info.error !== undefined && parsed.info.error !== null) {
+            throw new Error('OpenCode server returned an assistant error');
+        }
+        const reply = parsed.parts
+            .filter((part) => part.type === 'text' && typeof part.text === 'string')
+            .map((part) => part.text)
+            .join('\n')
+            .trim();
+        if (!reply) {
+            throw new Error('OpenCode server returned no assistant text');
+        }
+        return {
+            harness: this.harness,
+            chatId: chatIdArg,
+            reply,
+            via: `http:${this.serverUrl}`,
+        };
+    }
+    async close(reasonArg = 'connection disconnected') {
+        if (this.state === 'closed')
+            return;
+        this.state = 'closing';
+        this.onClosing?.();
+        this.onClosing = undefined;
+        for (const controller of this.activeControllers) {
+            controller.abort(new Error(reasonArg));
+        }
+        this.activeControllers.clear();
+        this.state = 'closed';
+        this.onClosed?.();
+        this.onClosed = undefined;
+    }
+    async requireSession(chatIdArg, timeoutMsArg = 30000, signalArg) {
+        const payload = await this.requestJson(`/session/${encodeURIComponent(chatIdArg)}`, {
+            query: { directory: this.directory },
+            timeoutMs: timeoutMsArg,
+            signal: signalArg,
+        });
+        const session = this.parseSession(payload);
+        if (session.id !== chatIdArg) {
+            throw new Error(`OpenCode server returned a different session for ${chatIdArg}`);
+        }
+        if (session.directory !== this.directory) {
+            throw new Error(`OpenCode session ${chatIdArg} is outside the connection directory`);
+        }
+        return session;
+    }
+    parseSession(valueArg) {
+        if (!helpers.isRecord(valueArg) || !helpers.isRecord(valueArg.time)) {
+            throw new Error('OpenCode server returned an invalid session');
+        }
+        const updatedMs = Number(valueArg.time.updated);
+        if (typeof valueArg.id !== 'string' ||
+            typeof valueArg.title !== 'string' ||
+            typeof valueArg.directory !== 'string' ||
+            !Number.isFinite(updatedMs) ||
+            (valueArg.parentID !== undefined && typeof valueArg.parentID !== 'string')) {
+            throw new Error('OpenCode server returned an invalid session');
+        }
+        return {
+            id: valueArg.id,
+            title: valueArg.title,
+            directory: valueArg.directory,
+            updatedMs,
+            parentID: valueArg.parentID,
+        };
+    }
+    parseMessage(valueArg, chatIdArg, maxCharsArg) {
+        const parsed = this.parseMessageEnvelope(valueArg, chatIdArg);
+        const textParts = parsed.parts
+            .filter((part) => part.type === 'text' && typeof part.text === 'string')
+            .map((part) => part.text);
+        const toolParts = parsed.parts
+            .filter((part) => part.type === 'tool' && typeof part.tool === 'string')
+            .map((part) => `[tool: ${part.tool}]`);
+        const created = helpers.isRecord(parsed.info.time) ? Number(parsed.info.time.created) : NaN;
+        return {
+            role: parsed.info.role,
+            text: helpers.truncateText([...textParts, ...toolParts].join('\n').trim(), maxCharsArg),
+            timestamp: Number.isFinite(created) ? new Date(created).toISOString() : undefined,
+        };
+    }
+    parseMessageEnvelope(valueArg, chatIdArg) {
+        if (!helpers.isRecord(valueArg) || !helpers.isRecord(valueArg.info) || !Array.isArray(valueArg.parts)) {
+            throw new Error('OpenCode server returned an invalid message');
+        }
+        const info = valueArg.info;
+        if (typeof info.id !== 'string' ||
+            typeof info.role !== 'string' ||
+            info.sessionID !== chatIdArg ||
+            (info.parentID !== undefined && typeof info.parentID !== 'string')) {
+            throw new Error('OpenCode server returned an invalid message identity');
+        }
+        const parts = valueArg.parts.map((part) => {
+            if (!helpers.isRecord(part) ||
+                typeof part.type !== 'string' ||
+                part.sessionID !== chatIdArg ||
+                part.messageID !== info.id) {
+                throw new Error('OpenCode server returned an invalid message part');
+            }
+            return part;
+        });
+        return {
+            info: info,
+            parts,
+        };
+    }
+    async requestJson(pathArg, optionsArg, allowConnectingArg = false) {
+        if (!allowConnectingArg && this.state !== 'connected') {
+            throw new Error(`OpenCode connection ${this.connectionId} is ${this.state}`);
+        }
+        const url = new URL(pathArg, `${this.serverUrl}/`);
+        for (const [key, value] of Object.entries(optionsArg.query ?? {})) {
+            url.searchParams.set(key, value);
+        }
+        const controller = new AbortController();
+        if (this.activeControllers.size >= 100) {
+            throw new Error('OpenCode connection has too many active requests');
+        }
+        this.activeControllers.add(controller);
+        const abortFromCaller = () => controller.abort(optionsArg.signal?.reason);
+        if (optionsArg.signal?.aborted)
+            abortFromCaller();
+        else
+            optionsArg.signal?.addEventListener('abort', abortFromCaller, { once: true });
+        const timer = setTimeout(() => controller.abort(new Error(`OpenCode request timed out after ${optionsArg.timeoutMs}ms`)), optionsArg.timeoutMs);
+        try {
+            const response = await fetch(url, {
+                method: optionsArg.method ?? 'GET',
+                headers: {
+                    ...this.authHeaders(),
+                    accept: 'application/json',
+                    ...(optionsArg.body === undefined ? {} : { 'content-type': 'application/json' }),
+                },
+                body: optionsArg.body === undefined ? undefined : JSON.stringify(optionsArg.body),
+                redirect: 'error',
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                const responseText = await this.readResponseText(response, 64 * 1024).catch(() => '[response body unavailable or too large]');
+                const redactedResponseText = this.redactCredentials(responseText);
+                throw new Error(`OpenCode server returned HTTP ${response.status}${redactedResponseText ? `: ${redactedResponseText.slice(0, 2000)}` : ''}`);
+            }
+            const responseText = await this.readResponseText(response, 16 * 1024 * 1024);
+            const payload = helpers.parseJson(responseText);
+            if (payload === undefined) {
+                throw new Error('OpenCode server returned invalid JSON');
+            }
+            return payload;
+        }
+        finally {
+            clearTimeout(timer);
+            optionsArg.signal?.removeEventListener('abort', abortFromCaller);
+            this.activeControllers.delete(controller);
+        }
+    }
+    async readResponseText(responseArg, maxBytesArg) {
+        const contentLength = Number(responseArg.headers.get('content-length'));
+        if (Number.isFinite(contentLength) && contentLength > maxBytesArg) {
+            await responseArg.body?.cancel().catch(() => { });
+            throw new Error(`OpenCode response exceeds ${maxBytesArg} bytes`);
+        }
+        if (!responseArg.body)
+            return '';
+        const reader = responseArg.body.getReader();
+        const decoder = new TextDecoder();
+        let bytes = 0;
+        let text = '';
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                bytes += value.byteLength;
+                if (bytes > maxBytesArg) {
+                    await reader.cancel().catch(() => { });
+                    throw new Error(`OpenCode response exceeds ${maxBytesArg} bytes`);
+                }
+                text += decoder.decode(value, { stream: true });
+            }
+            return text + decoder.decode();
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    authHeaders() {
+        const password = this.credentials?.password ?? process.env.OPENCODE_SERVER_PASSWORD;
+        if (!password) {
+            throw new Error('OPENCODE_SERVER_PASSWORD is required for OpenCode connections');
+        }
+        const username = this.credentials
+            ? (this.credentials.username ?? 'opencode')
+            : (process.env.OPENCODE_SERVER_USERNAME ?? 'opencode');
+        return {
+            authorization: `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`,
+        };
+    }
+    redactCredentials(valueArg) {
+        const password = this.credentials?.password ?? process.env.OPENCODE_SERVER_PASSWORD;
+        const username = this.credentials
+            ? (this.credentials.username ?? 'opencode')
+            : (process.env.OPENCODE_SERVER_USERNAME ?? 'opencode');
+        const authorization = password
+            ? `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`
+            : '';
+        let value = valueArg;
+        const secrets = [authorization, password, username]
+            .filter((secret) => Boolean(secret))
+            .sort((left, right) => right.length - left.length);
+        for (const secret of secrets) {
+            if (secret)
+                value = value.replaceAll(secret, '[redacted]');
+        }
+        return value;
+    }
+    remainingSendMs(deadlineArg, timeoutSecondsArg) {
+        const remainingMs = deadlineArg - Date.now();
+        if (remainingMs <= 0) {
+            throw new Error(`OpenCode send timed out after ${timeoutSecondsArg}s before dispatch; no message was delivered`);
+        }
+        return remainingMs;
+    }
+    assertChatId(chatIdArg) {
+        if (!chatIdArg || chatIdArg.length > 1024) {
+            throw new Error('OpenCode chatId must contain 1-1024 characters');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.connection.opencode.js","sourceRoot":"","sources":["../ts/classes.connection.opencode.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.connectionregistry.d.ts

@@ -0,0 +1,32 @@
+import type * as interfaces from './interfaces.js';
+export interface IConnectionRegistryOptions {
+    allowedServerUrls?: string[];
+    maxConnections?: number;
+    openCodeCredentials?: IOpenCodeCredentials;
+}
+export interface IOpenCodeCredentials {
+    serverUrl: string;
+    username?: string;
+    password: string;
+}
+export declare class ConnectionRegistry {
+    private connections;
+    private connecting;
+    private closingConnections;
+    private allowedServerUrls;
+    private maxConnections;
+    private openCodeCredentials;
+    private closing;
+    private closingTasks;
+    private shutdownPromise;
+    constructor(optionsArg?: IConnectionRegistryOptions);
+    connect(harnessArg: interfaces.THarnessName, serverUrlArg: string, directoryArg: string, signalArg?: AbortSignal): Promise<interfaces.IConnectionInfo>;
+    get(connectionIdArg: string): interfaces.IHarnessConnection;
+    list(): interfaces.IConnectionInfo[];
+    disconnect(connectionIdArg: string): Promise<interfaces.IConnectionInfo>;
+    closeAll(): Promise<void>;
+    private closeConnection;
+    private validateAllowedUrl;
+    private normalizeUrl;
+    private abortError;
+}