@zuplo/cli 7.9.5 → 7.9.6

package/node_modules/@modelcontextprotocol/client/dist/shimsWorkerd.cjs

@@ -1,4 +1,4 @@
-const require_src = require('./src-oZBjf3U1.cjs');
+const require_src = require('./src-DpAS0jfg.cjs');
 const require_cfWorkerProvider = require('./cfWorkerProvider-B3dvjU3F.cjs');
 
 //#region src/shimsWorkerd.ts

package/node_modules/@modelcontextprotocol/client/dist/shimsWorkerd.mjs

@@ -1,4 +1,4 @@
-import { n as preloadSchemas } from "./src-xKF0PJN-.mjs";
+import { n as preloadSchemas } from "./src-WCy6ifGf.mjs";
 import { t as CfWorkerJsonSchemaValidator } from "./cfWorkerProvider-BylNJ1R5.mjs";
 
 //#region src/shimsWorkerd.ts

package/node_modules/@modelcontextprotocol/client/dist/{src-oZBjf3U1.cjs → src-DpAS0jfg.cjs}

@@ -3072,7 +3072,7 @@ function build() {
 	const subscriptionsListenParamsShape = { notifications: SubscriptionFilterSchema$1 };
 	const SubscriptionsListenRequestSchema$1 = wireRequest("subscriptions/listen", subscriptionsListenParamsShape);
 	/**
-	* Anchor SubscriptionsListenResultMeta — required subscriptionId stamp on
+	* Anchor SubscriptionsListenResultMetaObject — required subscriptionId stamp on
 	* the graceful-close result. Extends `ResultMetaObject` since spec PR
 	* #3002 (composed, so the serverInfo key and its leniency stay single-sourced).
 	*/
@@ -3345,7 +3345,8 @@ function build() {
 		ListResourceTemplatesResultResponseSchema: wireResultResponse(ListResourceTemplatesResultSchema$1),
 		ReadResourceResultResponseSchema: wireResultResponse(zod_v4.union([ReadResourceResultSchema$1, InputRequiredResultSchema])),
 		CompleteResultResponseSchema: wireResultResponse(CompleteResultSchema$1),
-		DiscoverResultResponseSchema: wireResultResponse(DiscoverResultSchema$1)
+		DiscoverResultResponseSchema: wireResultResponse(DiscoverResultSchema$1),
+		SubscriptionsListenResultResponseSchema: wireResultResponse(SubscriptionsListenResultSchema$1)
 	};
 }
 let memo;
