Lainbo's Blog

import { serve, type ServeHandlerInfo } from "https://deno.land/std@0.224.0/http/server.ts";

// 定義路徑到目標URL的映射
// 鍵是代理伺服器接收到的路徑前綴，值是對應的目標伺服器基礎URL
const pathMappings: Record<string, string> = {
  '/anthropic': 'https://api.anthropic.com',
  '/gemini': 'https://generativelanguage.googleapis.com',
  '/openai': 'https://api.openai.com', // 目標是根路徑
  '/openrouter': 'https://openrouter.ai/api', // 目標本身有路徑 /api
  '/xai': 'https://api.x.ai',
  '/telegram': 'https://api.telegram.org',
  '/discord': 'https://discord.com/api',    // 目標本身有路徑 /api
  '/groq': 'https://api.groq.com/openai',   // 目標本身有路徑 /openai
  '/cohere': 'https://api.cohere.ai',
  '/huggingface': 'https://api-inference.huggingface.co',
  '/together': 'https://api.together.xyz',
  '/novita': 'https://api.novita.ai',
  '/portkey': 'https://api.portkey.ai',
  '/fireworks': 'https://api.fireworks.ai/inference', // 目標本身有路徑 /inference
  '/koofr': 'https://app.koofr.net',
};

// 從環境變量 "PORT" 獲取端口號，如果未設置則默認為 8000
const port = parseInt(Deno.env.get("PORT") || "8000");

console.log(`代理伺服器正在啟動，監聽端口: http://localhost:${port}`);

