Fix private feed URLs with parens (#127)

* fix: encode private feed urls

* fix: keep encoded delimiters

Author: chhoumann

src/downloadEpisode.ts

@@ -2,6 +2,7 @@ import { Notice, TFile, requestUrl } from "obsidian";
 import { downloadedEpisodes } from "./store";
 import { DownloadPathTemplateEngine } from "./TemplateEngine";
 import type { Episode } from "./types/Episode";
+import { encodeUrlForRequest } from "./utility/encodeUrlForRequest";
 import getUrlExtension from "./utility/getUrlExtension";
 import getExtensionFromContentType from "./utility/getExtensionFromContentType";
 
@@ -16,8 +17,9 @@ async function downloadFile(
 		onError: (error: Error) => void;
 	}>,
 ) {
+	const encodedUrl = encodeUrlForRequest(url);
 	try {
-		const response = await requestUrl({ url, method: "GET" });
+		const response = await requestUrl({ url: encodedUrl, method: "GET" });
 
 		if (response.status !== 200) {
 			throw new Error("Could not download episode.");
@@ -36,7 +38,7 @@ async function downloadFile(
 			}),
 			contentLength,
 			receivedLength: contentLength,
-			responseUrl: url,
+			responseUrl: encodedUrl,
 		};
 	} catch (error: unknown) {
 		const err = new Error(
@@ -229,16 +231,21 @@ export async function downloadEpisode(
 }
 
 async function getFileExtension(url: string): Promise<string> {
-	const urlExtension = getUrlExtension(url);
+	const encodedUrl = encodeUrlForRequest(url);
+	const urlExtension = getUrlExtension(encodedUrl);
 	if (urlExtension) return urlExtension;
 
 	// If URL doesn't have an extension, fetch headers to determine content type
-	const response = await fetch(url, { method: "HEAD" });
-	const contentType = response.headers.get("content-type");
+	try {
+		const response = await fetch(encodedUrl, { method: "HEAD" });
+		const contentType = response.headers.get("content-type");
 
-	const extensionFromContentType = getExtensionFromContentType(contentType);
-	if (extensionFromContentType) {
-		return extensionFromContentType;
+		const extensionFromContentType = getExtensionFromContentType(contentType);
+		if (extensionFromContentType) {
+			return extensionFromContentType;
+		}
+	} catch (error) {
+		console.error(`HEAD request failed for ${encodedUrl}`, error);
 	}
 
 	// Default to mp3 if we can't determine the type

src/utility/encodeUrlForRequest.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+import { encodeUrlForRequest } from "./encodeUrlForRequest";
+
+describe("encodeUrlForRequest", () => {
+	it("encodes parentheses and whitespace while leaving structure intact", () => {
+		const raw =
+			"https://example.com/podcast/Episode (Part 1).mp3?token=(abc123)";
+		expect(encodeUrlForRequest(raw)).toBe(
+			"https://example.com/podcast/Episode%20%28Part%201%29.mp3?token=%28abc123%29",
+		);
+	});
+
+	it("returns already encoded urls untouched", () => {
+		const alreadyEncoded =
+			"https://example.com/audio/Episode%20%28Part%201%29.mp3";
+		expect(encodeUrlForRequest(alreadyEncoded)).toBe(alreadyEncoded);
+	});
+
+	it("keeps intentionally encoded delimiters intact", () => {
+		const signedUrl =
+			"https://example.com/path%2Fsegment%3Fsignature%3Dabc123%23hash";
+		expect(encodeUrlForRequest(signedUrl)).toBe(signedUrl);
+	});
+
+	it("handles empty strings safely", () => {
+		expect(encodeUrlForRequest("")).toBe("");
+		expect(encodeUrlForRequest("   ")).toBe("");
+	});
+});

src/utility/encodeUrlForRequest.ts

@@ -0,0 +1,34 @@
+const PARENTHESIS_REGEXP = /[()]/g;
+const PARENTHESIS_LOOKUP: Record<string, string> = {
+	"(": "%28",
+	")": "%29",
+};
+
+/**
+ * Ensures URLs are safe to send over the network by percent-encoding
+ * whitespace plus characters that certain private feed hosts require,
+ * such as parentheses.
+ */
+export function encodeUrlForRequest(rawUrl: string): string {
+	const trimmed = rawUrl.trim();
+	if (!trimmed) return trimmed;
+
+	let normalized: string;
+	try {
+		normalized = new URL(trimmed).toString();
+	} catch {
+		normalized = encodeWhitespace(trimmed);
+	}
+
+	const encoded = normalized;
+	return encoded.replace(
+		PARENTHESIS_REGEXP,
+		(char) => PARENTHESIS_LOOKUP[char] ?? char,
+	);
+}
+
+function encodeWhitespace(value: string): string {
+	return value.replace(/\s/g, (char) =>
+		`%${char.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0")}`,
+	);
+}