@@ -4093,6 +4094,10 @@ function isSpecRequestMethod(method) {
 function isSpecNotificationMethod(method) {
 	return ALL_CODECS.some((codec) => codec.hasNotificationMethod(method));
 }
+/** The names SEP-2663 re-defines for the Tasks extension on the era that removed them from core. */
+function isExtensionReusedRequestMethod(method) {
+	return method === "tasks/get" || method === "tasks/cancel";
+}
 const ALL_CODECS = [rev2025Codec, rev2026Codec];
 
 //#endregion
@@ -5029,13 +5034,14 @@ function buildInputRequired(spec) {
 * @example Write-once tool requesting confirmation
 * ```ts
 * server.registerTool('deploy', { inputSchema: z.object({ env: z.string() }) }, async ({ env }, ctx) => {
-*     const confirmed = acceptedContent<{ confirm: boolean }>(ctx.mcpReq.inputResponses, 'confirm');
-*     if (!confirmed) {
+*     const confirmationSchema = z.object({ confirm: z.boolean() });
+*     const confirmed = acceptedContent(ctx.mcpReq.inputResponses, 'confirm', confirmationSchema);
+*     if (confirmed?.confirm !== true) {
 *         return inputRequired({
 *             inputRequests: {
 *                 confirm: inputRequired.elicit({
 *                     message: `Deploy to ${env}?`,
-*                     requestedSchema: { type: 'object', properties: { confirm: { type: 'boolean' } }, required: ['confirm'] }
+*                     requestedSchema: confirmationSchema
 *                 })
 *             }
 *         });
@@ -5646,6 +5652,8 @@ var Protocol = class {
 	_transport;
 	_requestMessageId = 0;
 	_requestHandlers = /* @__PURE__ */ new Map();
+	/** Methods registered with an explicit schema; the era gate in `_onrequest` reads it for the Tasks extension names. */
+	_customSchemaRequestMethods = /* @__PURE__ */ new Set();
 	_requestHandlerAbortControllers = /* @__PURE__ */ new Map();
 	_notificationHandlers = /* @__PURE__ */ new Map();
 	_responseHandlers = /* @__PURE__ */ new Map();
@@ -5927,7 +5935,7 @@ var Protocol = class {
 				return;
 			}
 		}
-		if (isSpecRequestMethod(request.method) && !codec.hasRequestMethod(request.method)) {
+		if (isSpecRequestMethod(request.method) && !codec.hasRequestMethod(request.method) && !(isExtensionReusedRequestMethod(request.method) && this._customSchemaRequestMethods.has(request.method))) {
 			sendErrorResponse(ProtocolErrorCode.MethodNotFound, "Method not found");
 			return;
 		}
@@ -6060,8 +6068,11 @@ var Protocol = class {
 	}
 	request(request, schemaOrOptions, maybeOptions) {
 		const codec = this._resolveOutboundCodec(request.method);
+		if (isStandardSchema(schemaOrOptions)) {
+			if (!isExtensionReusedRequestMethod(request.method)) this._assertOutboundRequestInEra(codec, request.method);
+			return this._requestWithSchemaViaCodec(codec, request, schemaOrOptions, maybeOptions);
+		}
 		this._assertOutboundRequestInEra(codec, request.method);
-		if (isStandardSchema(schemaOrOptions)) return this._requestWithSchemaViaCodec(codec, request, schemaOrOptions, maybeOptions);
 		const validate = codecResultValidator(codec, request.method);
 		if (validate === void 0) throw new TypeError(`'${request.method}' is not a spec method; pass a result schema as the second argument to request().`);
 		return this._requestWithSchemaViaCodec(codec, request, validate, schemaOrOptions);
@@ -6305,6 +6316,8 @@ var Protocol = class {
 			return maybeHandler(parsed.data, ctx);
 		};
 		else throw new TypeError("setRequestHandler: handler is required");
+		if (typeof schemasOrHandler === "function") this._customSchemaRequestMethods.delete(method);
+		else this._customSchemaRequestMethods.add(method);
 		this._requestHandlers.set(method, this._wrapHandler(method, stored));
 	}
 	/**
@@ -6333,6 +6346,7 @@ var Protocol = class {
 	*/
 	removeRequestHandler(method) {
 		this._requestHandlers.delete(method);
+		this._customSchemaRequestMethods.delete(method);
 	}
 	/**
 	* Asserts that a request handler has not already been set for the given method, in preparation for a new one being automatically installed.
@@ -6796,6 +6810,71 @@ function createFetchWithInit(baseFetch = fetch, baseInit) {
 		});
 	};
 }
+const REDIRECT_STATUSES = new Set([
+	301,
+	302,
+	303,
+	307,
+	308
+]);
+const MAX_REDIRECTS = 5;
+/** Whether `to` has the scheme, host and port of `from`, or is its https form with both on the default port. */
+function isWithinOrigin(from, to) {
+	if (from.protocol === to.protocol && from.host === to.host) return true;
+	return from.protocol === "http:" && to.protocol === "https:" && from.hostname === to.hostname && !from.port && !to.port;
+}
+/** The URL that a redirect `response` to a request for `url` points at, if it names one. */
+function redirectTarget(url, response) {
+	const location = REDIRECT_STATUSES.has(response.status) ? response.headers?.get("location") : void 0;
+	if (!location) return void 0;
+	try {
+		return new URL(location, url);
+	} catch {
+		return;
+	}
+}
+const leftToFetch = /* @__PURE__ */ new WeakSet();
+/** A copy of `baseFetch` that `fetchWithinOrigin` returns as it is, which leaves redirects to `baseFetch`. */
+function fetchLeavingRedirects(baseFetch) {
+	const copy = (url, init) => baseFetch(url, init);
+	leftToFetch.add(copy);
+	return copy;
+}
+/** Wraps `baseFetch` to follow a redirect only when it keeps the method and stays within the origin of the request. */
+function fetchWithinOrigin(baseFetch) {
+	if (leftToFetch.has(baseFetch)) return baseFetch;
+	return async (url, init) => {
+		if (init?.redirect === "error" || init?.redirect === "manual") return baseFetch(url, init);
+		const method = (init?.method ?? "GET").toUpperCase();
+		let current = url;
+		for (let followed = 0;; followed++) {
+			const response = await baseFetch(current, {
+				...init,
+				redirect: "manual"
+			});
+			const target = redirectTarget(current, response);
+			if (!target || followed === MAX_REDIRECTS) return response;
+			const from = new URL(current);
+			const keepsMethod = method === "GET" || response.status === 307 || response.status === 308;
+			const keepsUserinfo = !(target.username || target.password) || target.username === from.username && target.password === from.password;
+			if (!keepsMethod || !keepsUserinfo || !isWithinOrigin(from, target)) return response;
+			await response.text?.().catch(() => {});
+			current = target;
+		}
+	};
+}
+/** Error text for a redirect `response` to a request for `url` that was not followed, or `undefined` for any other response. */
+function unfollowedRedirect(url, response) {
+	if (response.type === "opaqueredirect") return "Redirect not followed: this runtime does not expose where it points";
+	const target = redirectTarget(response.url || url, response);
+	if (!target) return void 0;
+	target.username = target.password = target.search = target.hash = "";
+	if (target.protocol === "http:" && new URL(response.url || url).protocol === "https:") {
+		target.protocol = "https:";
+		return `Redirect from https to plain http not followed; try ${target.href} as the endpoint`;
+	}
+	return `Redirect to ${target.href} not followed; use that URL as the endpoint if it is the intended server`;
+}
 
 //#endregion
 //#region ../core-internal/src/shared/uriTemplate.ts
@@ -7326,6 +7405,18 @@ Object.defineProperty(exports, 'encodeMcpParamValue', {
     return encodeMcpParamValue;
   }
 });
+Object.defineProperty(exports, 'fetchLeavingRedirects', {
+  enumerable: true,
+  get: function () {
+    return fetchLeavingRedirects;
+  }
+});
+Object.defineProperty(exports, 'fetchWithinOrigin', {
+  enumerable: true,
+  get: function () {
+    return fetchWithinOrigin;
+  }
+});
 Object.defineProperty(exports, 'fromJsonSchema', {
   enumerable: true,
   get: function () {
@@ -7506,6 +7597,12 @@ Object.defineProperty(exports, 'stampErrorBrands', {
     return stampErrorBrands;
   }
 });
+Object.defineProperty(exports, 'unfollowedRedirect', {
+  enumerable: true,
+  get: function () {
+    return unfollowedRedirect;
+  }
+});
 Object.defineProperty(exports, 'withInputRequired', {
   enumerable: true,
   get: function () {
@@ -7518,4 +7615,4 @@ Object.defineProperty(exports, 'withoutIssuer', {
     return withoutIssuer;
   }
 });
-//# sourceMappingURL=src-oZBjf3U1.cjs.map
+//# sourceMappingURL=src-DpAS0jfg.cjs.map