// 啟動HTTP伺服器，為每個請求調用回調函數
serve(async (req: Request, _connInfo: ServeHandlerInfo) => {
  const incomingUrl = new URL(req.url); // 解析入站請求的URL
  const incomingPathname = incomingUrl.pathname; // 獲取入站請求的路徑部分

  // 創建包含安全相關頭部的 Headers 對象
  const createSecureHeaders = (contentType?: string): Headers => {
    const headers = new Headers();
    if (contentType) {
      headers.set('Content-Type', contentType);
    }
    headers.set('X-Content-Type-Options', 'nosniff');
    headers.set('X-Frame-Options', 'DENY');
    headers.set('Referrer-Policy', 'no-referrer');
    return headers;
  };

  if (incomingPathname === '/' || incomingPathname === '/index.html') {
    return new Response(null, {
      status: 404,
      headers: createSecureHeaders()
    });
  }

  if (incomingPathname === '/robots.txt') {
    return new Response('User-agent: *\nDisallow: /', {
      status: 200,
      headers: createSecureHeaders('text/plain')
    });
  }

  let targetBaseUrlString: string | undefined;
  let matchedPrefix: string | undefined;

  for (const prefix in pathMappings) {
    if (incomingPathname.startsWith(prefix)) {
      targetBaseUrlString = pathMappings[prefix];
      matchedPrefix = prefix;
      break;
    }
  }

  if (!targetBaseUrlString || !matchedPrefix) {
    console.warn(`[${new Date().toISOString()}] 未找到路徑映射: ${incomingPathname}`);
    return new Response("未找到: 此路徑沒有代理映射。", {
      status: 404,
      headers: createSecureHeaders('text/plain')
    });
  }

  const parsedTargetBaseUrl = new URL(targetBaseUrlString);
  // suffixPath 是入站請求路徑中，匹配掉代理前綴後的剩餘部分。
  // 例如：incomingPathname = "/openrouter/v1/chat", matchedPrefix = "/openrouter" -> suffixPath = "/v1/chat"
  // 例如：incomingPathname = "/openai/foo", matchedPrefix = "/openai" -> suffixPath = "/foo"
  // 例如：incomingPathname = "/openrouter", matchedPrefix = "/openrouter" -> suffixPath = ""
  const suffixPath = incomingPathname.substring(matchedPrefix.length);

  // --- 路徑拼接邏輯 ---
  // 1. 規範化基礎URL (`baseForNewUrl`)
  //    目標是確保如果 parsedTargetBaseUrl 本身有路徑 (其 pathname 不是根路徑"/")，
  //    那麼 baseForNewUrl 的字符串表示應該以 "/" 結尾，以便 new URL() 正確地追加相對路徑。
  let baseForNewUrl = parsedTargetBaseUrl.href; // 初始為映射中定義的URL的href字符串
                                               // e.g., "https://api.openai.com/" or "https://openrouter.ai/api"

  // 檢查 parsedTargetBaseUrl.pathname:
  // - "https://api.openai.com" -> pathname is "/"
  // - "https://openrouter.ai/api" -> pathname is "/api"
  // - "https://openrouter.ai/api/" -> pathname is "/api/"
  if (parsedTargetBaseUrl.pathname !== '/' && !baseForNewUrl.endsWith('/')) {
    // 如果目標URL的路徑不是根目錄，並且其href不以'/'結尾 (例如 "https://host.com/path")
    // 則在其末尾添加'/'，使其變為 "https://host.com/path/"
    baseForNewUrl += '/';
  }
  // 現在 baseForNewUrl 對於有路徑的基礎URL，其路徑部分會以'/'結尾 (如 "https://host.com/path/")
  // 對於根路徑的基礎URL，它可能是 "https://host.com/" 或 "https://host.com" (URL構造函數都能正確處理)

  // 2. 規範化要追加的路徑 (`pathForNewUrl`)
  //    目標是確保從 suffixPath 得到的路徑是一個相對路徑（不以 "/" 開頭）。
  let pathForNewUrl = suffixPath;
  // - suffixPath = "/v1/chat" -> pathForNewUrl = "v1/chat"
  // - suffixPath = "v1/chat"  -> pathForNewUrl = "v1/chat" (不變)
  // - suffixPath = ""        -> pathForNewUrl = "" (不變)
  if (pathForNewUrl.startsWith('/')) {
    pathForNewUrl = pathForNewUrl.substring(1);
  }

  // 3. 構建最終的目標URL
  //    使用規範化的 baseForNewUrl 和 pathForNewUrl。
  //    例如:
  //    - req: /openai/v1/chat -> target: https://api.openai.com, suffix: /v1/chat
  //      base: "https://api.openai.com/" (或 "https://api.openai.com"), path: "v1/chat"
  //      -> new URL("v1/chat", "https://api.openai.com/") -> https://api.openai.com/v1/chat
  //    - req: /openrouter/v1/chat -> target: https://openrouter.ai/api, suffix: /v1/chat
  //      base: "https://openrouter.ai/api/", path: "v1/chat"
  //      -> new URL("v1/chat", "https://openrouter.ai/api/") -> https://openrouter.ai/api/v1/chat (正確!)
  //    - req: /openrouter -> target: https://openrouter.ai/api, suffix: ""
  //      base: "https://openrouter.ai/api/", path: ""
  //      -> new URL("", "https://openrouter.ai/api/") -> https://openrouter.ai/api/
  const finalTargetUrl = new URL(pathForNewUrl + incomingUrl.search, baseForNewUrl);
  // --- 路徑拼接邏輯結束 ---

  const headersToProxy = new Headers(req.headers);
  headersToProxy.set("Host", finalTargetUrl.host); // 使用最終目標URL的主機名

  // 刪除不應被代理的 "hop-by-hop" 頭部
  headersToProxy.delete("X-Forwarded-For");
  headersToProxy.delete("X-Real-IP");
  headersToProxy.delete("Forwarded");
  headersToProxy.delete("Via");

  const proxyReq = new Request(finalTargetUrl.toString(), {
    method: req.method,
    headers: headersToProxy,
    body: req.body,
    redirect: "manual", // 代理伺服器不應自動處理重定向
  });

  try {
    const proxyRes = await fetch(proxyReq);

    // --- WebDAV 路徑重寫邏輯 ---
    // 檢查是否為需要重寫響應體的特定請求。
    // 針對 Koofr WebDAV 的場景：當請求方法為 PROPFIND (WebDAV用於列出目錄內容的方法)
    // 且請求路徑前綴為 /koofr 時，我們需要修改響應內容。
    if (matchedPrefix === '/koofr' && req.method === 'PROPFIND') {
      const contentType = proxyRes.headers.get('Content-Type') || '';
      // 確保我們只修改XML響應，這是WebDAV列表的格式。
      if (proxyRes.ok && (contentType.includes('application/xml') || contentType.includes('text/xml'))) {
        const originalBodyText = await proxyRes.text();

        // `suffixPath` 是目標伺服器上的路徑, 例如 "/dav/Koofr/webdav"
        // `incomingPathname` 是客戶端請求代理伺服器的完整路徑, 例如 "/koofr/dav/Koofr/webdav"
        // 目標伺服器返回的XML內容中包含了大量的 `suffixPath`。
        // 我們需要將它們全部替換為 `incomingPathname`，以便客戶端能構建正確的URL。
        // 例如，將 XML 中的 href="/dav/Koofr/webdav/file.zip" 替換為 href="/koofr/dav/Koofr/webdav/file.zip"。

        // 使用 String.prototype.replaceAll() 進行全局替換。
        // 增加一個安全檢查，避免 `suffixPath` 為 "/" 時替換掉所有根路徑。
        if (suffixPath && suffixPath.length > 1) {
          const rewrittenBody = originalBodyText.replaceAll(suffixPath, incomingPathname);
          
          const responseHeaders = new Headers(proxyRes.headers);
          // 因為我們修改了響應體，原有的 'Content-Length' 頭不再準確，
          // 需要刪除它，以便Deno/HTTP伺服器自動重新計算。
          responseHeaders.delete('Content-Length');

          // 為代理響應添加/確保我們自己的安全頭部
          responseHeaders.set('X-Content-Type-Options', 'nosniff');
          responseHeaders.set('X-Frame-Options', 'DENY');
          responseHeaders.set('Referrer-Policy', 'no-referrer');

          // 返回修改後的響應
          return new Response(rewrittenBody, {
            status: proxyRes.status,
            statusText: proxyRes.statusText,
            headers: responseHeaders,
          });
        }
      }
    }
    // --- WebDAV 路徑重寫邏輯結束 ---

    // 對於所有其他請求，或者不滿足上述重寫條件的請求，執行原始的透傳邏輯。
    const responseHeaders = new Headers(proxyRes.headers);

    // 從目標伺服器的響應中刪除 hop-by-hop 頭部
    responseHeaders.delete("Transfer-Encoding");
    responseHeaders.delete("Connection");
    responseHeaders.delete("Keep-Alive");
    responseHeaders.delete("Proxy-Authenticate");
    responseHeaders.delete("Proxy-Authorization");
    responseHeaders.delete("TE");
    responseHeaders.delete("Trailers");
    responseHeaders.delete("Upgrade");

    // 為代理響應添加/確保我們自己的安全頭部
    responseHeaders.set('X-Content-Type-Options', 'nosniff');
    responseHeaders.set('X-Frame-Options', 'DENY');
    responseHeaders.set('Referrer-Policy', 'no-referrer');

    return new Response(proxyRes.body, {
      status: proxyRes.status,
      statusText: proxyRes.statusText,
      headers: responseHeaders,
    });
    
  } catch (error) {
    console.error(`[${new Date().toISOString()}] 請求目標URL時出錯 ${finalTargetUrl.toString()}:`, error);
    return new Response("網關錯誤: 連接上游伺服器時出錯。", {
      status: 502,
      headers: createSecureHeaders('text/plain')
    });
  }

}, { port });