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文字列
                                               // 例："https://api.openai.com/" または "https://openrouter.ai/api"

  // parsedTargetBaseUrl.pathname をチェック：
  // - "https://api.openai.com" -> pathname は "/"
  // - "https://openrouter.ai/api" -> pathname は "/api"
  // - "https://openrouter.ai/api/" -> pathname は "/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 });