jjhub 0.1.5 → 0.1.7

package/dist/cli/jjhub.mjs

@@ -26536,6 +26536,155 @@ var init_dist = __esm({
   }
 });
 
+// node_modules/@modelcontextprotocol/sdk/node_modules/content-type/index.js
+var require_content_type = __commonJS({
+  "node_modules/@modelcontextprotocol/sdk/node_modules/content-type/index.js"(exports) {
+    "use strict";
+    var PARAM_REGEXP = /; *([!#$%&'*+.^_`|~0-9A-Za-z-]+) *= *("(?:[\u000b\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\u000b\u0020-\u00ff])*"|[!#$%&'*+.^_`|~0-9A-Za-z-]+) */g;
+    var TEXT_REGEXP = /^[\u000b\u0020-\u007e\u0080-\u00ff]+$/;
+    var TOKEN_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+    var QESC_REGEXP = /\\([\u000b\u0020-\u00ff])/g;
+    var QUOTE_REGEXP = /([\\"])/g;
+    var TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+    exports.format = format;
+    exports.parse = parse3;
+    function format(obj) {
+      if (!obj || typeof obj !== "object") {
+        throw new TypeError("argument obj is required");
+      }
+      var parameters = obj.parameters;
+      var type = obj.type;
+      if (!type || !TYPE_REGEXP.test(type)) {
+        throw new TypeError("invalid type");
+      }
+      var string4 = type;
+      if (parameters && typeof parameters === "object") {
+        var param;
+        var params = Object.keys(parameters).sort();
+        for (var i2 = 0; i2 < params.length; i2++) {
+          param = params[i2];
+          if (!TOKEN_REGEXP.test(param)) {
+            throw new TypeError("invalid parameter name");
+          }
+          string4 += "; " + param + "=" + qstring(parameters[param]);
+        }
+      }
+      return string4;
+    }
+    function parse3(string4) {
+      if (!string4) {
+        throw new TypeError("argument string is required");
+      }
+      var header = typeof string4 === "object" ? getcontenttype(string4) : string4;
+      if (typeof header !== "string") {
+        throw new TypeError("argument string is required to be a string");
+      }
+      var index4 = header.indexOf(";");
+      var type = index4 !== -1 ? header.slice(0, index4).trim() : header.trim();
+      if (!TYPE_REGEXP.test(type)) {
+        throw new TypeError("invalid media type");
+      }
+      var obj = new ContentType(type.toLowerCase());
+      if (index4 !== -1) {
+        var key;
+        var match;
+        var value;
+        PARAM_REGEXP.lastIndex = index4;
+        while (match = PARAM_REGEXP.exec(header)) {
+          if (match.index !== index4) {
+            throw new TypeError("invalid parameter format");
+          }
+          index4 += match[0].length;
+          key = match[1].toLowerCase();
+          value = match[2];
+          if (value.charCodeAt(0) === 34) {
+            value = value.slice(1, -1);
+            if (value.indexOf("\\") !== -1) {
+              value = value.replace(QESC_REGEXP, "$1");
+            }
+          }
+          obj.parameters[key] = value;
+        }
+        if (index4 !== header.length) {
+          throw new TypeError("invalid parameter format");
+        }
+      }
+      return obj;
+    }
+    function getcontenttype(obj) {
+      var header;
+      if (typeof obj.getHeader === "function") {
+        header = obj.getHeader("content-type");
+      } else if (typeof obj.headers === "object") {
+        header = obj.headers && obj.headers["content-type"];
+      }
+      if (typeof header !== "string") {
+        throw new TypeError("content-type header is missing from object");
+      }
+      return header;
+    }
+    function qstring(val) {
+      var str = String(val);
+      if (TOKEN_REGEXP.test(str)) {
+        return str;
+      }
+      if (str.length > 0 && !TEXT_REGEXP.test(str)) {
+        throw new TypeError("invalid parameter value");
+      }
+      return '"' + str.replace(QUOTE_REGEXP, "\\$1") + '"';
+    }
+    function ContentType(type) {
+      this.parameters = /* @__PURE__ */ Object.create(null);
+      this.type = type;
+    }
+  }
+});
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/mediaType.js
+function mediaTypeEssence(header) {
+  if (!header) {
+    return void 0;
+  }
+  try {
+    return import_content_type.default.parse(header).type;
+  } catch {
+    const essence = (header.split(";", 1)[0] ?? "").trim().toLowerCase();
+    if (essence === "" || header.slice(essence.length).includes(",")) {
+      return void 0;
+    }
+    return essence;
+  }
+}
+function isJsonContentType(header) {
+  if (header === "application/json") {
+    return true;
+  }
+  return mediaTypeEssence(header) === "application/json";
+}
+var import_content_type;
+var init_mediaType = __esm({
+  "node_modules/@modelcontextprotocol/sdk/dist/esm/shared/mediaType.js"() {
+    import_content_type = __toESM(require_content_type(), 1);
+  }
+});
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/server/sseKeepAlive.js
+function armSseKeepAlive(intervalMs, onTick) {
+  if (!Number.isFinite(intervalMs) || intervalMs < 1) {
+    return void 0;
+  }
+  const timer = setInterval(onTick, Math.min(intervalMs, MAX_TIMER_DELAY_MS));
+  timer.unref?.();
+  return timer;
+}
+var DEFAULT_SSE_KEEP_ALIVE_MS, MAX_TIMER_DELAY_MS;
+var init_sseKeepAlive = __esm({
+  "node_modules/@modelcontextprotocol/sdk/dist/esm/server/sseKeepAlive.js"() {
+    DEFAULT_SSE_KEEP_ALIVE_MS = 15e3;
+    MAX_TIMER_DELAY_MS = 2 ** 31 - 1;
+  }
+});
+
 // node_modules/zod/v4/core/core.js
 // @__NO_SIDE_EFFECTS__
 function $constructor(name, initializer3, params) {
@@ -43166,6 +43315,8 @@ var init_types = __esm({
 var WebStandardStreamableHTTPServerTransport;
 var init_webStandardStreamableHttp = __esm({
   "node_modules/@modelcontextprotocol/sdk/dist/esm/server/webStandardStreamableHttp.js"() {
+    init_mediaType();
+    init_sseKeepAlive();
     init_types();
     WebStandardStreamableHTTPServerTransport = class {
       constructor(options = {}) {
@@ -43173,10 +43324,12 @@ var init_webStandardStreamableHttp = __esm({
         this._hasHandledRequest = false;
         this._streamMapping = /* @__PURE__ */ new Map();
         this._requestToStreamMapping = /* @__PURE__ */ new Map();
+        this._resumableStreams = /* @__PURE__ */ new Set();
         this._requestResponseMap = /* @__PURE__ */ new Map();
         this._initialized = false;
         this._enableJsonResponse = false;
         this._standaloneSseStreamId = "_GET_stream";
+        this._closed = false;
         this.sessionIdGenerator = options.sessionIdGenerator;
         this._enableJsonResponse = options.enableJsonResponse ?? false;
         this._eventStore = options.eventStore;
@@ -43186,6 +43339,27 @@ var init_webStandardStreamableHttp = __esm({
         this._allowedOrigins = options.allowedOrigins;
         this._enableDnsRebindingProtection = options.enableDnsRebindingProtection ?? false;
         this._retryInterval = options.retryInterval;
+        this._keepAliveMs = options.keepAliveMs ?? DEFAULT_SSE_KEEP_ALIVE_MS;
+      }
+      /**
+       * Arms a keep-alive interval for an SSE stream that periodically writes an SSE
+       * comment frame so intermediaries and idle timeouts don't kill the connection.
+       * The returned timer is owned by the stream it was armed for: the stream's
+       * cancel/cleanup callbacks must clear it. The interval clears itself if a
+       * write fails (stream already closed/cancelled).
+       */
+      startKeepAlive(controller, encoder) {
+        if (this._closed)
+          return void 0;
+        const timer = armSseKeepAlive(this._keepAliveMs, () => {
+          try {
+            controller.enqueue(encoder.encode(": keepalive\n\n"));
+          } catch {
+            if (timer !== void 0)
+              clearInterval(timer);
+          }
+        });
+        return timer;
       }
       /**
        * Starts the transport. This is required by the Transport interface but is a no-op
@@ -43248,6 +43422,9 @@ var init_webStandardStreamableHttp = __esm({
        * Returns a Response object (Web Standard)
        */
       async handleRequest(req, options) {
+        if (this._closed) {
+          return this.createJsonErrorResponse(404, -32001, "Session not found");
+        }
         if (!this.sessionIdGenerator && this._hasHandledRequest) {
           throw new Error("Stateless transport cannot be reused across requests. Create a new transport per request.");
         }
@@ -43292,6 +43469,7 @@ data:
 `;
         }
         controller.enqueue(encoder.encode(primingEvent));
+        this._resumableStreams.add(streamId);
       }
       /**
        * Handles GET requests for SSE stream
@@ -43322,18 +43500,25 @@ data:
         }
         const encoder = new TextEncoder();
         let streamController;
+        let keepAliveTimer = void 0;
         const readable = new ReadableStream({
           start: (controller) => {
             streamController = controller;
           },
           cancel: () => {
-            this._streamMapping.delete(this._standaloneSseStreamId);
+            if (keepAliveTimer !== void 0) {
+              clearInterval(keepAliveTimer);
+            }
+            if (this._streamMapping.get(this._standaloneSseStreamId)?.controller === streamController) {
+              this._streamMapping.delete(this._standaloneSseStreamId);
+            }
           }
         });
         const headers = {
           "Content-Type": "text/event-stream",
           "Cache-Control": "no-cache, no-transform",
-          Connection: "keep-alive"
+          Connection: "keep-alive",
+          "X-Accel-Buffering": "no"
         };
         if (this.sessionId !== void 0) {
           headers["mcp-session-id"] = this.sessionId;
@@ -43342,6 +43527,9 @@ data:
           controller: streamController,
           encoder,
           cleanup: () => {
+            if (keepAliveTimer !== void 0) {
+              clearInterval(keepAliveTimer);
+            }
             this._streamMapping.delete(this._standaloneSseStreamId);
             try {
               streamController.close();
@@ -43349,6 +43537,7 @@ data:
             }
           }
         });
+        keepAliveTimer = this.startKeepAlive(streamController, encoder);
         return new Response(readable, { headers });
       }
       /**
@@ -43376,21 +43565,33 @@ data:
           const headers = {
             "Content-Type": "text/event-stream",
             "Cache-Control": "no-cache, no-transform",
-            Connection: "keep-alive"
+            Connection: "keep-alive",
+            "X-Accel-Buffering": "no"
           };
           if (this.sessionId !== void 0) {
             headers["mcp-session-id"] = this.sessionId;
           }
           const encoder = new TextEncoder();
           let streamController;
+          let keepAliveTimer = void 0;
+          let replayedStreamId = void 0;
+          let cancelled = false;
           const readable = new ReadableStream({
             start: (controller) => {
               streamController = controller;
             },
             cancel: () => {
+              cancelled = true;
+              if (keepAliveTimer !== void 0) {
+                clearInterval(keepAliveTimer);
+              }
+              if (replayedStreamId !== void 0 && this._streamMapping.get(replayedStreamId)?.controller === streamController) {
+                this._streamMapping.delete(replayedStreamId);
+              }
             }
           });
-          const replayedStreamId = await this._eventStore.replayEventsAfter(lastEventId, {
+          const replayedEventIds = /* @__PURE__ */ new Set();
+          replayedStreamId = await this._eventStore.replayEventsAfter(lastEventId, {
             send: async (eventId, message) => {
               const success2 = this.writeSSEEvent(streamController, encoder, message, eventId);
               if (!success2) {
@@ -43399,13 +43600,27 @@ data:
                   streamController.close();
                 } catch {
                 }
+              } else {
+                replayedEventIds.add(eventId);
               }
             }
           });
+          if (this._closed || cancelled) {
+            try {
+              streamController.close();
+            } catch {
+            }
+            return this.createJsonErrorResponse(404, -32001, "Session not found");
+          }
+          this._streamMapping.get(replayedStreamId)?.cleanup();
           this._streamMapping.set(replayedStreamId, {
             controller: streamController,
             encoder,
+            replayedEventIds,
             cleanup: () => {
+              if (keepAliveTimer !== void 0) {
+                clearInterval(keepAliveTimer);
+              }
               this._streamMapping.delete(replayedStreamId);
               try {
                 streamController.close();
@@ -43413,6 +43628,8 @@ data:
               }
             }
           });
+          this._resumableStreams.add(replayedStreamId);
+          keepAliveTimer = this.startKeepAlive(streamController, encoder);
           return new Response(readable, { headers });
         } catch (error51) {
           this.onerror?.(error51);
@@ -43471,7 +43688,7 @@ data:
             return this.createJsonErrorResponse(406, -32e3, "Not Acceptable: Client must accept both application/json and text/event-stream");
           }
           const ct = req.headers.get("content-type");
-          if (!ct || !ct.includes("application/json")) {
+          if (!isJsonContentType(ct)) {
             this.onerror?.(new Error("Unsupported Media Type: Content-Type must be application/json"));
             return this.createJsonErrorResponse(415, -32e3, "Unsupported Media Type: Content-Type must be application/json");
           }
@@ -43501,6 +43718,9 @@ data:
             this.onerror?.(new Error("Parse error: Invalid JSON-RPC message"));
             return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON-RPC message");
           }
+          if (this._closed) {
+            return this.createJsonErrorResponse(404, -32001, "Session not found");
+          }
           const isInitializationRequest = messages.some(isInitializeRequest);
           if (isInitializationRequest) {
             if (this._initialized && this.sessionId !== void 0) {
@@ -43527,6 +43747,9 @@ data:
               return protocolError;
             }
           }
+          if (this._closed) {
+            return this.createJsonErrorResponse(404, -32001, "Session not found");
+          }
           const hasRequests = messages.some(isJSONRPCRequest);
           if (!hasRequests) {
             for (const message of messages) {
@@ -43557,18 +43780,25 @@ data:
           }
           const encoder = new TextEncoder();
           let streamController;
+          let keepAliveTimer = void 0;
           const readable = new ReadableStream({
             start: (controller) => {
               streamController = controller;
             },
             cancel: () => {
-              this._streamMapping.delete(streamId);
+              if (keepAliveTimer !== void 0) {
+                clearInterval(keepAliveTimer);
+              }
+              if (this._streamMapping.get(streamId)?.controller === streamController) {
+                this._streamMapping.delete(streamId);
+              }
             }
           });
           const headers = {
             "Content-Type": "text/event-stream",
-            "Cache-Control": "no-cache",
-            Connection: "keep-alive"
+            "Cache-Control": "no-cache, no-transform",
+            Connection: "keep-alive",
+            "X-Accel-Buffering": "no"
           };
           if (this.sessionId !== void 0) {
             headers["mcp-session-id"] = this.sessionId;
@@ -43579,6 +43809,9 @@ data:
                 controller: streamController,
                 encoder,
                 cleanup: () => {
+                  if (keepAliveTimer !== void 0) {
+                    clearInterval(keepAliveTimer);
+                  }
                   this._streamMapping.delete(streamId);
                   try {
                     streamController.close();
@@ -43589,19 +43822,33 @@ data:
               this._requestToStreamMapping.set(message.id, streamId);
             }
           }
-          await this.writePrimingEvent(streamController, encoder, streamId, clientProtocolVersion);
-          for (const message of messages) {
-            let closeSSEStream;
-            let closeStandaloneSSEStream;
-            if (isJSONRPCRequest(message) && this._eventStore && clientProtocolVersion >= "2025-11-25") {
-              closeSSEStream = () => {
-                this.closeSSEStream(message.id);
-              };
-              closeStandaloneSSEStream = () => {
-                this.closeStandaloneSSEStream();
-              };
+          try {
+            await this.writePrimingEvent(streamController, encoder, streamId, clientProtocolVersion);
+            for (const message of messages) {
+              let closeSSEStream;
+              let closeStandaloneSSEStream;
+              if (isJSONRPCRequest(message) && this._eventStore && clientProtocolVersion >= "2025-11-25") {
+                closeSSEStream = () => {
+                  this.closeSSEStream(message.id);
+                };
+                closeStandaloneSSEStream = () => {
+                  this.closeStandaloneSSEStream();
+                };
+              }
+              this.onmessage?.(message, { authInfo: options?.authInfo, requestInfo, closeSSEStream, closeStandaloneSSEStream });
+            }
+          } catch (error51) {
+            this._streamMapping.get(streamId)?.cleanup();
+            this._resumableStreams.delete(streamId);
+            for (const message of messages) {
+              if (isJSONRPCRequest(message)) {
+                this._requestToStreamMapping.delete(message.id);
+              }
             }
-            this.onmessage?.(message, { authInfo: options?.authInfo, requestInfo, closeSSEStream, closeStandaloneSSEStream });
+            throw error51;
+          }
+          if (this._streamMapping.get(streamId)?.controller === streamController) {
+            keepAliveTimer = this.startKeepAlive(streamController, encoder);
           }
           return new Response(readable, { status: 200, headers });
         } catch (error51) {
@@ -43621,9 +43868,12 @@ data:
         if (protocolError) {
           return protocolError;
         }
-        await Promise.resolve(this._onsessionclosed?.(this.sessionId));
-        await this.close();
-        return new Response(null, { status: 200 });
+        try {
+          await Promise.resolve(this._onsessionclosed?.(this.sessionId));
+          return new Response(null, { status: 200 });
+        } finally {
+          await this.close();
+        }
       }
       /**
        * Validates session ID for non-initialization requests.
@@ -43670,11 +43920,16 @@ data:
         return void 0;
       }
       async close() {
+        if (this._closed) {
+          return;
+        }
+        this._closed = true;
         this._streamMapping.forEach(({ cleanup: cleanup2 }) => {
           cleanup2();
         });
         this._streamMapping.clear();
         this._requestResponseMap.clear();
+        this._resumableStreams.clear();
         this.onclose?.();
       }
       /**
@@ -43718,7 +43973,7 @@ data:
           if (standaloneSse === void 0) {
             return;
           }
-          if (standaloneSse.controller && standaloneSse.encoder) {
+          if (standaloneSse.controller && standaloneSse.encoder && (eventId === void 0 || !standaloneSse.replayedEventIds?.has(eventId))) {
             this.writeSSEEvent(standaloneSse.controller, standaloneSse.encoder, message, eventId);
           }
           return;
@@ -43727,13 +43982,19 @@ data:
         if (!streamId) {
           throw new Error(`No connection established for request ID: ${String(requestId)}`);
         }
-        const stream = this._streamMapping.get(streamId);
-        if (!this._enableJsonResponse && stream?.controller && stream?.encoder) {
+        let stream = this._streamMapping.get(streamId);
+        if (!this._enableJsonResponse) {
           let eventId;
           if (this._eventStore) {
             eventId = await this._eventStore.storeEvent(streamId, message);
+            stream = this._streamMapping.get(streamId);
+          }
+          if (stream?.controller && stream?.encoder && (eventId === void 0 || !stream.replayedEventIds?.has(eventId))) {
+            const written = this.writeSSEEvent(stream.controller, stream.encoder, message, eventId);
+            if (written && eventId !== void 0) {
+              this._resumableStreams.add(streamId);
+            }
           }
-          this.writeSSEEvent(stream.controller, stream.encoder, message, eventId);
         }
         if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
           this._requestResponseMap.set(requestId, message);
@@ -43741,6 +44002,25 @@ data:
           const allResponsesReady = relatedIds.every((id) => this._requestResponseMap.has(id));
           if (allResponsesReady) {
             if (!stream) {
+              if (this._closed) {
+                for (const id of relatedIds) {
+                  this._requestResponseMap.delete(id);
+                  this._requestToStreamMapping.delete(id);
+                }
+                return;
+              }
+              if (!this._enableJsonResponse && this._eventStore && this._resumableStreams.has(streamId)) {
+                for (const id of relatedIds) {
+                  this._requestResponseMap.delete(id);
+                  this._requestToStreamMapping.delete(id);
+                }
+                this._resumableStreams.delete(streamId);
+                return;
+              }
+              for (const id of relatedIds) {
+                this._requestResponseMap.delete(id);
+                this._requestToStreamMapping.delete(id);
+              }
               throw new Error(`No connection established for request ID: ${String(requestId)}`);
             }
             if (this._enableJsonResponse && stream.resolveJson) {
@@ -43763,6 +44043,7 @@ data:
               this._requestResponseMap.delete(id);
               this._requestToStreamMapping.delete(id);
             }
+            this._resumableStreams.delete(streamId);
           }
         }
       }
@@ -48032,17 +48313,33 @@ function normalizeObjectSchema(schema) {
   }
   return void 0;
 }
+function getDotPath(path3) {
+  if (path3.length === 0) {
+    return "object root";
+  }
+  return path3.reduce((acc, seg, index4) => {
+    if (index4 === 0) {
+      return String(seg);
+    }
+    if (typeof seg === "number") {
+      return `${acc}[${seg}]`;
+    }
+    return `${acc}.${seg}`;
+  }, "");
+}
 function getParseErrorMessage(error51) {
   if (error51 && typeof error51 === "object") {
+    if ("issues" in error51 && Array.isArray(error51.issues) && error51.issues.length > 0) {
+      return error51.issues.map((i2) => {
+        if (!i2.path?.length) {
+          return i2.message;
+        }
+        return `${i2.message} at ${getDotPath(i2.path)}`;
+      }).join("\n");
+    }
     if ("message" in error51 && typeof error51.message === "string") {
       return error51.message;
     }
-    if ("issues" in error51 && Array.isArray(error51.issues) && error51.issues.length > 0) {
-      const firstIssue = error51.issues[0];
-      if (firstIssue && typeof firstIssue === "object" && "message" in firstIssue) {
-        return String(firstIssue.message);
-      }
-    }
     try {
       return JSON.stringify(error51);
     } catch {
@@ -54303,7 +54600,12 @@ var require_fast_uri = __commonJS({
     }
     function resolve(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-      const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
+      const { parsed: baseParsed, malformedAuthorityOrPort: baseMalformed } = parseWithStatus(baseURI, schemelessOptions);
+      const { parsed: relativeParsed, malformedAuthorityOrPort: relativeMalformed } = parseWithStatus(relativeURI, schemelessOptions);
+      if (baseMalformed || relativeMalformed) {
+        throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
+      }
+      const resolved = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true);
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
@@ -54428,6 +54730,8 @@ var require_fast_uri = __commonJS({
       return uriTokens.join("");
     }
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
+    var AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
+    var AUTHORITY_INTRODUCER_REGION = /^(?:[^#/:?]+:)?([/\\\t\n\r]*)/;
     function getParseError(parsed, matches) {
       if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
         return 'URI path must start with "/" when authority is present.';
@@ -54457,6 +54761,25 @@ var require_fast_uri = __commonJS({
           uri = "//" + uri;
         }
       }
+      const authorityMatch = uri.match(AUTHORITY_PREFIX);
+      if (authorityMatch !== null && authorityMatch[1].indexOf("\\") !== -1) {
+        parsed.error = "URI authority must not contain a literal backslash.";
+        malformedAuthorityOrPort = true;
+      }
+      const introducerMatch = uri.match(AUTHORITY_INTRODUCER_REGION);
+      if (introducerMatch !== null) {
+        const region = introducerMatch[1];
+        const normalizedRegion = region.replace(/[\t\n\r]/g, "");
+        if (normalizedRegion.length >= 2) {
+          if (normalizedRegion.slice(0, 2) !== "//") {
+            parsed.error = parsed.error || "URI authority must not contain a literal backslash.";
+            malformedAuthorityOrPort = true;
+          } else if (region.length !== normalizedRegion.length) {
+            parsed.error = parsed.error || "URI authority introducer must not contain whitespace.";
+            malformedAuthorityOrPort = true;
+          }
+        }
+      }
       const matches = uri.match(URI_PARSE);
       if (matches) {
         parsed.scheme = matches[1];
@@ -57954,16 +58277,7 @@ var init_server2 = __esm({
         if (!methodSchema) {
           throw new Error("Schema is missing a method literal");
         }
-        let methodValue;
-        if (isZ4Schema(methodSchema)) {
-          const v4Schema = methodSchema;
-          const v4Def = v4Schema._zod?.def;
-          methodValue = v4Def?.value ?? v4Schema.value;
-        } else {
-          const v3Schema = methodSchema;
-          const legacyDef = v3Schema._def;
-          methodValue = legacyDef?.value ?? v3Schema.value;
-        }
+        const methodValue = getLiteralValue(methodSchema);
         if (typeof methodValue !== "string") {
           throw new Error("Schema method literal must be a string");
         }
@@ -59425,12 +59739,21 @@ function deserializeMessage(line) {
 function serializeMessage(message) {
   return JSON.stringify(message) + "\n";
 }
-var ReadBuffer;
+var STDIO_DEFAULT_MAX_BUFFER_SIZE, ReadBuffer;
 var init_stdio = __esm({
   "node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js"() {
     init_types();
+    STDIO_DEFAULT_MAX_BUFFER_SIZE = 10 * 1024 * 1024;
     ReadBuffer = class {
+      constructor(options) {
+        this._maxBufferSize = options?.maxBufferSize ?? STDIO_DEFAULT_MAX_BUFFER_SIZE;
+      }
       append(chunk) {
+        const newSize = (this._buffer?.length ?? 0) + chunk.length;
+        if (newSize > this._maxBufferSize) {
+          this.clear();
+          throw new Error(`ReadBuffer exceeded maximum size of ${this._maxBufferSize} bytes`);
+        }
         this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
       }
       readMessage() {
@@ -59459,18 +59782,24 @@ var init_stdio2 = __esm({
   "node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js"() {
     init_stdio();
     StdioServerTransport = class {
-      constructor(_stdin = process3.stdin, _stdout = process3.stdout) {
+      constructor(_stdin = process3.stdin, _stdout = process3.stdout, options) {
         this._stdin = _stdin;
         this._stdout = _stdout;
-        this._readBuffer = new ReadBuffer();
         this._started = false;
         this._ondata = (chunk) => {
-          this._readBuffer.append(chunk);
-          this.processReadBuffer();
+          try {
+            this._readBuffer.append(chunk);
+            this.processReadBuffer();
+          } catch (error51) {
+            this.onerror?.(error51);
+            this.close().catch(() => {
+            });
+          }
         };
         this._onerror = (error51) => {
           this.onerror?.(error51);
         };
+        this._readBuffer = new ReadBuffer({ maxBufferSize: options?.maxBufferSize });
       }
       /**
        * Starts listening for messages on stdin.
@@ -120155,6 +120484,13 @@ simple-concat/index.js:
 simple-get/index.js:
   (*! simple-get. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)
 
+content-type/index.js:
+  (*!
+   * content-type
+   * Copyright(c) 2015 Douglas Christopher Wilson
+   * MIT Licensed
+   *)
+
 long/umd/index.js:
   (**
    * @license

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jjhub",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "jjhub — GitHub CLI with Jujutsu-native superpowers: stable change IDs, stacks, platform-wide undo, and conflicts that wait, layered over plain GitHub repos by a JJHub server.",
   "bin": {
     "jjhub": "./dist/cli/jjhub.mjs"