remove proxy route

app/api/proxy/[...path]/route.ts

@@ -1,547 +0,0 @@
-import { NextRequest, NextResponse } from "next/server";
-
-export async function GET(
-  req: NextRequest,
-  { params }: { params: Promise<{ path: string[] }> }
-) {
-  const pathParams = await params;
-  const pathSegments = pathParams.path || [];
-  
-  // Get the target URL from query parameter
-  const targetUrl = req.nextUrl.searchParams.get("url");
-  
-  if (!targetUrl) {
-    return NextResponse.json(
-      { error: "Missing 'url' query parameter" },
-      { status: 400 }
-    );
-  }
-
-  try {
-    // Parse the target URL
-    const url = new URL(targetUrl);
-    
-    // Only allow static.hf.space domains for security
-    if (!url.hostname.endsWith(".static.hf.space")) {
-      return NextResponse.json(
-        { error: "Only static.hf.space domains are allowed" },
-        { status: 403 }
-      );
-    }
-
-    // Construct the actual target URL
-    // If path segments exist, use them; otherwise use "/" for root
-    const targetPath = pathSegments.length > 0 
-      ? "/" + pathSegments.join("/")
-      : "/";
-    
-    // Merge query parameters from the request URL with the target URL's search params
-    const requestSearchParams = req.nextUrl.searchParams;
-    const targetSearchParams = new URLSearchParams(url.search);
-    
-    // Copy all query params except 'url' to the target URL
-    requestSearchParams.forEach((value, key) => {
-      if (key !== "url") {
-        targetSearchParams.set(key, value);
-      }
-    });
-    
-    const searchString = targetSearchParams.toString();
-    const fullTargetUrl = `${url.protocol}//${url.hostname}${targetPath}${searchString ? `?${searchString}` : ""}`;
-
-    // Fetch the content from the target URL
-    const response = await fetch(fullTargetUrl, {
-      headers: {
-        "User-Agent": "Mozilla/5.0 (compatible; DeepSite/1.0)",
-      },
-      redirect: "follow", // Follow redirects automatically
-    });
-
-    if (!response.ok) {
-      return NextResponse.json(
-        { error: `Failed to fetch: ${response.statusText}` },
-        { status: response.status }
-      );
-    }
-
-    let contentType = response.headers.get("content-type") || "";
-    const content = await response.text();
-
-    // Detect content type from file extension if not properly set
-    if (!contentType || contentType === "text/plain" || contentType === "application/octet-stream") {
-      const fileExtension = pathSegments.length > 0 
-        ? pathSegments[pathSegments.length - 1].split(".").pop()?.toLowerCase()
-        : "";
-      
-      if (fileExtension === "js") {
-        contentType = "application/javascript";
-      } else if (fileExtension === "css") {
-        contentType = "text/css";
-      } else if (fileExtension === "html" || fileExtension === "htm") {
-        contentType = "text/html";
-      } else if (fileExtension === "json") {
-        contentType = "application/json";
-      }
-    }
-
-    // Get the base proxy URL
-    // Extract the base path from the request URL
-    const requestUrl = new URL(req.url);
-    // Find where "/api/proxy" starts in the pathname
-    const proxyIndex = requestUrl.pathname.indexOf("/api/proxy");
-    const basePath = proxyIndex > 0 ? requestUrl.pathname.substring(0, proxyIndex) : "";
-    const proxyBaseUrl = `${basePath}/api/proxy`;
-    const targetUrlParam = `?url=${encodeURIComponent(`https://${url.hostname}`)}`;
-
-    // Rewrite URLs in HTML content
-    let processedContent = content;
-    
-    if (contentType.includes("text/html")) {
-      // Rewrite relative URLs and URLs pointing to the same domain
-      processedContent = rewriteUrls(
-        content,
-        url.hostname,
-        proxyBaseUrl,
-        targetUrlParam,
-        pathSegments
-      );
-      
-      // Inject script to intercept JavaScript-based navigation
-      processedContent = injectNavigationInterceptor(
-        processedContent,
-        url.hostname,
-        proxyBaseUrl,
-        targetUrlParam
-      );
-    } else if (contentType.includes("text/css")) {
-      // Rewrite URLs in CSS
-      processedContent = rewriteCssUrls(
-        content,
-        url.hostname,
-        proxyBaseUrl,
-        targetUrlParam
-      );
-    } else if (contentType.includes("application/javascript") || contentType.includes("text/javascript")) {
-      // For component files and most JavaScript, don't rewrite URLs
-      // Only rewrite if needed (for fetch calls, etc.)
-      // Most component JavaScript files don't need URL rewriting
-      // Only rewrite if the file contains fetch calls with relative URLs
-      if (content.includes("fetch(") && content.match(/fetch\(["'][^"']*[^\/]\./)) {
-        processedContent = rewriteJsUrls(
-          content,
-          url.hostname,
-          proxyBaseUrl,
-          targetUrlParam
-        );
-      } else {
-        // Don't modify component JavaScript files - they should work as-is
-        processedContent = content;
-      }
-    }
-
-    // Ensure JavaScript files have charset specified
-    let finalContentType = contentType;
-    if (contentType.includes("javascript") && !contentType.includes("charset")) {
-      finalContentType = contentType.includes(";") 
-        ? contentType + "; charset=utf-8"
-        : contentType + "; charset=utf-8";
-    }
-
-    // Return the processed content with appropriate headers
-    return new NextResponse(processedContent, {
-      status: 200,
-      headers: {
-        "Content-Type": finalContentType,
-        "X-Content-Type-Options": "nosniff",
-        // Don't set X-Frame-Options for JavaScript files - they need to execute
-        ...(contentType.includes("text/html") && { "X-Frame-Options": "SAMEORIGIN" }),
-        // Remove CORS restrictions since we're proxying
-        "Access-Control-Allow-Origin": "*",
-        "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
-        "Access-Control-Allow-Headers": "Content-Type",
-      },
-    });
-  } catch (error: any) {
-    console.error("Proxy error:", error);
-    return NextResponse.json(
-      { error: error.message || "Proxy error occurred" },
-      { status: 500 }
-    );
-  }
-}
-
-function rewriteUrls(
-  html: string,
-  targetHost: string,
-  proxyBaseUrl: string,
-  targetUrlParam: string,
-  currentPathSegments: string[] = []
-): string {
-  let processed = html;
-
-  // Get the current directory path for resolving relative URLs
-  const currentDir = currentPathSegments.length > 0 
-    ? "/" + currentPathSegments.slice(0, -1).join("/") + "/"
-    : "/";
-
-  // Rewrite relative URLs in href attributes
-  processed = processed.replace(
-    /href=["']([^"']+)["']/gi,
-    (match, urlStr) => {
-      if (urlStr.startsWith("http://") || urlStr.startsWith("https://")) {
-        // Absolute URL - rewrite if it's the same domain
-        try {
-          const urlObj = new URL(urlStr);
-          if (urlObj.hostname === targetHost) {
-            const pathPart = urlObj.pathname === "/" ? "" : urlObj.pathname;
-            const searchPart = urlObj.search ? `&${urlObj.search.substring(1)}` : "";
-            return `href="${proxyBaseUrl}${pathPart}${targetUrlParam}${searchPart}"`;
-          }
-        } catch {
-          // Invalid URL, keep as is
-        }
-        return match;
-      } else if (urlStr.startsWith("//")) {
-        // Protocol-relative URL
-        try {
-          const urlObj = new URL(`https:${urlStr}`);
-          if (urlObj.hostname === targetHost) {
-            const pathPart = urlObj.pathname === "/" ? "" : urlObj.pathname;
-            const searchPart = urlObj.search ? `&${urlObj.search.substring(1)}` : "";
-            return `href="${proxyBaseUrl}${pathPart}${targetUrlParam}${searchPart}"`;
-          }
-        } catch {
-          // Invalid URL, keep as is
-        }
-        return match;
-      } else if (urlStr.startsWith("#") || urlStr.startsWith("javascript:") || urlStr.startsWith("mailto:") || urlStr.startsWith("tel:")) {
-        // Hash links, javascript:, mailto:, tel: - keep as is
-        return match;
-      } else {
-        // Relative URL - resolve it properly
-        let resolvedPath: string;
-        if (urlStr.startsWith("/")) {
-          // Absolute path relative to root
-          resolvedPath = urlStr;
-        } else if (urlStr.startsWith("components/") || urlStr.startsWith("images/") || urlStr.startsWith("videos/") || urlStr.startsWith("audio/")) {
-          // Paths starting with known directories should be treated as absolute from root
-          resolvedPath = "/" + urlStr;
-        } else {
-          // Relative path - resolve relative to current directory
-          resolvedPath = currentDir + urlStr;
-          // Normalize the path (remove ./ and ../)
-          const parts = resolvedPath.split("/");
-          const normalized: string[] = [];
-          for (const part of parts) {
-            if (part === "..") {
-              normalized.pop();
-            } else if (part !== "." && part !== "") {
-              normalized.push(part);
-            }
-          }
-          resolvedPath = "/" + normalized.join("/");
-        }
-        const [path, search] = resolvedPath.split("?");
-        const pathPart = path === "/" ? "" : path;
-        const searchPart = search ? `&${search}` : "";
-        return `href="${proxyBaseUrl}${pathPart}${targetUrlParam}${searchPart}"`;
-      }
-    }
-  );
-
-  // Rewrite relative URLs in src attributes
-  processed = processed.replace(
-    /src=["']([^"']+)["']/gi,
-    (match, urlStr) => {
-      if (urlStr.startsWith("http://") || urlStr.startsWith("https://")) {
-        try {
-          const urlObj = new URL(urlStr);
-          if (urlObj.hostname === targetHost) {
-            const pathPart = urlObj.pathname === "/" ? "" : urlObj.pathname;
-            const searchPart = urlObj.search ? `&${urlObj.search.substring(1)}` : "";
-            return `src="${proxyBaseUrl}${pathPart}${targetUrlParam}${searchPart}"`;
-          }
-        } catch {
-          // Invalid URL, keep as is
-        }
-        return match;
-      } else if (urlStr.startsWith("//")) {
-        try {
-          const urlObj = new URL(`https:${urlStr}`);
-          if (urlObj.hostname === targetHost) {
-            const pathPart = urlObj.pathname === "/" ? "" : urlObj.pathname;
-            const searchPart = urlObj.search ? `&${urlObj.search.substring(1)}` : "";
-            return `src="${proxyBaseUrl}${pathPart}${targetUrlParam}${searchPart}"`;
-          }
-        } catch {
-          // Invalid URL, keep as is
-        }
-        return match;
-      } else if (urlStr.startsWith("data:") || urlStr.startsWith("blob:")) {
-        // Data URLs and blob URLs - keep as is
-        return match;
-      } else {
-        // Relative URL - resolve it properly
-        let resolvedPath: string;
-        if (urlStr.startsWith("/")) {
-          // Absolute path relative to root
-          resolvedPath = urlStr;
-        } else if (urlStr.startsWith("components/") || urlStr.startsWith("images/") || urlStr.startsWith("videos/") || urlStr.startsWith("audio/")) {
-          // Paths starting with known directories should be treated as absolute from root
-          resolvedPath = "/" + urlStr;
-        } else {
-          // Relative path - resolve relative to current directory
-          resolvedPath = currentDir + urlStr;
-          // Normalize the path (remove ./ and ../)
-          const parts = resolvedPath.split("/");
-          const normalized: string[] = [];
-          for (const part of parts) {
-            if (part === "..") {
-              normalized.pop();
-            } else if (part !== "." && part !== "") {
-              normalized.push(part);
-            }
-          }
-          resolvedPath = "/" + normalized.join("/");
-        }
-        const [path, search] = resolvedPath.split("?");
-        const pathPart = path === "/" ? "" : path;
-        const searchPart = search ? `&${search}` : "";
-        return `src="${proxyBaseUrl}${pathPart}${targetUrlParam}${searchPart}"`;
-      }
-    }
-  );
-
-  // Rewrite URLs in action attributes (forms)
-  processed = processed.replace(
-    /action=["']([^"']+)["']/gi,
-    (match, urlStr) => {
-      if (urlStr.startsWith("http://") || urlStr.startsWith("https://")) {
-        try {
-          const urlObj = new URL(urlStr);
-          if (urlObj.hostname === targetHost) {
-            const pathPart = urlObj.pathname === "/" ? "" : urlObj.pathname;
-            const searchPart = urlObj.search ? `&${urlObj.search.substring(1)}` : "";
-            return `action="${proxyBaseUrl}${pathPart}${targetUrlParam}${searchPart}"`;
-          }
-        } catch {
-          // Invalid URL, keep as is
-        }
-        return match;
-      } else if (urlStr.startsWith("//")) {
-        try {
-          const urlObj = new URL(`https:${urlStr}`);
-          if (urlObj.hostname === targetHost) {
-            const pathPart = urlObj.pathname === "/" ? "" : urlObj.pathname;
-            const searchPart = urlObj.search ? `&${urlObj.search.substring(1)}` : "";
-            return `action="${proxyBaseUrl}${pathPart}${targetUrlParam}${searchPart}"`;
-          }
-        } catch {
-          // Invalid URL, keep as is
-        }
-        return match;
-      } else {
-        // Relative URL - rewrite to proxy
-        const cleanUrl = urlStr.startsWith("/") ? urlStr : `/${urlStr}`;
-        const [path, search] = cleanUrl.split("?");
-        const pathPart = path === "/" ? "" : path;
-        const searchPart = search ? `&${search}` : "";
-        return `action="${proxyBaseUrl}${pathPart}${targetUrlParam}${searchPart}"`;
-      }
-    }
-  );
-
-  // Rewrite URLs in CSS url() functions within style tags
-  processed = processed.replace(
-    /<style[^>]*>([\s\S]*?)<\/style>/gi,
-    (match, cssContent) => {
-      const rewrittenCss = rewriteCssUrls(cssContent, targetHost, proxyBaseUrl, targetUrlParam);
-      return match.replace(cssContent, rewrittenCss);
-    }
-  );
-
-  return processed;
-}
-
-function injectNavigationInterceptor(
-  html: string,
-  targetHost: string,
-  proxyBaseUrl: string,
-  targetUrlParam: string
-): string {
-  // Escape strings for safe injection
-  const escapeJs = (str: string) => {
-    return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
-  };
-  
-  const escapedProxyBaseUrl = escapeJs(proxyBaseUrl);
-  const escapedTargetUrlParam = escapeJs(targetUrlParam);
-  const escapedTargetHost = escapeJs(targetHost);
-  
-  const interceptorScript = `
-    <script>
-      (function() {
-        const proxyBaseUrl = "${escapedProxyBaseUrl}";
-        const targetUrlParam = "${escapedTargetUrlParam}";
-        const targetHost = "${escapedTargetHost}";
-        
-        // Helper function to convert URL to proxy URL
-        function convertToProxyUrl(url) {
-          try {
-            const urlObj = typeof url === 'string' ? new URL(url, window.location.href) : url;
-            if (urlObj.hostname === targetHost || urlObj.hostname === window.location.hostname) {
-              const pathPart = urlObj.pathname === "/" ? "" : urlObj.pathname;
-              const searchPart = urlObj.search ? urlObj.search.substring(1) : "";
-              return proxyBaseUrl + pathPart + targetUrlParam + (searchPart ? "&" + searchPart : "");
-            }
-            return typeof url === 'string' ? url : urlObj.href;
-          } catch (e) {
-            // Relative URL or invalid URL
-            const urlStr = typeof url === 'string' ? url : url.href || '';
-            const pathPart = urlStr.startsWith("/") ? urlStr.split("?")[0] : "/" + urlStr.split("?")[0];
-            const searchPart = urlStr.includes("?") ? urlStr.split("?")[1] : "";
-            return proxyBaseUrl + pathPart + targetUrlParam + (searchPart ? "&" + searchPart : "");
-          }
-        }
-        
-        // Intercept window.location.replace()
-        const originalReplace = window.location.replace.bind(window.location);
-        window.location.replace = function(url) {
-          const proxyUrl = convertToProxyUrl(url);
-          originalReplace(proxyUrl);
-        };
-        
-        // Intercept window.location.assign()
-        const originalAssign = window.location.assign.bind(window.location);
-        window.location.assign = function(url) {
-          const proxyUrl = convertToProxyUrl(url);
-          originalAssign(proxyUrl);
-        };
-        
-        // Intercept direct assignment to location.href using a proxy
-        // Since we can't override window.location, we intercept href assignments
-        // Try to intercept href setter, but handle gracefully if it's not configurable
-        try {
-          let locationHrefDescriptor = Object.getOwnPropertyDescriptor(window.location, 'href');
-          if (locationHrefDescriptor && locationHrefDescriptor.set && locationHrefDescriptor.configurable) {
-            const originalHrefSetter = locationHrefDescriptor.set;
-            Object.defineProperty(window.location, 'href', {
-              get: locationHrefDescriptor.get,
-              set: function(url) {
-                const proxyUrl = convertToProxyUrl(url);
-                originalHrefSetter.call(window.location, proxyUrl);
-              },
-              configurable: true,
-              enumerable: true
-            });
-          }
-        } catch (e) {
-          // If we can't intercept href setter, that's okay - replace() and assign() are intercepted
-          console.warn('Could not intercept location.href setter:', e);
-        }
-      })();
-    </script>
-  `;
-  
-  // Inject script before closing </head> or before </body>
-  if (html.includes("</head>")) {
-    return html.replace("</head>", interceptorScript + "</head>");
-  } else if (html.includes("</body>")) {
-    return html.replace("</body>", interceptorScript + "</body>");
-  } else {
-    return interceptorScript + html;
-  }
-}
-
-function rewriteCssUrls(
-  css: string,
-  targetHost: string,
-  proxyBaseUrl: string,
-  targetUrlParam: string
-): string {
-  return css.replace(
-    /url\(["']?([^"')]+)["']?\)/gi,
-    (match, urlStr) => {
-      // Remove quotes if present
-      const cleanUrl = urlStr.replace(/^["']|["']$/g, "");
-      
-      if (cleanUrl.startsWith("http://") || cleanUrl.startsWith("https://")) {
-        try {
-          const urlObj = new URL(cleanUrl);
-          if (urlObj.hostname === targetHost) {
-            const pathPart = urlObj.pathname === "/" ? "" : urlObj.pathname;
-            const searchPart = urlObj.search ? `&${urlObj.search.substring(1)}` : "";
-            return `url("${proxyBaseUrl}${pathPart}${targetUrlParam}${searchPart}")`;
-          }
-        } catch {
-          // Invalid URL, keep as is
-        }
-        return match;
-      } else if (cleanUrl.startsWith("//")) {
-        try {
-          const urlObj = new URL(`https:${cleanUrl}`);
-          if (urlObj.hostname === targetHost) {
-            const pathPart = urlObj.pathname === "/" ? "" : urlObj.pathname;
-            const searchPart = urlObj.search ? `&${urlObj.search.substring(1)}` : "";
-            return `url("${proxyBaseUrl}${pathPart}${targetUrlParam}${searchPart}")`;
-          }
-        } catch {
-          // Invalid URL, keep as is
-        }
-        return match;
-      } else if (cleanUrl.startsWith("data:") || cleanUrl.startsWith("blob:")) {
-        // Data URLs and blob URLs - keep as is
-        return match;
-      } else {
-        // Relative URL - rewrite to proxy
-        const cleanUrlPath = cleanUrl.startsWith("/") ? cleanUrl : `/${cleanUrl}`;
-        const [path, search] = cleanUrlPath.split("?");
-        const pathPart = path === "/" ? "" : path;
-        const searchPart = search ? `&${search}` : "";
-        return `url("${proxyBaseUrl}${pathPart}${targetUrlParam}${searchPart}")`;
-      }
-    }
-  );
-}
-
-function rewriteJsUrls(
-  js: string,
-  targetHost: string,
-  proxyBaseUrl: string,
-  targetUrlParam: string
-): string {
-  // This is a basic implementation - JavaScript URL rewriting is complex
-  // For now, we'll handle common patterns like fetch() and XMLHttpRequest
-  let processed = js;
-
-  // Rewrite fetch() calls with relative URLs
-  processed = processed.replace(
-    /fetch\(["']([^"']+)["']\)/gi,
-    (match, urlStr) => {
-      if (urlStr.startsWith("http://") || urlStr.startsWith("https://")) {
-        try {
-          const urlObj = new URL(urlStr);
-          if (urlObj.hostname === targetHost) {
-            const pathPart = urlObj.pathname === "/" ? "" : urlObj.pathname;
-            const searchPart = urlObj.search ? `&${urlObj.search.substring(1)}` : "";
-            return `fetch("${proxyBaseUrl}${pathPart}${targetUrlParam}${searchPart}")`;
-          }
-        } catch {
-          // Invalid URL, keep as is
-        }
-        return match;
-      } else if (!urlStr.startsWith("//") && !urlStr.startsWith("data:") && !urlStr.startsWith("blob:")) {
-        // Relative URL - rewrite to proxy
-        const cleanUrl = urlStr.startsWith("/") ? urlStr : `/${urlStr}`;
-        const [path, search] = cleanUrl.split("?");
-        const pathPart = path === "/" ? "" : path;
-        const searchPart = search ? `&${search}` : "";
-        return `fetch("${proxyBaseUrl}${pathPart}${targetUrlParam}${searchPart}")`;
-      }
-      return match;
-    }
-  );
-
-  return processed;
-}
-

app/api/proxy/route.ts

@@ -1,557 +0,0 @@
-import { NextRequest, NextResponse } from "next/server";
-
-export async function GET(req: NextRequest) {
-  // Get the target URL from query parameter
-  const targetUrl = req.nextUrl.searchParams.get("url");
-  
-  if (!targetUrl) {
-    return NextResponse.json(
-      { error: "Missing 'url' query parameter" },
-      { status: 400 }
-    );
-  }
-
-  try {
-    // Parse the target URL
-    const url = new URL(targetUrl);
-    
-    // Only allow static.hf.space domains for security
-    if (!url.hostname.endsWith(".static.hf.space")) {
-      return NextResponse.json(
-        { error: "Only static.hf.space domains are allowed" },
-        { status: 403 }
-      );
-    }
-
-    // Use the pathname from the URL query param, or "/" for root
-    const targetPath = url.pathname || "/";
-    
-    // Merge query parameters from the request URL with the target URL's search params
-    const requestSearchParams = req.nextUrl.searchParams;
-    const targetSearchParams = new URLSearchParams(url.search);
-    
-    // Copy all query params except 'url' to the target URL
-    requestSearchParams.forEach((value, key) => {
-      if (key !== "url") {
-        targetSearchParams.set(key, value);
-      }
-    });
-    
-    const searchString = targetSearchParams.toString();
-    const fullTargetUrl = `${url.protocol}//${url.hostname}${targetPath}${searchString ? `?${searchString}` : ""}`;
-
-    // Fetch the content from the target URL
-    const response = await fetch(fullTargetUrl, {
-      headers: {
-        "User-Agent": "Mozilla/5.0 (compatible; DeepSite/1.0)",
-      },
-      redirect: "follow", // Follow redirects automatically
-    });
-
-    if (!response.ok) {
-      return NextResponse.json(
-        { error: `Failed to fetch: ${response.statusText}` },
-        { status: response.status }
-      );
-    }
-
-    let contentType = response.headers.get("content-type") || "";
-    const content = await response.text();
-
-    // Detect content type from URL path if not properly set
-    if (!contentType || contentType === "text/plain" || contentType === "application/octet-stream") {
-      const urlPath = url.pathname || "";
-      const fileExtension = urlPath.split(".").pop()?.toLowerCase();
-      
-      if (fileExtension === "js") {
-        contentType = "application/javascript";
-      } else if (fileExtension === "css") {
-        contentType = "text/css";
-      } else if (fileExtension === "html" || fileExtension === "htm") {
-        contentType = "text/html";
-      } else if (fileExtension === "json") {
-        contentType = "application/json";
-      }
-    }
-
-    // Get the base proxy URL
-    const requestUrl = new URL(req.url);
-    const proxyIndex = requestUrl.pathname.indexOf("/api/proxy");
-    const basePath = proxyIndex > 0 ? requestUrl.pathname.substring(0, proxyIndex) : "";
-    const proxyBaseUrl = `${basePath}/api/proxy`;
-    // Build the base target URL with the path included
-    const baseTargetUrl = `https://${url.hostname}${targetPath}`;
-    const targetUrlParam = `?url=${encodeURIComponent(baseTargetUrl)}`;
-
-    // Rewrite URLs in HTML content
-    let processedContent = content;
-    
-    if (contentType.includes("text/html")) {
-      // Rewrite relative URLs and URLs pointing to the same domain
-      processedContent = rewriteUrls(
-        content,
-        url.hostname,
-        proxyBaseUrl,
-        baseTargetUrl,
-        [] // Empty path segments for root route
-      );
-      
-      // Inject script to intercept JavaScript-based navigation
-      processedContent = injectNavigationInterceptor(
-        processedContent,
-        url.hostname,
-        proxyBaseUrl,
-        targetUrlParam
-      );
-    } else if (contentType.includes("text/css")) {
-      // Rewrite URLs in CSS
-      processedContent = rewriteCssUrls(
-        content,
-        url.hostname,
-        proxyBaseUrl,
-        targetUrlParam
-      );
-    } else if (contentType.includes("application/javascript") || contentType.includes("text/javascript")) {
-      // For component files and most JavaScript, don't rewrite URLs
-      // Only rewrite if needed (for fetch calls, etc.)
-      // Most component JavaScript files don't need URL rewriting
-      // Only rewrite if the file contains fetch calls with relative URLs
-      if (content.includes("fetch(") && content.match(/fetch\(["'][^"']*[^\/]\./)) {
-        processedContent = rewriteJsUrls(
-          content,
-          url.hostname,
-          proxyBaseUrl,
-          targetUrlParam
-        );
-      } else {
-        // Don't modify component JavaScript files - they should work as-is
-        processedContent = content;
-      }
-    }
-
-    // Ensure JavaScript files have charset specified
-    let finalContentType = contentType;
-    if (contentType.includes("javascript") && !contentType.includes("charset")) {
-      finalContentType = contentType.includes(";") 
-        ? contentType + "; charset=utf-8"
-        : contentType + "; charset=utf-8";
-    }
-
-    // Return the processed content with appropriate headers
-    return new NextResponse(processedContent, {
-      status: 200,
-      headers: {
-        "Content-Type": finalContentType,
-        "X-Content-Type-Options": "nosniff",
-        // Don't set X-Frame-Options for JavaScript files - they need to execute
-        ...(contentType.includes("text/html") && { "X-Frame-Options": "SAMEORIGIN" }),
-        // Remove CORS restrictions since we're proxying
-        "Access-Control-Allow-Origin": "*",
-        "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
-        "Access-Control-Allow-Headers": "Content-Type",
-      },
-    });
-  } catch (error: any) {
-    console.error("Proxy error:", error);
-    return NextResponse.json(
-      { error: error.message || "Proxy error occurred" },
-      { status: 500 }
-    );
-  }
-}
-
-// Import the helper functions from the catch-all route
-// We'll need to move these to a shared file or duplicate them here
-// For now, let's duplicate them to avoid refactoring
-
-function rewriteUrls(
-  html: string,
-  targetHost: string,
-  proxyBaseUrl: string,
-  baseTargetUrl: string,
-  currentPathSegments: string[] = []
-): string {
-  let processed = html;
-
-  // Get the current directory path for resolving relative URLs
-  const currentDir = currentPathSegments.length > 0 
-    ? "/" + currentPathSegments.slice(0, -1).join("/") + "/"
-    : "/";
-
-  // Helper function to build proxy URL with path in query parameter
-  const buildProxyUrl = (path: string, search?: string) => {
-    const fullTargetUrl = `https://${targetHost}${path}`;
-    const encodedUrl = encodeURIComponent(fullTargetUrl);
-    const searchPart = search ? `&${search}` : "";
-    return `${proxyBaseUrl}?url=${encodedUrl}${searchPart}`;
-  };
-
-  // Rewrite relative URLs in href attributes
-  processed = processed.replace(
-    /href=["']([^"']+)["']/gi,
-    (match, urlStr) => {
-      if (urlStr.startsWith("http://") || urlStr.startsWith("https://")) {
-        // Absolute URL - rewrite if it's the same domain
-        try {
-          const urlObj = new URL(urlStr);
-          if (urlObj.hostname === targetHost) {
-            const searchPart = urlObj.search ? urlObj.search.substring(1) : "";
-            return `href="${buildProxyUrl(urlObj.pathname, searchPart)}"`;
-          }
-        } catch {
-          // Invalid URL, keep as is
-        }
-        return match;
-      } else if (urlStr.startsWith("//")) {
-        // Protocol-relative URL
-        try {
-          const urlObj = new URL(`https:${urlStr}`);
-          if (urlObj.hostname === targetHost) {
-            const searchPart = urlObj.search ? urlObj.search.substring(1) : "";
-            return `href="${buildProxyUrl(urlObj.pathname, searchPart)}"`;
-          }
-        } catch {
-          // Invalid URL, keep as is
-        }
-        return match;
-      } else if (urlStr.startsWith("#") || urlStr.startsWith("javascript:") || urlStr.startsWith("mailto:") || urlStr.startsWith("tel:")) {
-        // Hash links, javascript:, mailto:, tel: - keep as is
-        return match;
-      } else {
-        // Relative URL - resolve it properly
-        let resolvedPath: string;
-        if (urlStr.startsWith("/")) {
-          // Absolute path relative to root
-          resolvedPath = urlStr;
-        } else if (urlStr.startsWith("components/") || urlStr.startsWith("images/") || urlStr.startsWith("videos/") || urlStr.startsWith("audio/")) {
-          // Paths starting with known directories should be treated as absolute from root
-          resolvedPath = "/" + urlStr;
-        } else {
-          // Relative path - resolve relative to current directory
-          resolvedPath = currentDir + urlStr;
-          // Normalize the path (remove ./ and ../)
-          const parts = resolvedPath.split("/");
-          const normalized: string[] = [];
-          for (const part of parts) {
-            if (part === "..") {
-              normalized.pop();
-            } else if (part !== "." && part !== "") {
-              normalized.push(part);
-            }
-          }
-          resolvedPath = "/" + normalized.join("/");
-        }
-        const [path, search] = resolvedPath.split("?");
-        const normalizedPath = path === "/" ? "/" : path;
-        return `href="${buildProxyUrl(normalizedPath, search)}"`;
-      }
-    }
-  );
-
-  // Rewrite relative URLs in src attributes
-  processed = processed.replace(
-    /src=["']([^"']+)["']/gi,
-    (match, urlStr) => {
-      if (urlStr.startsWith("http://") || urlStr.startsWith("https://")) {
-        try {
-          const urlObj = new URL(urlStr);
-          if (urlObj.hostname === targetHost) {
-            const searchPart = urlObj.search ? urlObj.search.substring(1) : "";
-            return `src="${buildProxyUrl(urlObj.pathname, searchPart)}"`;
-          }
-        } catch {
-          // Invalid URL, keep as is
-        }
-        return match;
-      } else if (urlStr.startsWith("//")) {
-        try {
-          const urlObj = new URL(`https:${urlStr}`);
-          if (urlObj.hostname === targetHost) {
-            const searchPart = urlObj.search ? urlObj.search.substring(1) : "";
-            return `src="${buildProxyUrl(urlObj.pathname, searchPart)}"`;
-          }
-        } catch {
-          // Invalid URL, keep as is
-        }
-        return match;
-      } else if (urlStr.startsWith("data:") || urlStr.startsWith("blob:")) {
-        // Data URLs and blob URLs - keep as is
-        return match;
-      } else {
-        // Relative URL - resolve it properly
-        let resolvedPath: string;
-        if (urlStr.startsWith("/")) {
-          // Absolute path relative to root
-          resolvedPath = urlStr;
-        } else if (urlStr.startsWith("components/") || urlStr.startsWith("images/") || urlStr.startsWith("videos/") || urlStr.startsWith("audio/")) {
-          // Paths starting with known directories should be treated as absolute from root
-          resolvedPath = "/" + urlStr;
-        } else {
-          // Relative path - resolve relative to current directory
-          resolvedPath = currentDir + urlStr;
-          // Normalize the path (remove ./ and ../)
-          const parts = resolvedPath.split("/");
-          const normalized: string[] = [];
-          for (const part of parts) {
-            if (part === "..") {
-              normalized.pop();
-            } else if (part !== "." && part !== "") {
-              normalized.push(part);
-            }
-          }
-          resolvedPath = "/" + normalized.join("/");
-        }
-        const [path, search] = resolvedPath.split("?");
-        const normalizedPath = path === "/" ? "/" : path;
-        return `src="${buildProxyUrl(normalizedPath, search)}"`;
-      }
-    }
-  );
-
-  // Rewrite URLs in action attributes (forms)
-  processed = processed.replace(
-    /action=["']([^"']+)["']/gi,
-    (match, urlStr) => {
-      if (urlStr.startsWith("http://") || urlStr.startsWith("https://")) {
-        try {
-          const urlObj = new URL(urlStr);
-          if (urlObj.hostname === targetHost) {
-            const searchPart = urlObj.search ? urlObj.search.substring(1) : "";
-            return `action="${buildProxyUrl(urlObj.pathname, searchPart)}"`;
-          }
-        } catch {
-          // Invalid URL, keep as is
-        }
-        return match;
-      } else if (urlStr.startsWith("//")) {
-        try {
-          const urlObj = new URL(`https:${urlStr}`);
-          if (urlObj.hostname === targetHost) {
-            const searchPart = urlObj.search ? urlObj.search.substring(1) : "";
-            return `action="${buildProxyUrl(urlObj.pathname, searchPart)}"`;
-          }
-        } catch {
-          // Invalid URL, keep as is
-        }
-        return match;
-      } else {
-        // Relative URL - resolve it properly
-        let resolvedPath: string;
-        if (urlStr.startsWith("/")) {
-          resolvedPath = urlStr;
-        } else if (urlStr.startsWith("components/") || urlStr.startsWith("images/") || urlStr.startsWith("videos/") || urlStr.startsWith("audio/")) {
-          resolvedPath = "/" + urlStr;
-        } else {
-          resolvedPath = currentDir + urlStr;
-          const parts = resolvedPath.split("/");
-          const normalized: string[] = [];
-          for (const part of parts) {
-            if (part === "..") {
-              normalized.pop();
-            } else if (part !== "." && part !== "") {
-              normalized.push(part);
-            }
-          }
-          resolvedPath = "/" + normalized.join("/");
-        }
-        const [path, search] = resolvedPath.split("?");
-        const normalizedPath = path === "/" ? "/" : path;
-        return `action="${buildProxyUrl(normalizedPath, search)}"`;
-      }
-    }
-  );
-
-  // Rewrite URLs in CSS url() functions within style tags
-  processed = processed.replace(
-    /<style[^>]*>([\s\S]*?)<\/style>/gi,
-    (match, cssContent) => {
-      const rewrittenCss = rewriteCssUrls(cssContent, targetHost, proxyBaseUrl, baseTargetUrl);
-      return match.replace(cssContent, rewrittenCss);
-    }
-  );
-
-  return processed;
-}
-
-function injectNavigationInterceptor(
-  html: string,
-  targetHost: string,
-  proxyBaseUrl: string,
-  targetUrlParam: string
-): string {
-  // Escape strings for safe injection
-  const escapeJs = (str: string) => {
-    return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
-  };
-  
-  const escapedProxyBaseUrl = escapeJs(proxyBaseUrl);
-  const escapedTargetUrlParam = escapeJs(targetUrlParam);
-  const escapedTargetHost = escapeJs(targetHost);
-  
-  const interceptorScript = `
-    <script>
-      (function() {
-        const proxyBaseUrl = "${escapedProxyBaseUrl}";
-        const targetUrlParam = "${escapedTargetUrlParam}";
-        const targetHost = "${escapedTargetHost}";
-        
-        // Helper function to convert URL to proxy URL
-        function convertToProxyUrl(url) {
-          try {
-            const urlObj = typeof url === 'string' ? new URL(url, window.location.href) : url;
-            if (urlObj.hostname === targetHost || urlObj.hostname === window.location.hostname) {
-              const pathPart = urlObj.pathname === "/" ? "" : urlObj.pathname;
-              const searchPart = urlObj.search ? urlObj.search.substring(1) : "";
-              return proxyBaseUrl + pathPart + targetUrlParam + (searchPart ? "&" + searchPart : "");
-            }
-            return typeof url === 'string' ? url : urlObj.href;
-          } catch (e) {
-            // Relative URL or invalid URL
-            const urlStr = typeof url === 'string' ? url : url.href || '';
-            const pathPart = urlStr.startsWith("/") ? urlStr.split("?")[0] : "/" + urlStr.split("?")[0];
-            const searchPart = urlStr.includes("?") ? urlStr.split("?")[1] : "";
-            return proxyBaseUrl + pathPart + targetUrlParam + (searchPart ? "&" + searchPart : "");
-          }
-        }
-        
-        // Intercept window.location.replace()
-        const originalReplace = window.location.replace.bind(window.location);
-        window.location.replace = function(url) {
-          const proxyUrl = convertToProxyUrl(url);
-          originalReplace(proxyUrl);
-        };
-        
-        // Intercept window.location.assign()
-        const originalAssign = window.location.assign.bind(window.location);
-        window.location.assign = function(url) {
-          const proxyUrl = convertToProxyUrl(url);
-          originalAssign(proxyUrl);
-        };
-        
-        // Intercept direct assignment to location.href using a proxy
-        // Since we can't override window.location, we intercept href assignments
-        // Try to intercept href setter, but handle gracefully if it's not configurable
-        try {
-          let locationHrefDescriptor = Object.getOwnPropertyDescriptor(window.location, 'href');
-          if (locationHrefDescriptor && locationHrefDescriptor.set && locationHrefDescriptor.configurable) {
-            const originalHrefSetter = locationHrefDescriptor.set;
-            Object.defineProperty(window.location, 'href', {
-              get: locationHrefDescriptor.get,
-              set: function(url) {
-                const proxyUrl = convertToProxyUrl(url);
-                originalHrefSetter.call(window.location, proxyUrl);
-              },
-              configurable: true,
-              enumerable: true
-            });
-          }
-        } catch (e) {
-          // If we can't intercept href setter, that's okay - replace() and assign() are intercepted
-          console.warn('Could not intercept location.href setter:', e);
-        }
-      })();
-    </script>
-  `;
-  
-  // Inject script before closing </head> or before </body>
-  if (html.includes("</head>")) {
-    return html.replace("</head>", interceptorScript + "</head>");
-  } else if (html.includes("</body>")) {
-    return html.replace("</body>", interceptorScript + "</body>");
-  } else {
-    return interceptorScript + html;
-  }
-}
-
-function rewriteCssUrls(
-  css: string,
-  targetHost: string,
-  proxyBaseUrl: string,
-  targetUrlParam: string
-): string {
-  return css.replace(
-    /url\(["']?([^"')]+)["']?\)/gi,
-    (match, urlStr) => {
-      // Remove quotes if present
-      const cleanUrl = urlStr.replace(/^["']|["']$/g, "");
-      
-      if (cleanUrl.startsWith("http://") || cleanUrl.startsWith("https://")) {
-        try {
-          const urlObj = new URL(cleanUrl);
-          if (urlObj.hostname === targetHost) {
-            const pathPart = urlObj.pathname === "/" ? "" : urlObj.pathname;
-            const searchPart = urlObj.search ? `&${urlObj.search.substring(1)}` : "";
-            return `url("${proxyBaseUrl}${pathPart}${targetUrlParam}${searchPart}")`;
-          }
-        } catch {
-          // Invalid URL, keep as is
-        }
-        return match;
-      } else if (cleanUrl.startsWith("//")) {
-        try {
-          const urlObj = new URL(`https:${cleanUrl}`);
-          if (urlObj.hostname === targetHost) {
-            const pathPart = urlObj.pathname === "/" ? "" : urlObj.pathname;
-            const searchPart = urlObj.search ? `&${urlObj.search.substring(1)}` : "";
-            return `url("${proxyBaseUrl}${pathPart}${targetUrlParam}${searchPart}")`;
-          }
-        } catch {
-          // Invalid URL, keep as is
-        }
-        return match;
-      } else if (cleanUrl.startsWith("data:") || cleanUrl.startsWith("blob:")) {
-        // Data URLs and blob URLs - keep as is
-        return match;
-      } else {
-        // Relative URL - rewrite to proxy
-        const cleanUrlPath = cleanUrl.startsWith("/") ? cleanUrl : `/${cleanUrl}`;
-        const [path, search] = cleanUrlPath.split("?");
-        const pathPart = path === "/" ? "" : path;
-        const searchPart = search ? `&${search}` : "";
-        return `url("${proxyBaseUrl}${pathPart}${targetUrlParam}${searchPart}")`;
-      }
-    }
-  );
-}
-
-function rewriteJsUrls(
-  js: string,
-  targetHost: string,
-  proxyBaseUrl: string,
-  targetUrlParam: string
-): string {
-  // This is a basic implementation - JavaScript URL rewriting is complex
-  // For now, we'll handle common patterns like fetch() and XMLHttpRequest
-  let processed = js;
-
-  // Rewrite fetch() calls with relative URLs
-  processed = processed.replace(
-    /fetch\(["']([^"']+)["']\)/gi,
-    (match, urlStr) => {
-      if (urlStr.startsWith("http://") || urlStr.startsWith("https://")) {
-        try {
-          const urlObj = new URL(urlStr);
-          if (urlObj.hostname === targetHost) {
-            const pathPart = urlObj.pathname === "/" ? "" : urlObj.pathname;
-            const searchPart = urlObj.search ? `&${urlObj.search.substring(1)}` : "";
-            return `fetch("${proxyBaseUrl}${pathPart}${targetUrlParam}${searchPart}")`;
-          }
-        } catch {
-          // Invalid URL, keep as is
-        }
-        return match;
-      } else if (!urlStr.startsWith("//") && !urlStr.startsWith("data:") && !urlStr.startsWith("blob:")) {
-        // Relative URL - rewrite to proxy
-        const cleanUrl = urlStr.startsWith("/") ? urlStr : `/${urlStr}`;
-        const [path, search] = cleanUrl.split("?");
-        const pathPart = path === "/" ? "" : path;
-        const searchPart = search ? `&${search}` : "";
-        return `fetch("${proxyBaseUrl}${pathPart}${targetUrlParam}${searchPart}")`;
-      }
-      return match;
-    }
-  );
-
-  return processed;
-}
-