@modelprofile.com/mcp-crossharness 5.0.0

package/dist_ts/classes.mcpserver.js

@@ -0,0 +1,276 @@
+import * as plugins from './plugins.js';
+import { commitinfo } from './00_commitinfo_data.js';
+import { ConnectionRegistry } from './classes.connectionregistry.js';
+import { DispatchRegistry } from './classes.dispatchregistry.js';
+const harnessNameSchema = plugins.z.enum(['claudecode', 'opencode', 'codex']);
+export class CrossHarnessMcpServer {
+    connections;
+    dispatches;
+    activeServer;
+    stdinEndHandler;
+    stdinEndSource;
+    closePromise;
+    resourceShutdownPromise;
+    startCalled = false;
+    constructor(connectionsArg = new ConnectionRegistry(), dispatchesArg = new DispatchRegistry()) {
+        this.connections = connectionsArg;
+        this.dispatches = dispatchesArg;
+    }
+    async start(transportArg = new plugins.StdioServerTransport(), stdinArg = process.stdin) {
+        if (this.startCalled)
+            throw new Error('Crossharness MCP server instances are one-shot');
+        this.startCalled = true;
+        const server = new plugins.McpServer({
+            name: 'mcp-crossharness',
+            version: commitinfo.version,
+        });
+        server.registerTool('connect_harness', {
+            title: 'Connect to harness server',
+            description: 'Establish an explicit connection to an allowlisted harness web server. The exact origin must be listed in CROSSHARNESS_ALLOWED_SERVER_URLS. OpenCode uses http(s), Codex uses ws(s), and Claude Code is rejected because it exposes no URL-addressable session server. Returns a connectionId required by every connection-scoped operation; list_connections remains global.',
+            inputSchema: {
+                harness: harnessNameSchema,
+                serverUrl: plugins.z.string().max(2048).url().describe('Allowlisted harness server origin'),
+                directory: plugins.z
+                    .string()
+                    .max(4096)
+                    .startsWith('/')
+                    .describe('Absolute project directory on the harness server'),
+            },
+        }, async (args, extra) => this.wrapToolCall(async () => {
+            const info = await this.connections.connect(args.harness, args.serverUrl, args.directory, extra.signal);
+            return this.describeConnection(info);
+        }));
+        server.registerTool('disconnect_harness', {
+            title: 'Disconnect harness server',
+            description: 'Close and remove an established harness connection. In-flight requests fail; async dispatch records remain inspectable with check_reply.',
+            inputSchema: {
+                connectionId: plugins.z.string().max(128).describe('Connection id returned by connect_harness'),
+            },
+        }, async (args, extra) => this.wrapToolCall(async () => this.describeConnection(await this.connections.disconnect(args.connectionId))));
+        server.registerTool('list_connections', {
+            title: 'List harness connections',
+            description: 'List explicit harness web-server connections established in this MCP process.',
+            inputSchema: {},
+        }, async () => this.wrapToolCall(async () => {
+            const connections = this.connections.list();
+            return connections.length > 0
+                ? connections.map((connection) => this.describeConnection(connection)).join('\n\n')
+                : 'No harness server connections established.';
+        }));
+        server.registerTool('connection_status', {
+            title: 'Check harness connection',
+            description: 'Run the protocol health check for one explicit harness server connection.',
+            inputSchema: {
+                connectionId: plugins.z.string().max(128).describe('Connection id returned by connect_harness'),
+            },
+        }, async (args) => this.wrapToolCall(async () => {
+            const status = await this.connections.get(args.connectionId).getStatus();
+            return `${this.describeConnection(status)}\nhealthy: ${status.healthy ? 'yes' : 'no'}\ndetail: ${status.detail}`;
+        }));
+        server.registerTool('list_chats', {
+            title: 'List harness chats',
+            description: 'List chats from the server and directory bound to an explicit connection. No local session stores are read.',
+            inputSchema: {
+                connectionId: plugins.z.string().max(128).describe('Connection id returned by connect_harness'),
+                limit: plugins.z.number().int().min(1).max(100).optional(),
+            },
+        }, async (args) => this.wrapToolCall(async () => {
+            const chats = await this.connections.get(args.connectionId).listChats(args.limit ?? 10);
+            if (chats.length === 0)
+                return 'No chats found for this connection.';
+            return [
+                'harness\tchatId\tupdatedAt\tactivity\ttitle',
+                ...chats.map((chat) => `${chat.harness}\t${chat.chatId}\t${chat.updatedAt}\t${chat.isActive ? 'active' : 'idle'}\t${chat.title.replace(/\s+/g, ' ').slice(0, 120)}`),
+            ].join('\n');
+        }));
+        server.registerTool('read_chat', {
+            title: 'Read harness chat',
+            description: 'Read a chat through the harness web server bound to an explicit connection.',
+            inputSchema: {
+                connectionId: plugins.z.string().max(128).describe('Connection id returned by connect_harness'),
+                chatId: plugins.z.string().min(1).max(1024),
+                limit: plugins.z.number().int().min(1).max(500).optional(),
+                maxChars: plugins.z.number().int().min(200).max(50000).optional(),
+            },
+        }, async (args) => this.wrapToolCall(async () => {
+            const transcript = await this.connections
+                .get(args.connectionId)
+                .readChat(args.chatId, args.limit ?? 20, args.maxChars ?? 2000);
+            const header = [
+                `harness: ${transcript.harness}`,
+                `chatId: ${transcript.chatId}`,
+                `title: ${transcript.title}`,
+                `directory: ${transcript.directory}`,
+                transcript.totalMessages === undefined
+                    ? `messages: showing ${transcript.messages.length}; server total unavailable`
+                    : `messages: showing ${transcript.messages.length} of ${transcript.totalMessages}`,
+            ].join('\n');
+            const body = transcript.messages
+                .map((message) => `-- [${message.role}]${message.timestamp ? ` ${message.timestamp}` : ''}\n${message.text}`)
+                .join('\n');
+            return `${header}\n\n${body}`;
+        }));
+        server.registerTool('send_message', {
+            title: 'Send message through harness server',
+            description: 'Send a message only through the harness web server bound to an explicit connection and wait for the reply. There is no CLI, process, local-store, discovery, or retry fallback.',
+            inputSchema: {
+                connectionId: plugins.z.string().max(128).describe('Connection id returned by connect_harness'),
+                chatId: plugins.z.string().min(1).max(1024),
+                message: plugins.z.string().min(1).max(1024 * 1024),
+                timeoutSeconds: plugins.z.number().int().min(1).max(3600).optional(),
+            },
+        }, async (args, extra) => this.wrapToolCall(async () => {
+            const result = await this.connections
+                .get(args.connectionId)
+                .sendMessage(args.chatId, args.message, args.timeoutSeconds ?? 300, extra.signal);
+            return `${result.reply}\n\n[crossharness transport: ${result.via}]`;
+        }));
+        server.registerTool('send_message_async', {
+            title: 'Send message through harness server asynchronously',
+            description: 'Start a server-only send and return a dispatchId immediately. Both this connectionId and the dispatchId are required by check_reply.',
+            inputSchema: {
+                connectionId: plugins.z.string().max(128).describe('Connection id returned by connect_harness'),
+                chatId: plugins.z.string().min(1).max(1024),
+                message: plugins.z.string().min(1).max(1024 * 1024),
+                timeoutSeconds: plugins.z.number().int().min(1).max(3600).optional(),
+            },
+        }, async (args) => this.wrapToolCall(async () => {
+            const connection = this.connections.get(args.connectionId);
+            const record = this.dispatches.track(args.connectionId, connection.harness, args.chatId, () => connection.sendMessage(args.chatId, args.message, args.timeoutSeconds ?? 900));
+            return [
+                `connectionId: ${record.connectionId}`,
+                `dispatchId: ${record.dispatchId}`,
+                `harness: ${record.harness}`,
+                `chatId: ${record.chatId}`,
+                `startedAt: ${record.startedAt}`,
+            ].join('\n');
+        }));
+        server.registerTool('check_reply', {
+            title: 'Check async server send',
+            description: 'Check an asynchronous send. The connectionId must own the dispatch. Records remain inspectable after disconnect.',
+            inputSchema: {
+                connectionId: plugins.z.string().max(128).describe('Connection id used for send_message_async'),
+                dispatchId: plugins.z.string().max(128).describe('Dispatch id returned by send_message_async'),
+                waitSeconds: plugins.z.number().int().min(0).max(60).optional(),
+            },
+        }, async (args, extra) => this.wrapToolCall(async () => {
+            const record = await this.dispatches.waitFor(args.connectionId, args.dispatchId, (args.waitSeconds ?? 0) * 1000, extra.signal);
+            if (!record)
+                throw new Error('unknown dispatchId for this connectionId');
+            const header = [
+                `connectionId: ${record.connectionId}`,
+                `dispatchId: ${record.dispatchId}`,
+                `status: ${record.status}`,
+                `harness: ${record.harness}`,
+                `chatId: ${record.chatId}`,
+                `startedAt: ${record.startedAt}`,
+                ...(record.completedAt ? [`completedAt: ${record.completedAt}`] : []),
+            ].join('\n');
+            if (record.status === 'working')
+                return `${header}\n\nStill working.`;
+            if (record.status === 'failed')
+                return `${header}\n\nError: ${record.error}`;
+            return `${header}\n\n${record.reply}\n\n[crossharness transport: ${record.via}]`;
+        }));
+        this.activeServer = server;
+        this.stdinEndHandler = () => this.triggerClose();
+        this.stdinEndSource = stdinArg;
+        this.stdinEndSource.once('end', this.stdinEndHandler);
+        this.stdinEndSource.once('close', this.stdinEndHandler);
+        this.stdinEndSource.once('error', this.stdinEndHandler);
+        server.server.onclose = () => {
+            this.clearTransportReferences();
+            void this.ensureResourceShutdown().catch(() => undefined);
+        };
+        try {
+            await server.connect(transportArg);
+        }
+        catch (error) {
+            this.clearTransportReferences();
+            await transportArg.close().catch(() => { });
+            await this.ensureResourceShutdown();
+            throw error;
+        }
+    }
+    async close() {
+        if (this.closePromise)
+            return this.closePromise;
+        this.closePromise = (async () => {
+            const server = this.activeServer;
+            let closeError;
+            try {
+                if (server)
+                    await server.close();
+            }
+            catch (error) {
+                closeError = error;
+            }
+            finally {
+                this.clearTransportReferences();
+                await this.ensureResourceShutdown();
+            }
+            if (closeError)
+                throw closeError;
+        })().finally(() => {
+            this.closePromise = undefined;
+        });
+        return this.closePromise;
+    }
+    triggerClose() {
+        void this.close().catch(() => { });
+    }
+    ensureResourceShutdown() {
+        if (this.resourceShutdownPromise)
+            return this.resourceShutdownPromise;
+        let shutdownPromise;
+        shutdownPromise = this.connections.closeAll().finally(() => {
+            this.dispatches.dispose();
+        }).catch((errorArg) => {
+            if (this.resourceShutdownPromise === shutdownPromise) {
+                this.resourceShutdownPromise = undefined;
+            }
+            throw errorArg;
+        });
+        this.resourceShutdownPromise = shutdownPromise;
+        return shutdownPromise;
+    }
+    clearTransportReferences() {
+        if (this.stdinEndHandler) {
+            this.stdinEndSource?.off('end', this.stdinEndHandler);
+            this.stdinEndSource?.off('close', this.stdinEndHandler);
+            this.stdinEndSource?.off('error', this.stdinEndHandler);
+        }
+        this.stdinEndHandler = undefined;
+        this.stdinEndSource = undefined;
+        this.activeServer = undefined;
+    }
+    describeConnection(infoArg) {
+        return [
+            `connectionId: ${infoArg.connectionId}`,
+            `harness: ${infoArg.harness}`,
+            `serverUrl: ${infoArg.serverUrl}`,
+            `directory: ${infoArg.directory}`,
+            `state: ${infoArg.state}`,
+            `connectedAt: ${infoArg.connectedAt}`,
+            ...(infoArg.serverVersion ? [`serverVersion: ${infoArg.serverVersion}`] : []),
+        ].join('\n');
+    }
+    async wrapToolCall(handlerArg) {
+        try {
+            const text = await handlerArg();
+            return { content: [{ type: 'text', text: text.slice(0, 100000) }] };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`.slice(0, 100000),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.mcpserver.js","sourceRoot":"","sources":["../ts/classes.mcpserver.ts"],"names":[],"mappings":"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"}

package/dist_ts/helpers.d.ts

@@ -0,0 +1,4 @@
+export declare const truncateText: (textArg: string, maxCharsArg: number) => string;
+export declare const parseJson: (valueArg: string) => unknown;
+export declare const isRecord: (valueArg: unknown) => valueArg is Record<string, unknown>;
+export declare const errorMessage: (errorArg: unknown) => string;

package/dist_ts/helpers.js

@@ -0,0 +1,17 @@
+export const truncateText = (textArg, maxCharsArg) => {
+    if (textArg.length <= maxCharsArg) {
+        return textArg;
+    }
+    return `${textArg.slice(0, maxCharsArg)}\n[truncated ${textArg.length - maxCharsArg} chars]`;
+};
+export const parseJson = (valueArg) => {
+    try {
+        return JSON.parse(valueArg);
+    }
+    catch {
+        return undefined;
+    }
+};
+export const isRecord = (valueArg) => Boolean(valueArg) && typeof valueArg === 'object' && !Array.isArray(valueArg);
+export const errorMessage = (errorArg) => errorArg instanceof Error ? errorArg.message : String(errorArg);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVscGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2hlbHBlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFHLENBQUMsT0FBZSxFQUFFLFdBQW1CLEVBQVUsRUFBRTtJQUMzRSxJQUFJLE9BQU8sQ0FBQyxNQUFNLElBQUksV0FBVyxFQUFFLENBQUM7UUFDbEMsT0FBTyxPQUFPLENBQUM7SUFDakIsQ0FBQztJQUNELE9BQU8sR0FBRyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRSxXQUFXLENBQUMsZ0JBQWdCLE9BQU8sQ0FBQyxNQUFNLEdBQUcsV0FBVyxTQUFTLENBQUM7QUFDL0YsQ0FBQyxDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sU0FBUyxHQUFHLENBQUMsUUFBZ0IsRUFBVyxFQUFFO0lBQ3JELElBQUksQ0FBQztRQUNILE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUM5QixDQUFDO0lBQUMsTUFBTSxDQUFDO1FBQ1AsT0FBTyxTQUFTLENBQUM7SUFDbkIsQ0FBQztBQUNILENBQUMsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLFFBQVEsR0FBRyxDQUFDLFFBQWlCLEVBQXVDLEVBQUUsQ0FDakYsT0FBTyxDQUFDLFFBQVEsQ0FBQyxJQUFJLE9BQU8sUUFBUSxLQUFLLFFBQVEsSUFBSSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDLENBQUM7QUFFaEYsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFHLENBQUMsUUFBaUIsRUFBVSxFQUFFLENBQ3hELFFBQVEsWUFBWSxLQUFLLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQyJ9

package/dist_ts/index.d.ts

@@ -0,0 +1,5 @@
+export * from './interfaces.js';
+export * from './classes.connectionregistry.js';
+export * from './classes.dispatchregistry.js';
+export * from './classes.mcpserver.js';
+export declare const runCli: () => Promise<void>;

package/dist_ts/index.js

@@ -0,0 +1,9 @@
+export * from './interfaces.js';
+export * from './classes.connectionregistry.js';
+export * from './classes.dispatchregistry.js';
+export * from './classes.mcpserver.js';
+import { CrossHarnessMcpServer } from './classes.mcpserver.js';
+export const runCli = async () => {
+    await new CrossHarnessMcpServer().start();
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLHdCQUF3QixDQUFDO0FBRXZDLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRS9ELE1BQU0sQ0FBQyxNQUFNLE1BQU0sR0FBRyxLQUFLLElBQW1CLEVBQUU7SUFDOUMsTUFBTSxJQUFJLHFCQUFxQixFQUFFLENBQUMsS0FBSyxFQUFFLENBQUM7QUFDNUMsQ0FBQyxDQUFDIn0=

package/dist_ts/interfaces.d.ts

@@ -0,0 +1,57 @@
+export type THarnessName = 'claudecode' | 'opencode' | 'codex';
+export type TConnectionState = 'connecting' | 'connected' | 'closing' | 'closed';
+export interface IConnectionInfo {
+    connectionId: string;
+    harness: THarnessName;
+    serverUrl: string;
+    directory: string;
+    state: TConnectionState;
+    connectedAt: string;
+    serverVersion?: string;
+}
+export interface IConnectionStatus extends IConnectionInfo {
+    healthy: boolean;
+    detail: string;
+}
+export interface IChatSummary {
+    harness: THarnessName;
+    chatId: string;
+    title: string;
+    directory: string;
+    updatedAt: string;
+    isActive?: boolean;
+    meta?: Record<string, string>;
+}
+export interface IChatMessage {
+    role: string;
+    text: string;
+    timestamp?: string;
+}
+export interface IChatTranscript {
+    harness: THarnessName;
+    chatId: string;
+    title: string;
+    directory: string;
+    totalMessages?: number;
+    messages: IChatMessage[];
+}
+export interface ISendResult {
+    harness: THarnessName;
+    chatId: string;
+    reply: string;
+    via: string;
+}
+export interface IHarnessConnection {
+    readonly connectionId: string;
+    readonly harness: THarnessName;
+    readonly serverUrl: string;
+    readonly directory: string;
+    readonly state: TConnectionState;
+    connect(): Promise<void>;
+    getInfo(): IConnectionInfo;
+    getStatus(): Promise<IConnectionStatus>;
+    listChats(limitArg: number): Promise<IChatSummary[]>;
+    readChat(chatIdArg: string, limitArg: number, maxCharsArg: number): Promise<IChatTranscript>;
+    sendMessage(chatIdArg: string, messageArg: string, timeoutSecondsArg: number, signalArg?: AbortSignal): Promise<ISendResult>;
+    close(reasonArg?: string): Promise<void>;
+}

package/dist_ts/interfaces.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2ludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist_ts/plugins.d.ts

@@ -0,0 +1,17 @@
+import * as crypto from 'node:crypto';
+import * as http from 'node:http';
+import * as stream from 'node:stream';
+import type { AddressInfo } from 'node:net';
+export { crypto, http, stream };
+export type { AddressInfo };
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { Client as McpClient } from '@modelcontextprotocol/sdk/client/index.js';
+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import { WebSocket as WsWebSocket, WebSocketServer } from 'ws';
+import type { RawData } from 'ws';
+import { z } from 'zod';
+export { InMemoryTransport, McpClient, McpServer, StdioServerTransport, WebSocketServer, WsWebSocket, z, };
+export type { RawData };
+export type { Transport };

package/dist_ts/plugins.js

@@ -0,0 +1,14 @@
+// Node native modules
+import * as crypto from 'node:crypto';
+import * as http from 'node:http';
+import * as stream from 'node:stream';
+export { crypto, http, stream };
+// Third-party modules
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { Client as McpClient } from '@modelcontextprotocol/sdk/client/index.js';
+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
+import { WebSocket as WsWebSocket, WebSocketServer } from 'ws';
+import { z } from 'zod';
+export { InMemoryTransport, McpClient, McpServer, StdioServerTransport, WebSocketServer, WsWebSocket, z, };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsc0JBQXNCO0FBQ3RCLE9BQU8sS0FBSyxNQUFNLE1BQU0sYUFBYSxDQUFDO0FBQ3RDLE9BQU8sS0FBSyxJQUFJLE1BQU0sV0FBVyxDQUFDO0FBQ2xDLE9BQU8sS0FBSyxNQUFNLE1BQU0sYUFBYSxDQUFDO0FBR3RDLE9BQU8sRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxDQUFDO0FBR2hDLHNCQUFzQjtBQUN0QixPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0seUNBQXlDLENBQUM7QUFDcEUsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sMkNBQTJDLENBQUM7QUFDakYsT0FBTyxFQUFFLE1BQU0sSUFBSSxTQUFTLEVBQUUsTUFBTSwyQ0FBMkMsQ0FBQztBQUNoRixPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx1Q0FBdUMsQ0FBQztBQUUxRSxPQUFPLEVBQUUsU0FBUyxJQUFJLFdBQVcsRUFBRSxlQUFlLEVBQUUsTUFBTSxJQUFJLENBQUM7QUFFL0QsT0FBTyxFQUFFLENBQUMsRUFBRSxNQUFNLEtBQUssQ0FBQztBQUV4QixPQUFPLEVBQ0wsaUJBQWlCLEVBQ2pCLFNBQVMsRUFDVCxTQUFTLEVBQ1Qsb0JBQW9CLEVBQ3BCLGVBQWUsRUFDZixXQUFXLEVBQ1gsQ0FBQyxHQUNGLENBQUMifQ==

package/license.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Task Venture Capital GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@modelprofile.com/mcp-crossharness",
+  "version": "5.0.0",
+  "private": false,
+  "description": "Connection-first MCP server for explicit OpenCode HTTP and Codex WebSocket session servers",
+  "main": "dist_ts/index.js",
+  "typings": "dist_ts/index.d.ts",
+  "type": "module",
+  "author": "Task Venture Capital GmbH",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://code.foss.global/modelprofile.com/mcp-crossharness.git"
+  },
+  "homepage": "https://code.foss.global/modelprofile.com/mcp-crossharness",
+  "bugs": {
+    "url": "https://community.foss.global/"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "bin": {
+    "mcp-crossharness": "./cli.js"
+  },
+  "devDependencies": {
+    "@git.zone/tsbuild": "^4.4.2",
+    "@git.zone/tsrun": "^2.0.6",
+    "@git.zone/tstest": "^4.0.0",
+    "@types/node": "^26.2.0",
+    "@types/ws": "^8.18.1"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "ws": "8.21.2",
+    "zod": "^4.4.3"
+  },
+  "files": [
+    "ts/**/*",
+    "dist_ts/**/*",
+    "cli.js",
+    ".smartconfig.json",
+    "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
+  ],
+  "scripts": {
+    "test": "(tstest test/ --verbose)",
+    "build": "(tsbuild)"
+  }
+}

package/readme.hints.md

@@ -0,0 +1,52 @@
+# readme.hints.md
+
+Implementation findings for mcp-crossharness.
+
+## Server-only architecture
+
+- Every harness operation after connection setup is scoped to an opaque connection established from an explicit server origin and remote absolute directory; `list_connections` remains global.
+- Duplicate harness/origin/directory bindings are rejected and each registry is capped at 32 connections.
+- `CROSSHARNESS_ALLOWED_SERVER_URLS` is an exact-origin allowlist. Credentials are fixed environment variables, never tool inputs.
+- URLs reject user info, query strings, fragments, and non-root paths. OpenCode fetch calls use `redirect: 'error'`.
+- No production source reads harness stores, invokes harness CLIs, starts or stops processes, or discovers endpoints.
+
+## OpenCode server API
+
+Verified against OpenCode 1.18.13 docs, source, and generated SDK.
+
+- Health: `GET /global/health`.
+- Session list: `GET /session?directory=...&scope=project&roots=true&limit=...`.
+- Session ownership: `GET /session/:id?directory=...`, then verify returned `directory` exactly.
+- Transcript: `GET /session/:id/message?directory=...&limit=...`.
+- Send: `POST /session/:id/message?directory=...` with a generated `messageID` and text part.
+- OpenCode owns queuing. Crossharness intentionally does not serialize HTTP sends, subscribe to permission events, or issue session-wide aborts.
+- Aborting a fetch does not prove that a queued/running server turn stopped, so timeout errors state the ambiguity and no retry occurs.
+- Successful JSON response bodies are capped at 16 MiB; error bodies are capped at 64 KiB and only the first 2,000 characters are surfaced.
+
+## Codex app-server API
+
+Verified against Codex 0.146.0 using `codex app-server generate-ts` and official app-server documentation.
+
+- Explicit transports are `ws://` and `wss://`; one initialized WebSocket is owned per Crossharness connection.
+- Flow: `initialize` -> `initialized`; `thread/list`; `thread/read`; `thread/resume`; `turn/start`; correlated notifications; optional `turn/interrupt` on timeout.
+- `thread/list` supports exact `cwd` filtering. `thread/read` results are still verified against the connection directory before reading or sending.
+- Request responses are correlated by JSON-RPC id. Turn events are correlated by `threadId` and `turnId`; events can arrive before `turn/start` resolves, so one unbound turn per thread may claim the early id.
+- Sends to one thread are sequenced; different threads remain concurrent.
+- Codex send queues are bounded globally and per thread, outbound WebSocket buffering is capped at 4 MiB, and a send's timeout includes time spent waiting in the same-thread queue.
+- Turn output is bounded by text size and delta count, including empty streaming deltas.
+- Foreground MCP cancellation aborts the operation-scoped OpenCode request or safely interrupts the correlated Codex turn; asynchronous dispatches remain independent after acceptance.
+- A timed-out send keeps its thread queue locked until `turn/interrupt` is acknowledged and `turn/completed` reports terminal state. Missing turn correlation or incomplete interruption closes the connection fail-closed.
+- Socket close rejects all pending requests and turns. Disconnect removes the connection before closing so no new work can enter.
+- Stdio EOF closes the MCP transport and every active or handshaking connection.
+- Server requests are never ignored: command/file approvals decline, tool input returns empty answers, MCP elicitation declines, permission-profile requests grant no extra permissions for the turn, legacy approvals abort, and unknown requests receive `-32601`.
+
+## Claude Code
+
+Claude Code 2.1.219 and the current Agent SDK expose local CLI/library interfaces, not a URL-addressable session server. `connect_harness` rejects `claudecode` until such a server exists.
+
+## Testing
+
+- HTTP fixtures cover required Basic auth, allowlisting, redirect rejection, directory ownership, concurrent OpenCode sends, and disconnect state.
+- WebSocket fixtures cover initialization, list/read/send, interleaved turns, bounded deltas and send buffering, safe server-request responses, timeout interruption, directory ownership, and disconnect failure propagation.
+- Registry fixtures cover pending-connect shutdown and bounded dispatch admission before send invocation.
+- Timeout fixtures cover OpenCode validation, Codex same-thread queueing, interruption completion, malformed terminal events, and stdio EOF cleanup.