@keystrokehq/platform 0.1.89 → 0.1.91

package/dist/{dist-DXWcIK6r.cjs → dist-DLMpDCU8.cjs}

@@ -24625,6 +24625,52 @@ function assertPublicHttpUrl(urlString) {
 	if (isBlockedHost(normalizeHostname(url.hostname))) throw new PublicHttpUrlError("URL host is not allowed");
 	return url;
 }
+const DEFAULT_MAX_REDIRECTS = 5;
+/**
+* Fetch a URL that must remain on public http(s) hosts.
+* Validates the initial URL and every redirect Location (no private/metadata hosts).
+*/
+async function fetchPublicHttp(urlString, options = {}) {
+	const { maxRedirects = DEFAULT_MAX_REDIRECTS, fetchFn = fetch, ...init } = options;
+	let current = assertPublicHttpUrl(urlString).toString();
+	let hopInit = { ...init };
+	for (let hop = 0; hop <= maxRedirects; hop++) {
+		const response = await fetchFn(current, {
+			...hopInit,
+			redirect: "manual"
+		});
+		if (response.status < 300 || response.status >= 400) return response;
+		const location = response.headers.get("location");
+		await response.body?.cancel().catch(() => void 0);
+		if (!location) throw new PublicHttpUrlError("Redirect missing Location");
+		let next;
+		try {
+			next = new URL(location, current);
+		} catch {
+			throw new PublicHttpUrlError("Invalid redirect Location");
+		}
+		current = assertPublicHttpUrl(next.toString()).toString();
+		if (response.status === 301 || response.status === 302 || response.status === 303) {
+			const { body: _body, ...rest } = hopInit;
+			hopInit = {
+				...rest,
+				method: "GET"
+			};
+		}
+	}
+	throw new PublicHttpUrlError("Too many redirects");
+}
+/** Wrap `fetch` so every outbound URL (including SDK follow-ups) passes `assertPublicHttpUrl`. */
+function createPublicHttpFetch(fetchFn = fetch) {
+	return async (input, init) => {
+		const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+		assertPublicHttpUrl(url);
+		return fetchPublicHttp(url, {
+			...init,
+			fetchFn
+		});
+	};
+}
 function resourceNameFromMetadata(metadata) {
 	return metadata?.resource_name?.trim() || void 0;
 }
