sdiufhs

src/routes/m3u8-proxy.ts

@@ -3,26 +3,40 @@
  * @description Proxies m3u8 files and their segments
  */
 
+// Helper function to safely create a URL object
+function safeCreateURL(url: string, base?: string): URL | null {
+  try {
+    return base ? new URL(url, base) : new URL(url);
+  } catch (error) {
+    console.error("URL parsing error:", error, "URL:", url, "Base:", base);
+    return null;
+  }
+}
+
 // Helper function to parse URLs
 function parseURL(req_url: string, baseUrl?: string) {
   try {
     if (baseUrl) {
-      return new URL(req_url, baseUrl).toString();
+      const url = safeCreateURL(req_url, baseUrl);
+      return url ? url.toString() : null;
     }
     
     // If it's already a fully qualified URL
     if (/^https?:\/\//i.test(req_url)) {
-      return new URL(req_url).toString();
+      const url = safeCreateURL(req_url);
+      return url ? url.toString() : null;
     }
     
     // If it starts with // (protocol-relative URL)
     if (req_url.startsWith('//')) {
-      return new URL(`https:${req_url}`).toString();
+      const url = safeCreateURL(`https:${req_url}`);
+      return url ? url.toString() : null;
     }
     
     // If it's a relative URL and we have a base URL
     if (baseUrl) {
-      return new URL(req_url, baseUrl).toString();
+      const url = safeCreateURL(req_url, baseUrl);
+      return url ? url.toString() : null;
     }
     
     return null;
@@ -45,6 +59,7 @@ export default async function(request: Request, env: any, ctx: any) {
     });
   }
   
