token-goat 2.6.35 → 2.8.0

package/dist/token-goat-chunk-324QOJYZ.mjs

@@ -0,0 +1,91 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import "./token-goat-chunk-AEX54RUZ.mjs";
+
+// src/mcp_stdio.ts
+import process from "node:process";
+var STDIO_MAX_BUFFER_BYTES = 10 * 1024 * 1024;
+var StdioServerTransport = class {
+  stdin;
+  stdout;
+  buffer;
+  started = false;
+  onmessage;
+  onclose;
+  onerror;
+  // Arrow properties rather than bound methods so `off()` can remove the exact same function
+  // reference `on()` added -- a fresh `.bind(this)` at removal time would leave the listener
+  // attached, and a second `mcp-serve` in the same process would then see every message twice.
+  ondata = (chunk) => {
+    const size = (this.buffer?.length ?? 0) + chunk.length;
+    if (size > STDIO_MAX_BUFFER_BYTES) {
+      this.buffer = void 0;
+      this.onerror?.(new Error(`MCP stdio read buffer exceeded ${STDIO_MAX_BUFFER_BYTES} bytes`));
+      void this.close();
+      return;
+    }
+    this.buffer = this.buffer === void 0 ? chunk : Buffer.concat([this.buffer, chunk]);
+    this.drain();
+  };
+  onstreamerror = (error) => {
+    this.onerror?.(error);
+  };
+  constructor(stdin = process.stdin, stdout = process.stdout) {
+    this.stdin = stdin;
+    this.stdout = stdout;
+  }
+  async start() {
+    if (this.started) throw new Error("StdioServerTransport already started");
+    this.started = true;
+    this.stdin.on("data", this.ondata);
+    this.stdin.on("error", this.onstreamerror);
+    return Promise.resolve();
+  }
+  /**
+   * Consumes every complete line currently buffered. A line that is not valid JSON is reported and
+   * skipped rather than closing the connection: one malformed message is not a reason to drop a
+   * working session, and the next line may well be fine.
+   */
+  drain() {
+    for (; ; ) {
+      const buffer = this.buffer;
+      if (buffer === void 0) return;
+      const index = buffer.indexOf("\n");
+      if (index === -1) return;
+      const line = buffer.toString("utf8", 0, index).replace(/\r$/, "");
+      this.buffer = buffer.subarray(index + 1);
+      if (line.trim().length === 0) continue;
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch (err) {
+        this.onerror?.(err instanceof Error ? err : new Error(String(err)));
+        continue;
+      }
+      this.onmessage?.(message);
+    }
+  }
+  /**
+   * Resolves once the message is handed off. Waiting for `drain` when the stream says it is full
+   * is what keeps a long reply from being silently truncated on a slow or small pipe.
+   */
+  send(message) {
+    return new Promise((resolve) => {
+      if (this.stdout.write(`${JSON.stringify(message)}
+`)) resolve();
+      else this.stdout.once("drain", resolve);
+    });
+  }
+  async close() {
+    this.stdin.off("data", this.ondata);
+    this.stdin.off("error", this.onstreamerror);
+    if (this.stdin.listenerCount("data") === 0) this.stdin.pause();
+    this.buffer = void 0;
+    this.onclose?.();
+    return Promise.resolve();
+  }
+};
+export {
+  STDIO_MAX_BUFFER_BYTES,
+  StdioServerTransport
+};