@@ -24655,13 +24701,17 @@ function logProbeFallback(phase, error) {
 }
 async function probeMcpAuth(url, fetchFn = fetch) {
 	assertPublicHttpUrl(url);
+	const safeFetch = createPublicHttpFetch(fetchFn);
 	const serverUrl = new URL(url);
-	const { status, wwwAuthenticate } = await probeUnauthenticatedStatus(url, fetchFn);
+	const { status, wwwAuthenticate } = await probeUnauthenticatedStatus(url, safeFetch);
 	let resourceMetadataUrl;
-	if (wwwAuthenticate) resourceMetadataUrl = extractWWWAuthenticateParams(new Response(null, { headers: { "www-authenticate": wwwAuthenticate } })).resourceMetadataUrl?.toString();
+	if (wwwAuthenticate) {
+		resourceMetadataUrl = extractWWWAuthenticateParams(new Response(null, { headers: { "www-authenticate": wwwAuthenticate } })).resourceMetadataUrl?.toString();
+		if (resourceMetadataUrl) assertPublicHttpUrl(resourceMetadataUrl);
+	}
 	try {
 		const discovered = await discoverOAuthServerInfo(serverUrl, {
-			fetchFn,
+			fetchFn: safeFetch,
 			...resourceMetadataUrl ? { resourceMetadataUrl: new URL(resourceMetadataUrl) } : {}
 		});
 		const metadata = discovered.authorizationServerMetadata;
@@ -24683,8 +24733,10 @@ async function probeMcpAuth(url, fetchFn = fetch) {
 		logProbeFallback("discoverOAuthServerInfo", error);
 	}
 	try {
-		const protectedResource = await discoverOAuthProtectedResourceMetadata(serverUrl, {}, fetchFn);
-		const metadata = await discoverAuthorizationServerMetadata(protectedResource.authorization_servers?.[0] ?? serverUrl.origin, { fetchFn });
+		const protectedResource = await discoverOAuthProtectedResourceMetadata(serverUrl, {}, safeFetch);
+		const authorizationServerUrl = protectedResource.authorization_servers?.[0] ?? serverUrl.origin;
+		assertPublicHttpUrl(authorizationServerUrl);
+		const metadata = await discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn: safeFetch });
 		if (metadata?.authorization_endpoint && metadata.token_endpoint) return {
 			url,
 			mode: "oauth",
@@ -24716,11 +24768,13 @@ async function probeMcpAuth(url, fetchFn = fetch) {
 }
 /** Best-effort server metadata for no-auth MCP servers (initialize handshake). */
 async function probeMcpServerInfo(url, fetchFn = fetch) {
+	assertPublicHttpUrl(url);
+	const safeFetch = createPublicHttpFetch(fetchFn);
 	const client = new Client({
 		name: "keystroke",
 		version: "0.0.0"
 	});
-	const transport = new StreamableHTTPClientTransport(new URL(url), { fetch: fetchFn });
+	const transport = new StreamableHTTPClientTransport(new URL(url), { fetch: safeFetch });
 	try {
 		await client.connect(transport);
 		const info = client.getServerVersion();
@@ -31731,7 +31785,13 @@ function isOpenApiSpec(value) {
 	return isRecord$1(value) && (typeof value.openapi === "string" || typeof value.swagger === "string");
 }
 async function discoverOpenApiApp(url) {
-	const response = await fetch(url, { redirect: "follow" });
+	let response;
+	try {
+		response = await fetchPublicHttp(url);
+	} catch (error) {
+		if (error instanceof PublicHttpUrlError) throw new Error(error.message);
+		throw error;
+	}
 	if (!response.ok) throw new Error(`Failed to fetch OpenAPI spec (${response.status})`);
 	const contentLength = response.headers.get("content-length");
 	if (contentLength && Number(contentLength) > MAX_SPEC_BYTES) throw new Error("OpenAPI spec is too large");
@@ -31758,15 +31818,20 @@ const INTROSPECTION_QUERY = `query IntrospectionQuery {
 }`;
 const USAGE_AUTH_PROBE_QUERY = "query { __typename }";
 async function postGraphql(endpointUrl, query) {
-	const response = await fetch(endpointUrl, {
-		method: "POST",
-		redirect: "follow",
-		headers: {
-			"content-type": "application/json",
-			accept: "application/json"
-		},
-		body: JSON.stringify({ query })
-	});
+	let response;
+	try {
+		response = await fetchPublicHttp(endpointUrl, {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				accept: "application/json"
+			},
+			body: JSON.stringify({ query })
+		});
+	} catch (error) {
+		if (error instanceof PublicHttpUrlError) throw new Error(error.message);
+		throw error;
+	}
 	const contentLength = response.headers.get("content-length");
 	if (contentLength && Number(contentLength) > MAX_RESPONSE_BYTES) throw new Error("GraphQL introspection response is too large");
 	const text = await response.text();
@@ -31790,14 +31855,8 @@ function introspectionDisabled(body) {
 		return (typeof error.message === "string" ? error.message.toLowerCase() : "").includes("introspection");
 	});
 }
-function parseEndpointUrl(url) {
-	const trimmed = url.trim();
-	const parsed = new URL(trimmed);
-	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new Error("GraphQL endpoint must use http or https");
-	return parsed;
-}
 async function discoverGraphqlApp(url) {
-	const endpointUrl = parseEndpointUrl(url).toString();
+	const endpointUrl = url.trim();
 	const { response, body } = await postGraphql(endpointUrl, INTROSPECTION_QUERY);
 	const authProbe = inferGraphqlAuthFromProbe(response.status, response.headers.get("www-authenticate"), body);
 	if (!(isRecord(body) && isRecord(body.data) && isRecord(body.data.__schema))) {
@@ -38520,4 +38579,4 @@ Object.defineProperty(exports, "withCredentialAssignments", {
 	}
 });
 
-//# sourceMappingURL=dist-DXWcIK6r.cjs.map
+//# sourceMappingURL=dist-DLMpDCU8.cjs.map