+  try {
     // Parse URL parameters
     const url = new URL(request.url);
     const targetUrl = url.searchParams.get('url');
@@ -64,6 +79,15 @@ export default async function(request: Request, env: any, ctx: any) {
       return new Response('Invalid headers format', { status: 400 });
     }
     
+    // Validate target URL
+    const validatedUrl = safeCreateURL(targetUrl);
+    if (!validatedUrl) {
+      return new Response(`Invalid target URL: ${targetUrl}`, { 
+        status: 400,
+        headers: { 'Access-Control-Allow-Origin': '*' }
+      });
+    }
+    
     try {
       // Create base request headers
       const requestHeaders = new Headers({
@@ -73,11 +97,11 @@ export default async function(request: Request, env: any, ctx: any) {
         ...customHeaders
       });
       
-    console.log("Making request to:", targetUrl);
+      console.log("Making request to:", validatedUrl.toString());
       console.log("With headers:", JSON.stringify(Object.fromEntries(requestHeaders.entries())));
       
       // Use fetch API which is natively available in Workers
-    const response = await fetch(targetUrl, { 
+      const response = await fetch(validatedUrl.toString(), { 
         headers: requestHeaders
       });
       
@@ -117,7 +141,15 @@ export default async function(request: Request, env: any, ctx: any) {
                 let fullKeyUrl;
                 try {
                   // Try to get the full URL
-                fullKeyUrl = keyUrl.startsWith('http') ? keyUrl : new URL(keyUrl, targetUrl).toString();
+                  const keyUrlObj = keyUrl.startsWith('http') 
+                    ? safeCreateURL(keyUrl)
+                    : safeCreateURL(keyUrl, validatedUrl.toString());
+                    
+                  if (!keyUrlObj) {
+                    throw new Error("Could not create valid URL for key");
+                  }
+                  
+                  fullKeyUrl = keyUrlObj.toString();
                   const proxyKeyUrl = `${baseProxyUrl}/ts-proxy?url=${encodeURIComponent(fullKeyUrl)}&headers=${encodeURIComponent(JSON.stringify(customHeaders))}`;
                   newLines.push(line.replace(keyUrl, proxyKeyUrl));
                 } catch (error) {
@@ -136,7 +168,15 @@ export default async function(request: Request, env: any, ctx: any) {
               if (mediaUrl) {
                 try {
                   // Try to get the full URL
-                const fullMediaUrl = mediaUrl.startsWith('http') ? mediaUrl : new URL(mediaUrl, targetUrl).toString();
+                  const mediaUrlObj = mediaUrl.startsWith('http') 
+                    ? safeCreateURL(mediaUrl)
+                    : safeCreateURL(mediaUrl, validatedUrl.toString());
+                    
+                  if (!mediaUrlObj) {
+                    throw new Error("Could not create valid URL for media");
+                  }
+                  
+                  const fullMediaUrl = mediaUrlObj.toString();
                   const proxyMediaUrl = `${baseProxyUrl}/m3u8-proxy?url=${encodeURIComponent(fullMediaUrl)}&headers=${encodeURIComponent(JSON.stringify(customHeaders))}`;
                   newLines.push(line.replace(mediaUrl, proxyMediaUrl));
                 } catch (error) {
@@ -153,7 +193,15 @@ export default async function(request: Request, env: any, ctx: any) {
             // This is a quality variant URL
             try {
               // Try to create a full URL
-            const variantUrl = line.startsWith('http') ? line : new URL(line, targetUrl).toString();
+              const variantUrlObj = line.startsWith('http') 
+                ? safeCreateURL(line)
+                : safeCreateURL(line, validatedUrl.toString());
+                
+              if (!variantUrlObj) {
+                throw new Error("Could not create valid URL for variant");
+              }
+              
+              const variantUrl = variantUrlObj.toString();
               newLines.push(`${baseProxyUrl}/m3u8-proxy?url=${encodeURIComponent(variantUrl)}&headers=${encodeURIComponent(JSON.stringify(customHeaders))}`);
             } catch (error) {
               console.error("Error processing variant URL:", line, error);
@@ -184,7 +232,15 @@ export default async function(request: Request, env: any, ctx: any) {
               if (keyUrl) {
                 try {
                   // Try to get the full URL
-                const fullKeyUrl = keyUrl.startsWith('http') ? keyUrl : new URL(keyUrl, targetUrl).toString();
+                  const keyUrlObj = keyUrl.startsWith('http') 
+                    ? safeCreateURL(keyUrl)
+                    : safeCreateURL(keyUrl, validatedUrl.toString());
+                    
+                  if (!keyUrlObj) {
+                    throw new Error("Could not create valid URL for key");
+                  }
+                  
+                  const fullKeyUrl = keyUrlObj.toString();
                   const proxyKeyUrl = `${baseProxyUrl}/ts-proxy?url=${encodeURIComponent(fullKeyUrl)}&headers=${encodeURIComponent(JSON.stringify(customHeaders))}`;
                   newLines.push(line.replace(keyUrl, proxyKeyUrl));
                 } catch (error) {
@@ -201,7 +257,15 @@ export default async function(request: Request, env: any, ctx: any) {
             // This is a segment URL (.ts file)
             try {
               // Try to create a full URL
-            const segmentUrl = line.startsWith('http') ? line : new URL(line, targetUrl).toString();
+              const segmentUrlObj = line.startsWith('http') 
+                ? safeCreateURL(line)
+                : safeCreateURL(line, validatedUrl.toString());
+                
+              if (!segmentUrlObj) {
+                throw new Error("Could not create valid URL for segment");
+              }
+              
+              const segmentUrl = segmentUrlObj.toString();
               newLines.push(`${baseProxyUrl}/ts-proxy?url=${encodeURIComponent(segmentUrl)}&headers=${encodeURIComponent(JSON.stringify(customHeaders))}`);
             } catch (error) {
               console.error("Error processing segment URL:", line, error);
@@ -226,4 +290,13 @@ export default async function(request: Request, env: any, ctx: any) {
         }
       });
     }
+  } catch (error: any) {
+    console.error('Unexpected error in m3u8-proxy:', error);
+    return new Response(error.message || 'Unexpected error in m3u8-proxy', { 
+      status: 500,
+      headers: {
+        'Access-Control-Allow-Origin': '*'
+      }
+    });
+  }
 } 

src/routes/ts-proxy.ts

@@ -3,6 +3,16 @@
  * @description Proxies TS (transport stream) files
  */
 
+// Helper function to safely create a URL object
+function safeCreateURL(url: string, base?: string): URL | null {
+  try {
+    return base ? new URL(url, base) : new URL(url);
+  } catch (error) {
+    console.error("URL parsing error:", error, "URL:", url, "Base:", base);
+    return null;
+  }
+}
+
 export default async function(request: Request, env: any, ctx: any) {
   // Handle CORS preflight requests
   if (request.method === 'OPTIONS') {
@@ -23,21 +33,26 @@ export default async function(request: Request, env: any, ctx: any) {
     const headersParam = url.searchParams.get('headers');
     
     if (!targetUrl) {
-      return new Response('URL parameter is required', { status: 400 });
+      return new Response('URL parameter is required', { 
+        status: 400,
+        headers: { 'Access-Control-Allow-Origin': '*' }
+      });
     }
     
     let customHeaders = {};
     try {
       customHeaders = headersParam ? JSON.parse(headersParam) : {};
     } catch (e) {
-      return new Response('Invalid headers format', { status: 400 });
+      return new Response('Invalid headers format', { 
+        status: 400,
+        headers: { 'Access-Control-Allow-Origin': '*' }
+      });
     }
     
     // Validate the URL
-    try {
+    const validatedUrl = safeCreateURL(targetUrl);
-      new URL(targetUrl);
+    if (!validatedUrl) {
-    } catch (error) {
+      console.error('Invalid target URL:', targetUrl);
-      console.error('Invalid target URL:', targetUrl, error);
       return new Response('Invalid target URL', { 
         status: 400,
         headers: { 'Access-Control-Allow-Origin': '*' }
@@ -52,11 +67,11 @@ export default async function(request: Request, env: any, ctx: any) {
       ...customHeaders
     });
     
-    console.log('Fetching TS from:', targetUrl);
+    console.log('Fetching TS from:', validatedUrl.toString());
     console.log('With headers:', JSON.stringify(Object.fromEntries(requestHeaders.entries())));
     
     // Fetch the TS file
-    const response = await fetch(targetUrl, {
+    const response = await fetch(validatedUrl.toString(), {
       method: 'GET',
       headers: requestHeaders
     });