@mknrt/autotests-overkill 1.2.3 → 1.2.6

package/dist/src/cli/runMcpServer.js

@@ -1,11 +1,46 @@
-import { createRuntimeAppContext } from '../appContext.js';
-import { runMcpServer } from '../mcp/server.js';
 import { formatRuntimeStartupError } from './runtimeStartupError.js';
 import { isDirectExecution } from './shared.js';
+let sqliteWarningSuppressionInstalled = false;
 export async function startMcpServer() {
+    suppressSqliteExperimentalWarning();
+    const [{ createRuntimeAppContext }, { runMcpServer }] = await Promise.all([
+        import('../appContext.js'),
+        import('../mcp/server.js'),
+    ]);
     const context = await createRuntimeAppContext();
     await runMcpServer(context);
 }
+function suppressSqliteExperimentalWarning() {
+    if (sqliteWarningSuppressionInstalled) {
+        return;
+    }
+    sqliteWarningSuppressionInstalled = true;
+    const originalEmitWarning = process.emitWarning.bind(process);
+    process.emitWarning = ((warning, ...args) => {
+        if (isSqliteExperimentalWarning(warning, args)) {
+            return;
+        }
+        originalEmitWarning(warning, ...args);
+    });
+}
+function isSqliteExperimentalWarning(warning, args) {
+    const message = warning instanceof Error ? warning.message : warning;
+    const type = warning instanceof Error
+        ? warning.name
+        : readWarningType(args[0]);
+    return type === 'ExperimentalWarning'
+        && message.includes('SQLite is an experimental feature');
+}
+function readWarningType(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value && typeof value === 'object' && 'type' in value) {
+        const { type } = value;
+        return typeof type === 'string' ? type : undefined;
+    }
+    return undefined;
+}
 if (isDirectExecution(import.meta.url)) {
     try {
         await startMcpServer();

package/dist/src/mcp/framingAwareStdioTransport.d.ts

@@ -0,0 +1,23 @@
+import type { Readable, Writable } from 'node:stream';
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import { type JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+/**
+ * Accepts both SDK newline-delimited stdio JSON-RPC and Content-Length framed MCP messages.
+ */
+export declare class FramingAwareStdioServerTransport implements Transport {
+    private readonly stdin;
+    private readonly stdout;
+    private readonly readBuffer;
+    private started;
+    private responseFraming;
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    onmessage?: (message: JSONRPCMessage) => void;
+    constructor(stdin?: Readable, stdout?: Writable);
+    private readonly ondata;
+    private readonly onstreamerror;
+    start(): Promise<void>;
+    close(): Promise<void>;
+    send(message: JSONRPCMessage): Promise<void>;
+    private processReadBuffer;
+}

package/dist/src/mcp/framingAwareStdioTransport.js

@@ -0,0 +1,152 @@
+import process from 'node:process';
+import { JSONRPCMessageSchema } from '@modelcontextprotocol/sdk/types.js';
+class FramingAwareReadBuffer {
+    buffer;
+    append(chunk) {
+        this.buffer = this.buffer ? Buffer.concat([this.buffer, chunk]) : chunk;
+    }
+    clear() {
+        this.buffer = undefined;
+    }
+    readMessage() {
+        if (!this.buffer || this.buffer.length === 0) {
+            return null;
+        }
+        if (startsWithContentLengthHeader(this.buffer)) {
+            return this.readContentLengthMessage();
+        }
+        return this.readNewlineMessage();
+    }
+    readNewlineMessage() {
+        if (!this.buffer) {
+            return null;
+        }
+        const newlineIndex = this.buffer.indexOf('\n');
+        if (newlineIndex === -1) {
+            return null;
+        }
+        const line = this.buffer.toString('utf8', 0, newlineIndex).replace(/\r$/, '');
+        this.buffer = this.buffer.subarray(newlineIndex + 1);
+        return {
+            message: deserializeMessage(line),
+            framing: 'newline',
+        };
+    }
+    readContentLengthMessage() {
+        if (!this.buffer) {
+            return null;
+        }
+        const header = findHeader(this.buffer);
+        if (!header) {
+            return null;
+        }
+        const headerText = this.buffer.toString('utf8', 0, header.endIndex);
+        const contentLength = parseContentLength(headerText);
+        if (contentLength === undefined) {
+            this.buffer = this.buffer.subarray(header.endIndex + header.separatorLength);
+            throw new Error('Invalid MCP stdio Content-Length header');
+        }
+        const bodyStart = header.endIndex + header.separatorLength;
+        const bodyEnd = bodyStart + contentLength;
+        if (this.buffer.length < bodyEnd) {
+            return null;
+        }
+        const body = this.buffer.toString('utf8', bodyStart, bodyEnd);
+        this.buffer = this.buffer.subarray(bodyEnd);
+        return {
+            message: deserializeMessage(body),
+            framing: 'content-length',
+        };
+    }
+}
+/**
+ * Accepts both SDK newline-delimited stdio JSON-RPC and Content-Length framed MCP messages.
+ */
+export class FramingAwareStdioServerTransport {
+    stdin;
+    stdout;
+    readBuffer = new FramingAwareReadBuffer();
+    started = false;
+    responseFraming = 'newline';
+    onclose;
+    onerror;
+    onmessage;
+    constructor(stdin = process.stdin, stdout = process.stdout) {
+        this.stdin = stdin;
+        this.stdout = stdout;
+    }
+    ondata = (chunk) => {
+        this.readBuffer.append(chunk);
+        this.processReadBuffer();
+    };
+    onstreamerror = (error) => {
+        this.onerror?.(error);
+    };
+    async start() {
+        if (this.started) {
+            throw new Error('FramingAwareStdioServerTransport already started');
+        }
+        this.started = true;
+        this.stdin.on('data', this.ondata);
+        this.stdin.on('error', this.onstreamerror);
+    }
+    async close() {
+        this.stdin.off('data', this.ondata);
+        this.stdin.off('error', this.onstreamerror);
+        if (this.stdin.listenerCount('data') === 0) {
+            this.stdin.pause();
+        }
+        this.readBuffer.clear();
+        this.onclose?.();
+    }
+    send(message) {
+        return new Promise((resolve) => {
+            const json = JSON.stringify(message);
+            const output = this.responseFraming === 'content-length'
+                ? `Content-Length: ${Buffer.byteLength(json, 'utf8')}\r\n\r\n${json}`
+                : `${json}\n`;
+            if (this.stdout.write(output)) {
+                resolve();
+            }
+            else {
+                this.stdout.once('drain', resolve);
+            }
+        });
+    }
+    processReadBuffer() {
+        while (true) {
+            try {
+                const parsed = this.readBuffer.readMessage();
+                if (parsed === null) {
+                    break;
+                }
+                this.responseFraming = parsed.framing;
+                this.onmessage?.(parsed.message);
+            }
+            catch (error) {
+                this.onerror?.(error instanceof Error ? error : new Error(String(error)));
+            }
+        }
+    }
+}
+function deserializeMessage(json) {
+    return JSONRPCMessageSchema.parse(JSON.parse(json));
+}
+function startsWithContentLengthHeader(buffer) {
+    return buffer.subarray(0, 'Content-Length:'.length).toString('utf8').toLowerCase() === 'content-length:';
+}
+function findHeader(buffer) {
+    const crlfIndex = buffer.indexOf('\r\n\r\n');
+    if (crlfIndex !== -1) {
+        return { endIndex: crlfIndex, separatorLength: 4 };
+    }
+    const lfIndex = buffer.indexOf('\n\n');
+    if (lfIndex !== -1) {
+        return { endIndex: lfIndex, separatorLength: 2 };
+    }
+    return undefined;
+}
+function parseContentLength(header) {
+    const match = /^Content-Length:\s*(\d+)\s*$/im.exec(header);
+    return match ? Number(match[1]) : undefined;
+}

package/dist/src/mcp/server.js

@@ -1,11 +1,13 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ErrorCode, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, McpError, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { FramingAwareStdioServerTransport } from './framingAwareStdioTransport.js';
 import { buildToolRegistry } from './registerTools.js';
 export async function createMcpServer(context) {
     const server = new McpServer({
         name: 'autotests-ultimate-testing-overkill',
         version: '1.1.0',
     });
+    registerEmptyResourceHandlers(server);
     for (const tool of buildToolRegistry()) {
         server.registerTool(tool.name, {
             title: tool.name,
@@ -22,8 +24,24 @@ export async function createMcpServer(context) {
     }
     return server;
 }
+function registerEmptyResourceHandlers(server) {
+    server.server.registerCapabilities({
+        resources: {
+            listChanged: true,
+        },
+    });
+    server.server.setRequestHandler(ListResourcesRequestSchema, () => ({
+        resources: [],
+    }));
+    server.server.setRequestHandler(ListResourceTemplatesRequestSchema, () => ({
+        resourceTemplates: [],
+    }));
+    server.server.setRequestHandler(ReadResourceRequestSchema, (request) => {
+        throw new McpError(ErrorCode.InvalidParams, `Resource ${request.params.uri} not found`);
+    });
+}
 export async function runMcpServer(context) {
     const server = await createMcpServer(context);
-    const transport = new StdioServerTransport();
+    const transport = new FramingAwareStdioServerTransport();
     await server.connect(transport);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mknrt/autotests-overkill",
-  "version": "1.2.3",
+  "version": "1.2.6",
   "private": false,
   "type": "module",
   "description": "AI-assisted testing intelligence platform for autotests2, caseplatform-web, and CI artifacts",