@ai-ecoverse/mcpcat 0.4.0 → 0.5.0

package/dist/host/mcpcat.mjs

@@ -1708,6 +1708,185 @@ var StreamableHttpTransport = class extends TransportEvents {
   }
 };
 
+// src/client/platform-stdio-transport.ts
+var DEFAULT_MAX_MESSAGE_BYTES2 = 4 * 1024 * 1024;
+var DEFAULT_MAX_STDERR_BYTES2 = 64 * 1024;
+var DEFAULT_CLOSE_TIMEOUT_MS2 = 2e3;
+var STDIN_CLOSE_GRACE_MS2 = 500;
+var PlatformStdioTransport = class {
+  options;
+  process;
+  started = false;
+  closed = false;
+  closeEmitted = false;
+  stderrText = "";
+  decoder = new TextDecoder();
+  encoder = new TextEncoder();
+  messageListeners = [];
+  errorListeners = [];
+  closeListeners = [];
+  constructor(options) {
+    this.options = options;
+  }
+  get stderr() {
+    return this.stderrText;
+  }
+  onMessage(listener) {
+    this.messageListeners.push(listener);
+    return () => {
+      this.messageListeners = this.messageListeners.filter((l) => l !== listener);
+    };
+  }
+  onError(listener) {
+    this.errorListeners.push(listener);
+    return () => {
+      this.errorListeners = this.errorListeners.filter((l) => l !== listener);
+    };
+  }
+  onClose(listener) {
+    this.closeListeners.push(listener);
+    return () => {
+      this.closeListeners = this.closeListeners.filter((l) => l !== listener);
+    };
+  }
+  emitMessage(message) {
+    for (const l of [...this.messageListeners]) l(message);
+  }
+  emitError(error) {
+    for (const l of [...this.errorListeners]) l(error);
+  }
+  emitClose() {
+    if (this.closeEmitted) return;
+    this.closeEmitted = true;
+    for (const l of [...this.closeListeners]) l();
+  }
+  async start() {
+    if (this.started) throw new Error("MCP stdio transport already started");
+    if (this.closed) throw new Error("MCP connection closed");
+    this.started = true;
+    const env = this.options.inheritEnv === false ? { ...this.options.env ?? {} } : {
+      ...this.options.platform.env,
+      ...this.options.env
+    };
+    this.process = await this.options.platform.spawn({
+      argv: [this.options.command, ...this.options.args ?? []],
+      env,
+      cwd: this.options.cwd
+    });
+    void this.readStdout();
+    void this.readStderr();
+    void this.waitForExit();
+  }
+  async send(message) {
+    if (!this.started || this.closed || !this.process) throw new Error("MCP connection closed");
+    const payload = `${JSON.stringify(message)}
+`;
+    const writer = this.process.stdin.getWriter();
+    try {
+      await writer.write(this.encoder.encode(payload));
+    } finally {
+      writer.releaseLock();
+    }
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    const proc = this.process;
+    if (!proc) {
+      this.emitClose();
+      return;
+    }
+    const closeTimeoutMs = this.options.closeTimeoutMs ?? DEFAULT_CLOSE_TIMEOUT_MS2;
+    const grace = Math.min(STDIN_CLOSE_GRACE_MS2, closeTimeoutMs);
+    const done = proc.wait().then(() => true);
+    const delay = (ms) => new Promise((r) => setTimeout(() => r(false), ms));
+    try {
+      await proc.stdin.close();
+    } catch {
+    }
+    const exited = await Promise.race([done, delay(grace)]);
+    if (!exited) {
+      proc.kill("SIGTERM");
+      const exitedAfterTerm = await Promise.race([done, delay(closeTimeoutMs)]);
+      if (!exitedAfterTerm) {
+        proc.kill("SIGKILL");
+        await done;
+      }
+    }
+    proc.kill("SIGTERM");
+    this.emitClose();
+  }
+  async readStdout() {
+    const proc = this.process;
+    if (!proc) return;
+    const reader = proc.stdout.getReader();
+    const maxBytes = this.options.maxMessageBytes ?? DEFAULT_MAX_MESSAGE_BYTES2;
+    let buffer = "";
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += this.decoder.decode(value, { stream: true });
+        let nlIdx = buffer.indexOf("\n");
+        while (nlIdx >= 0) {
+          const line = buffer.slice(0, nlIdx).replace(/\r$/, "");
+          buffer = buffer.slice(nlIdx + 1);
+          if (line.trim()) {
+            try {
+              this.emitMessage(parseJsonRpcMessage(JSON.parse(line)));
+            } catch (err) {
+              this.emitError(err);
+            }
+          }
+          nlIdx = buffer.indexOf("\n");
+        }
+        if (this.encoder.encode(buffer).length > maxBytes) {
+          buffer = "";
+          this.emitError(new Error(`MCP stdio message exceeds ${maxBytes} bytes`));
+        }
+      }
+      buffer += this.decoder.decode();
+      if (buffer.trim()) {
+        this.emitError(new Error("MCP stdio server closed with an incomplete JSON-RPC message"));
+      }
+    } catch (err) {
+      if (!this.closed) this.emitError(err);
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  async readStderr() {
+    const proc = this.process;
+    if (!proc) return;
+    const reader = proc.stderr.getReader();
+    const maxBytes = this.options.maxStderrBytes ?? DEFAULT_MAX_STDERR_BYTES2;
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const chunk = this.decoder.decode(value, { stream: true });
+        this.stderrText += chunk;
+        if (this.encoder.encode(this.stderrText).length > maxBytes) {
+          this.stderrText = this.stderrText.slice(-maxBytes);
+        }
+        this.options.onStderr?.(chunk);
+      }
+    } catch {
+    }
+  }
+  async waitForExit() {
+    const proc = this.process;
+    if (!proc) return;
+    try {
+      await proc.wait();
+    } catch {
+    }
+    if (!this.closed) {
+      this.emitClose();
+    }
+  }
+};
+
 // src/client/pi-connection.ts
 async function createPiConnection(options) {
   const clientOptions = {
@@ -1719,17 +1898,29 @@ async function createPiConnection(options) {
   if (options.url) {
     transport = new StreamableHttpTransport({
       url: options.url,
-      headers: options.headers
+      headers: options.headers,
+      fetch: options.fetchImpl
     });
   } else if (options.command) {
-    transport = new StdioTransport({
-      command: options.command,
-      args: options.args,
-      env: options.env,
-      cwd: options.cwd,
-      inheritEnv: true,
-      stderr: "pipe"
-    });
+    if (options.platform) {
+      transport = new PlatformStdioTransport({
+        command: options.command,
+        args: options.args,
+        env: options.env,
+        cwd: options.cwd,
+        inheritEnv: true,
+        platform: options.platform
+      });
+    } else {
+      transport = new StdioTransport({
+        command: options.command,
+        args: options.args,
+        env: options.env,
+        cwd: options.cwd,
+        inheritEnv: true,
+        stderr: "pipe"
+      });
+    }
   } else {
     throw new Error("PiConnection requires either a url or a command");
   }
@@ -1943,7 +2134,8 @@ async function connect(platform2, options) {
       args: options.args,
       env: options.env,
       cwd: options.cwd,
-      version: options.version
+      version: options.version,
+      platform: platform2
     });
   }
   if (!options.url) {
@@ -1953,7 +2145,9 @@ async function connect(platform2, options) {
     return createPiConnection({
       url: options.url,
       headers: options.headers,
-      version: options.version
+      version: options.version,
+      fetchImpl: platform2.fetch,
+      platform: platform2
     });
   }
   try {
@@ -1972,7 +2166,9 @@ async function connect(platform2, options) {
       return createPiConnection({
         url: options.url,
         headers: options.headers,
-        version: options.version
+        version: options.version,
+        fetchImpl: platform2.fetch,
+        platform: platform2
       });
     }
     throw err;
@@ -4905,6 +5101,21 @@ function renderCallResult(result) {
   }
   return parts.join("\n");
 }
+var NETWORK_HINT = "connection failed (use slicc-node, slicc-swift, or the browser extension for servers without CORS)";
+function transportHint(err) {
+  if (err instanceof TypeError) {
+    const cause = err.cause;
+    if (cause?.code === "ECONNREFUSED" || cause?.code === "ENETUNREACH") {
+      return `connection failed: ${err.message}`;
+    }
+  }
+  if (err instanceof Error && "status" in err && err.status === 502) {
+    const msg = err.message;
+    if (msg) return `${NETWORK_HINT}: ${msg}`;
+    return NETWORK_HINT;
+  }
+  return void 0;
+}
 async function readDataArg(platform2, dataArg) {
   let raw;
   if (dataArg.startsWith("@-")) {
@@ -5146,7 +5357,8 @@ async function run(platform2, version, args2) {
       version
     });
   } catch (err) {
-    await platform2.write(2, `mcpcat: connection failed: ${err.message}
+    const msg = transportHint(err) ?? `connection failed: ${err.message}`;
+    await platform2.write(2, `mcpcat: ${msg}
 `);
     return 3;
   }
@@ -5176,11 +5388,13 @@ import { access, mkdir, readFile as readFile2, rename, rmdir, stat, writeFile }
 import { createServer } from "node:net";
 import { Readable, Writable } from "node:stream";
 import * as tty from "node:tty";
+var USE_PROCESS_GROUPS2 = process.platform !== "win32";
 function nodeSpawn(options) {
   const child = cpSpawn(options.argv[0], options.argv.slice(1), {
     env: options.env ?? process.env,
     cwd: options.cwd,
-    stdio: ["pipe", "pipe", "pipe"]
+    stdio: ["pipe", "pipe", "pipe"],
+    detached: USE_PROCESS_GROUPS2
   });
   const stdout = Readable.toWeb(child.stdout);
   const stderr = Readable.toWeb(child.stderr);
@@ -5200,7 +5414,19 @@ function nodeSpawn(options) {
       });
     },
     kill(signal) {
-      child.kill(signal ?? "SIGTERM");
+      const sig = signal ?? "SIGTERM";
+      const pid = child.pid;
+      if (USE_PROCESS_GROUPS2 && pid !== void 0) {
+        try {
+          process.kill(-pid, sig);
+          return;
+        } catch {
+        }
+      }
+      try {
+        child.kill(sig);
+      } catch {
+      }
     }
   });
 }
@@ -5354,5 +5580,5 @@ function createHostPlatform() {
 // src/host.ts
 var platform = createHostPlatform();
 var args = process.argv.slice(2);
-var code = await run(platform, "0.4.0", args);
+var code = await run(platform, "0.5.0", args);
 process.exit(code);

package/dist/kernel/mcpcat.mjs

@@ -1,3 +1,5 @@
+var __mcpcat_byteLength = (s) => new TextEncoder().encode(s).length;
+
 // node_modules/@earendil-works/pi-mcp/dist/protocol/jsonrpc.js
 var JSON_RPC_ERROR_CODES = {
   parseError: -32700,
@@ -772,7 +774,7 @@ async function consumeSseStream(stream, options) {
     if (value.startsWith(" "))
       value = value.slice(1);
     if (field === "data") {
-      dataBytes += Buffer.byteLength(value) + (dataLines.length > 0 ? 1 : 0);
+      dataBytes += __mcpcat_byteLength(value) + (dataLines.length > 0 ? 1 : 0);
       if (dataBytes > maxEventBytes)
         throw new Error(`MCP SSE event exceeds ${maxEventBytes} bytes`);
       dataLines.push(value);
@@ -796,7 +798,7 @@ async function consumeSseStream(stream, options) {
         buffered = buffered.slice(newline + 1);
         newline = buffered.indexOf("\n");
       }
-      if (Buffer.byteLength(buffered) > maxEventBytes)
+      if (__mcpcat_byteLength(buffered) > maxEventBytes)
         throw new Error(`MCP SSE event exceeds ${maxEventBytes} bytes`);
     }
     buffered += decoder2.decode();
@@ -1173,6 +1175,185 @@ var StreamableHttpTransport = class extends TransportEvents {
   }
 };
 
+// src/client/platform-stdio-transport.ts
+var DEFAULT_MAX_MESSAGE_BYTES2 = 4 * 1024 * 1024;
+var DEFAULT_MAX_STDERR_BYTES2 = 64 * 1024;
+var DEFAULT_CLOSE_TIMEOUT_MS2 = 2e3;
+var STDIN_CLOSE_GRACE_MS2 = 500;
+var PlatformStdioTransport = class {
+  options;
+  process;
+  started = false;
+  closed = false;
+  closeEmitted = false;
+  stderrText = "";
+  decoder = new TextDecoder();
+  encoder = new TextEncoder();
+  messageListeners = [];
+  errorListeners = [];
+  closeListeners = [];
+  constructor(options) {
+    this.options = options;
+  }
+  get stderr() {
+    return this.stderrText;
+  }
+  onMessage(listener) {
+    this.messageListeners.push(listener);
+    return () => {
+      this.messageListeners = this.messageListeners.filter((l) => l !== listener);
+    };
+  }
+  onError(listener) {
+    this.errorListeners.push(listener);
+    return () => {
+      this.errorListeners = this.errorListeners.filter((l) => l !== listener);
+    };
+  }
+  onClose(listener) {
+    this.closeListeners.push(listener);
+    return () => {
+      this.closeListeners = this.closeListeners.filter((l) => l !== listener);
+    };
+  }
+  emitMessage(message) {
+    for (const l of [...this.messageListeners]) l(message);
+  }
+  emitError(error) {
+    for (const l of [...this.errorListeners]) l(error);
+  }
+  emitClose() {
+    if (this.closeEmitted) return;
+    this.closeEmitted = true;
+    for (const l of [...this.closeListeners]) l();
+  }
+  async start() {
+    if (this.started) throw new Error("MCP stdio transport already started");
+    if (this.closed) throw new Error("MCP connection closed");
+    this.started = true;
+    const env = this.options.inheritEnv === false ? { ...this.options.env ?? {} } : {
+      ...this.options.platform.env,
+      ...this.options.env
+    };
+    this.process = await this.options.platform.spawn({
+      argv: [this.options.command, ...this.options.args ?? []],
+      env,
+      cwd: this.options.cwd
+    });
+    void this.readStdout();
+    void this.readStderr();
+    void this.waitForExit();
+  }
+  async send(message) {
+    if (!this.started || this.closed || !this.process) throw new Error("MCP connection closed");
+    const payload = `${JSON.stringify(message)}
+`;
+    const writer = this.process.stdin.getWriter();
+    try {
+      await writer.write(this.encoder.encode(payload));
+    } finally {
+      writer.releaseLock();
+    }
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    const proc = this.process;
+    if (!proc) {
+      this.emitClose();
+      return;
+    }
+    const closeTimeoutMs = this.options.closeTimeoutMs ?? DEFAULT_CLOSE_TIMEOUT_MS2;
+    const grace = Math.min(STDIN_CLOSE_GRACE_MS2, closeTimeoutMs);
+    const done = proc.wait().then(() => true);
+    const delay = (ms) => new Promise((r) => setTimeout(() => r(false), ms));
+    try {
+      await proc.stdin.close();
+    } catch {
+    }
+    const exited = await Promise.race([done, delay(grace)]);
+    if (!exited) {
+      proc.kill("SIGTERM");
+      const exitedAfterTerm = await Promise.race([done, delay(closeTimeoutMs)]);
+      if (!exitedAfterTerm) {
+        proc.kill("SIGKILL");
+        await done;
+      }
+    }
+    proc.kill("SIGTERM");
+    this.emitClose();
+  }
+  async readStdout() {
+    const proc = this.process;
+    if (!proc) return;
+    const reader = proc.stdout.getReader();
+    const maxBytes = this.options.maxMessageBytes ?? DEFAULT_MAX_MESSAGE_BYTES2;
+    let buffer = "";
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += this.decoder.decode(value, { stream: true });
+        let nlIdx = buffer.indexOf("\n");
+        while (nlIdx >= 0) {
+          const line = buffer.slice(0, nlIdx).replace(/\r$/, "");
+          buffer = buffer.slice(nlIdx + 1);
+          if (line.trim()) {
+            try {
+              this.emitMessage(parseJsonRpcMessage(JSON.parse(line)));
+            } catch (err) {
+              this.emitError(err);
+            }
+          }
+          nlIdx = buffer.indexOf("\n");
+        }
+        if (this.encoder.encode(buffer).length > maxBytes) {
+          buffer = "";
+          this.emitError(new Error(`MCP stdio message exceeds ${maxBytes} bytes`));
+        }
+      }
+      buffer += this.decoder.decode();
+      if (buffer.trim()) {
+        this.emitError(new Error("MCP stdio server closed with an incomplete JSON-RPC message"));
+      }
+    } catch (err) {
+      if (!this.closed) this.emitError(err);
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  async readStderr() {
+    const proc = this.process;
+    if (!proc) return;
+    const reader = proc.stderr.getReader();
+    const maxBytes = this.options.maxStderrBytes ?? DEFAULT_MAX_STDERR_BYTES2;
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const chunk = this.decoder.decode(value, { stream: true });
+        this.stderrText += chunk;
+        if (this.encoder.encode(this.stderrText).length > maxBytes) {
+          this.stderrText = this.stderrText.slice(-maxBytes);
+        }
+        this.options.onStderr?.(chunk);
+      }
+    } catch {
+    }
+  }
+  async waitForExit() {
+    const proc = this.process;
+    if (!proc) return;
+    try {
+      await proc.wait();
+    } catch {
+    }
+    if (!this.closed) {
+      this.emitClose();
+    }
+  }
+};
+
 // src/client/pi-connection.ts
 async function createPiConnection(options) {
   const clientOptions = {
@@ -1184,17 +1365,29 @@ async function createPiConnection(options) {
   if (options.url) {
     transport = new StreamableHttpTransport({
       url: options.url,
-      headers: options.headers
+      headers: options.headers,
+      fetch: options.fetchImpl
     });
   } else if (options.command) {
-    transport = new StdioTransport({
-      command: options.command,
-      args: options.args,
-      env: options.env,
-      cwd: options.cwd,
-      inheritEnv: true,
-      stderr: "pipe"
-    });
+    if (options.platform) {
+      transport = new PlatformStdioTransport({
+        command: options.command,
+        args: options.args,
+        env: options.env,
+        cwd: options.cwd,
+        inheritEnv: true,
+        platform: options.platform
+      });
+    } else {
+      transport = new StdioTransport({
+        command: options.command,
+        args: options.args,
+        env: options.env,
+        cwd: options.cwd,
+        inheritEnv: true,
+        stderr: "pipe"
+      });
+    }
   } else {
     throw new Error("PiConnection requires either a url or a command");
   }
@@ -1408,7 +1601,8 @@ async function connect(platform, options) {
       args: options.args,
       env: options.env,
       cwd: options.cwd,
-      version: options.version
+      version: options.version,
+      platform
     });
   }
   if (!options.url) {
@@ -1418,7 +1612,9 @@ async function connect(platform, options) {
     return createPiConnection({
       url: options.url,
       headers: options.headers,
-      version: options.version
+      version: options.version,
+      fetchImpl: platform.fetch,
+      platform
     });
   }
   try {
@@ -1437,7 +1633,9 @@ async function connect(platform, options) {
       return createPiConnection({
         url: options.url,
         headers: options.headers,
-        version: options.version
+        version: options.version,
+        fetchImpl: platform.fetch,
+        platform
       });
     }
     throw err;
@@ -4370,6 +4568,21 @@ function renderCallResult(result) {
   }
   return parts.join("\n");
 }
+var NETWORK_HINT = "connection failed (use slicc-node, slicc-swift, or the browser extension for servers without CORS)";
+function transportHint(err) {
+  if (err instanceof TypeError) {
+    const cause = err.cause;
+    if (cause?.code === "ECONNREFUSED" || cause?.code === "ENETUNREACH") {
+      return `connection failed: ${err.message}`;
+    }
+  }
+  if (err instanceof Error && "status" in err && err.status === 502) {
+    const msg = err.message;
+    if (msg) return `${NETWORK_HINT}: ${msg}`;
+    return NETWORK_HINT;
+  }
+  return void 0;
+}
 async function readDataArg(platform, dataArg) {
   let raw;
   if (dataArg.startsWith("@-")) {
@@ -4611,7 +4824,8 @@ async function run(platform, version, args) {
       version
     });
   } catch (err) {
-    await platform.write(2, `mcpcat: connection failed: ${err.message}
+    const msg = transportHint(err) ?? `connection failed: ${err.message}`;
+    await platform.write(2, `mcpcat: ${msg}
 `);
     return 3;
   }
@@ -4664,12 +4878,22 @@ async function kernelSpawn(ctx, options) {
     stdout: "pipe",
     stderr: "pipe"
   });
+  const childPid = result.pid;
   return {
     stdin: result.stdin,
     stdout: result.stdout,
     stderr: result.stderr,
     wait: () => result.wait(),
-    kill: (signal) => result.kill(signal)
+    kill: (signal) => {
+      try {
+        ctx.kill(-childPid, signal);
+      } catch {
+      }
+      try {
+        ctx.kill(childPid, signal);
+      } catch {
+      }
+    }
   };
 }
 async function kernelListen(ctx, options) {
@@ -4735,7 +4959,7 @@ function createKernelPlatform(ctx) {
 async function main(ctx) {
   const platform = createKernelPlatform(ctx);
   const args = ctx.argv.slice(1);
-  return run(platform, "0.4.0", args);
+  return run(platform, "0.5.0", args);
 }
 export {
   main as default

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-ecoverse/mcpcat",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "A curl for the Model Context Protocol",
   "type": "module",
   "license": "Apache-2.0",
@@ -17,7 +17,7 @@
   },
   "engines": {
     "node": ">=24",
-    "slicc-kernel": ">=1.64.2"
+    "slicc-kernel": ">=1.65.2"
   },
   "publishConfig": {
     "access": "public",
@@ -46,9 +46,10 @@
     "build": "node scripts/build.mjs",
     "lint": "sh scripts/lint.sh",
     "typecheck": "tsc",
-    "test": "npm run test:unit && npm run test:integration",
+    "test": "npm run test:unit && npm run test:integration && npm run test:kernel-min",
     "test:unit": "mcr -c node_modules/@ai-ecoverse/slicc-shared-web/mcr.config.mjs node --test 'test/unit/**/*.test.mjs'",
     "test:integration": "node --test --test-timeout=30000 test/integration/*.test.mjs",
+    "test:kernel-min": "node scripts/test-kernel-min.mjs",
     "cert": "node --test --test-timeout=120000 test/integration/cert.test.mjs test/integration/serve-soak.cert.mjs",
     "release": "semantic-release",
     "trust": "npx fledgling sync -y --skip-publish",