@adhisang/minecraft-modding-mcp 1.2.1 → 2.1.0

package/dist/compat-stdio-transport.js

@@ -1,29 +1,14 @@
 import process from "node:process";
-import { JSONRPCMessageSchema } from "@modelcontextprotocol/sdk/types.js";
-function findHeaderBoundary(buffer) {
-    const crlfBoundary = buffer.indexOf("\r\n\r\n");
-    if (crlfBoundary !== -1) {
-        return { index: crlfBoundary, delimiterBytes: 4 };
-    }
-    const lfBoundary = buffer.indexOf("\n\n");
-    if (lfBoundary !== -1) {
-        return { index: lfBoundary, delimiterBytes: 2 };
-    }
-    return undefined;
-}
-function parseJsonRpcMessage(json) {
-    return JSONRPCMessageSchema.parse(JSON.parse(json));
-}
+import { JsonRpcFrameReader, encodeJsonRpcMessage } from "./json-rpc-framing.js";
 function asError(value) {
     return value instanceof Error ? value : new Error(String(value));
 }
 export class CompatStdioServerTransport {
     stdin;
     stdout;
+    frameReader = new JsonRpcFrameReader();
     started = false;
     closed = false;
-    mode = "unknown";
-    buffer = Buffer.alloc(0);
     onclose;
     onerror;
     onmessage;
@@ -43,10 +28,7 @@ export class CompatStdioServerTransport {
         this.stdin.resume();
     }
     async send(message) {
-        const json = JSON.stringify(message);
-        const frame = this.mode === "content-length"
-            ? `Content-Length: ${Buffer.byteLength(json, "utf8")}\r\n\r\n${json}`
-            : `${json}\n`;
+        const frame = encodeJsonRpcMessage(message, this.frameReader.currentMode === "content-length" ? "content-length" : "line");
         await new Promise((resolve) => {
             if (this.stdout.write(frame)) {
                 resolve();
@@ -63,15 +45,18 @@ export class CompatStdioServerTransport {
         if (this.stdin.listenerCount("data") === 0) {
             this.stdin.pause();
         }
-        this.buffer = Buffer.alloc(0);
+        this.frameReader.clear();
         this.emitCloseOnce();
     }
     handleData = (chunk) => {
-        if (chunk.length === 0) {
-            return;
-        }
-        this.buffer = Buffer.concat([this.buffer, chunk]);
-        this.processReadBuffer();
+        this.frameReader.processChunk(chunk, {
+            onFrame: ({ message }) => {
+                this.onmessage?.(message);
+            },
+            onError: (error) => {
+                this.onerror?.(error);
+            }
+        });
     };
     handleStreamError = (error) => {
         this.onerror?.(error);
@@ -86,132 +71,5 @@ export class CompatStdioServerTransport {
         this.closed = true;
         this.onclose?.();
     }
-    processReadBuffer() {
-        while (true) {
-            try {
-                if (this.mode === "unknown") {
-                    const detected = this.detectMode();
-                    if (!detected) {
-                        return;
-                    }
-                    this.mode = detected;
-                    continue;
-                }
-                const modeBefore = this.mode;
-                const message = this.mode === "content-length"
-                    ? this.readContentLengthMessage()
-                    : this.readLineDelimitedMessage();
-                if (!message) {
-                    // readLineDelimitedMessage may switch mode to "content-length"
-                    // mid-stream; retry with the new parser instead of stopping.
-                    if (this.mode !== modeBefore) {
-                        continue;
-                    }
-                    return;
-                }
-                this.onmessage?.(message);
-            }
-            catch (caughtError) {
-                this.onerror?.(asError(caughtError));
-                this.mode = "unknown";
-            }
-        }
-    }
-    detectMode() {
-        // Skip blank leading lines that some clients may emit.
-        while (this.buffer.length > 0) {
-            if (this.buffer[0] === 0x0a) {
-                this.buffer = this.buffer.subarray(1);
-                continue;
-            }
-            if (this.buffer.length >= 2 && this.buffer[0] === 0x0d && this.buffer[1] === 0x0a) {
-                this.buffer = this.buffer.subarray(2);
-                continue;
-            }
-            break;
-        }
-        if (this.buffer.length === 0) {
-            return undefined;
-        }
-        const prefix = this.buffer
-            .subarray(0, Math.min(this.buffer.length, 32))
-            .toString("utf8")
-            .toLowerCase();
-        if (prefix.startsWith("content-length")) {
-            return "content-length";
-        }
-        const firstNewline = this.buffer.indexOf(0x0a);
-        if (firstNewline === -1) {
-            return undefined;
-        }
-        const firstLine = this.buffer.subarray(0, firstNewline).toString("utf8").replace(/\r$/, "");
-        if (/^\s*content-length\s*:/i.test(firstLine)) {
-            return "content-length";
-        }
-        return "line";
-    }
-    readLineDelimitedMessage() {
-        while (true) {
-            const newlineIndex = this.buffer.indexOf(0x0a);
-            if (newlineIndex === -1) {
-                return undefined;
-            }
-            const line = this.buffer.subarray(0, newlineIndex).toString("utf8").replace(/\r$/, "");
-            this.buffer = this.buffer.subarray(newlineIndex + 1);
-            if (line.trim().length === 0) {
-                continue;
-            }
-            if (/^\s*content-length\s*:/i.test(line)) {
-                // Reconstruct the header with the correct line ending so that
-                // findHeaderBoundary can locate \r\n\r\n or \n\n reliably.
-                const sep = this.buffer.length > 0 && this.buffer[0] === 0x0d ? "\r\n" : "\n";
-                this.buffer = Buffer.concat([Buffer.from(`${line}${sep}`, "utf8"), this.buffer]);
-                this.mode = "content-length";
-                return undefined;
-            }
-            return parseJsonRpcMessage(line);
-        }
-    }
-    readContentLengthMessage() {
-        const headerBoundary = findHeaderBoundary(this.buffer);
-        if (!headerBoundary) {
-            return undefined;
-        }
-        const headersRaw = this.buffer.subarray(0, headerBoundary.index).toString("utf8");
-        const headerLines = headersRaw
-            .split(/\r?\n/)
-            .map((line) => line.trim())
-            .filter((line) => line.length > 0);
-        let contentLength;
-        for (const headerLine of headerLines) {
-            const separatorIndex = headerLine.indexOf(":");
-            if (separatorIndex === -1) {
-                this.buffer = this.buffer.subarray(headerBoundary.index + headerBoundary.delimiterBytes);
-                throw new Error(`Malformed header line: ${headerLine}`);
-            }
-            const headerName = headerLine.slice(0, separatorIndex).trim().toLowerCase();
-            const headerValue = headerLine.slice(separatorIndex + 1).trim();
-            if (headerName === "content-length") {
-                const parsed = Number.parseInt(headerValue, 10);
-                if (!Number.isFinite(parsed) || parsed < 0) {
-                    this.buffer = this.buffer.subarray(headerBoundary.index + headerBoundary.delimiterBytes);
-                    throw new Error(`Invalid Content-Length header value: ${headerValue}`);
-                }
-                contentLength = parsed;
-            }
-        }
-        if (contentLength === undefined) {
-            this.buffer = this.buffer.subarray(headerBoundary.index + headerBoundary.delimiterBytes);
-            throw new Error("Missing Content-Length header.");
-        }
-        const messageStart = headerBoundary.index + headerBoundary.delimiterBytes;
-        const frameEnd = messageStart + contentLength;
-        if (this.buffer.length < frameEnd) {
-            return undefined;
-        }
-        const body = this.buffer.subarray(messageStart, frameEnd).toString("utf8");
-        this.buffer = this.buffer.subarray(frameEnd);
-        return parseJsonRpcMessage(body);
-    }
 }
 //# sourceMappingURL=compat-stdio-transport.js.map