maven-proxy 1.0.1 → 1.0.2

package/src/proxy/proxy-http-handler.js

@@ -1,187 +1,187 @@
-import fs from "node:fs";
-import http from "node:http";
-import https from "node:https";
-import path from "node:path";
-import { getCacheFilePath } from "../cache/cache-path.js";
-import { detectPackageEcosystem } from "../common/ecosystem.js";
-
-function pickClient(protocol) {
-  return protocol === "https:" ? https : http;
-}
-
-function sanitizeHeaders(headers = {}) {
-  const result = { ...headers };
-  const blocked = [
-    "proxy-connection",
-    "proxy-authorization",
-    "proxy-authenticate",
-    "connection",
-    "keep-alive",
-    "transfer-encoding",
-    "upgrade",
-    "te",
-    "trailer",
-  ];
-
-  for (const key of blocked) {
-    delete result[key];
-    delete result[key.toLowerCase()];
-  }
-
-  return result;
-}
-
-async function statIfFile(filePath) {
-  try {
-    const stats = await fs.promises.stat(filePath);
-    return stats.isFile() ? stats : null;
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return null;
-    }
-    throw error;
-  }
-}
-
-function sendText(res, statusCode, message) {
-  res.writeHead(statusCode, { "content-type": "text/plain; charset=utf-8" });
-  res.end(message);
-}
-
-function buildUrl(req, forcedProtocol = null) {
-  const raw = req.url || "/";
-  if (/^https?:\/\//i.test(raw)) {
-    return new URL(raw);
-  }
-
-  const host = req.headers.host || req.socket.__mitmHost;
-  if (!host) {
-    throw new Error("Missing host header");
-  }
-
-  const protocol = forcedProtocol || "http:";
-  return new URL(`${protocol}//${host}${raw}`);
-}
-
-async function serveFile(res, req, filePath) {
-  const stats = await statIfFile(filePath);
-  if (!stats) {
-    sendText(res, 404, "Not Found");
-    return;
-  }
-
-  res.setHeader("content-length", String(stats.size));
-  if (!res.hasHeader("x-cache")) {
-    res.setHeader("x-cache", "HIT");
-  }
-
-  if (req.method === "HEAD") {
-    res.writeHead(200);
-    res.end();
-    return;
-  }
-
-  res.writeHead(200);
-  fs.createReadStream(filePath).pipe(res);
-}
-
-function forwardDirectRequest(req, res, urlObj, timeoutMs, upstreamProxyManager = null) {
-  const client = pickClient(urlObj.protocol);
-  const headers = sanitizeHeaders(req.headers);
-  headers.host = urlObj.host;
-  const agent = upstreamProxyManager ? upstreamProxyManager.getAgentForUrl(urlObj) : undefined;
-
-  if (agent) {
-    console.log(`[proxy] direct forward via upstream host=${urlObj.hostname} protocol=${urlObj.protocol}`);
-  }
-
-  const upstreamReq = client.request(
-    {
-      protocol: urlObj.protocol,
-      hostname: urlObj.hostname,
-      port: urlObj.port || (urlObj.protocol === "https:" ? 443 : 80),
-      method: req.method,
-      path: `${urlObj.pathname}${urlObj.search}`,
-      headers,
-      agent,
-    },
-    (upstreamRes) => {
-      res.writeHead(upstreamRes.statusCode || 502, upstreamRes.headers);
-      upstreamRes.pipe(res);
-    },
-  );
-
-  upstreamReq.setTimeout(timeoutMs, () => {
-    upstreamReq.destroy(new Error(`Upstream timeout after ${timeoutMs}ms`));
-  });
-
-  upstreamReq.on("error", (error) => {
-    if (!res.headersSent) {
-      sendText(res, 502, `Proxy forward failed: ${error.message}`);
-    } else {
-      res.destroy(error);
-    }
-  });
-
-  req.pipe(upstreamReq);
-}
-
-export function createHttpRequestHandler({ config, downloader, upstreamProxyManager = null, matchesDomain }) {
-  return async function handleHttpRequestPath(req, res, forcedProtocol = null) {
-    let urlObj;
-    try {
-      urlObj = buildUrl(req, forcedProtocol);
-    } catch (error) {
-      sendText(res, 400, `Bad request: ${error.message}`);
-      return;
-    }
-
-    const method = (req.method || "GET").toUpperCase();
-    if (method !== "GET" && method !== "HEAD") {
-      forwardDirectRequest(req, res, urlObj, config.downloadTimeoutMs, upstreamProxyManager);
-      return;
-    }
-
-    let cachePath;
-    try {
-      const ecosystem = detectPackageEcosystem(urlObj, config, matchesDomain);
-      cachePath = getCacheFilePath(config.cacheDir, urlObj, {
-        ecosystem,
-        includeHost: ecosystem !== "maven",
-      });
-    } catch (error) {
-      sendText(res, 400, `Invalid cache path: ${error.message}`);
-      return;
-    }
-
-    const existing = await statIfFile(cachePath);
-    if (existing) {
-      await serveFile(res, req, cachePath);
-      return;
-    }
-
-    try {
-      await fs.promises.mkdir(path.dirname(cachePath), { recursive: true });
-      await downloader.ensureCached(urlObj, cachePath, req.headers);
-      res.setHeader("x-cache", "MISS");
-      await serveFile(res, req, cachePath);
-    } catch (error) {
-      const statusCode = error.statusCode || 502;
-      sendText(res, statusCode, `Download failed: ${error.message}`);
-    }
-  };
-}
-
-export function createMitmHttpServer(handleHttpRequestPath) {
-  const server = http.createServer((req, res) => {
-    handleHttpRequestPath(req, res, "https:").catch((error) => {
-      sendText(res, 500, `MITM request failed: ${error.message}`);
-    });
-  });
-
-  server.on("clientError", (error, socket) => {
-    socket.destroy(error);
-  });
-
-  return server;
-}
+import fs from "node:fs";
+import http from "node:http";
+import https from "node:https";
+import path from "node:path";
+import { getCacheFilePath } from "../cache/cache-path.js";
+import { detectPackageEcosystem } from "../common/ecosystem.js";
+
+function pickClient(protocol) {
+  return protocol === "https:" ? https : http;
+}
+
+function sanitizeHeaders(headers = {}) {
+  const result = { ...headers };
+  const blocked = [
+    "proxy-connection",
+    "proxy-authorization",
+    "proxy-authenticate",
+    "connection",
+    "keep-alive",
+    "transfer-encoding",
+    "upgrade",
+    "te",
+    "trailer",
+  ];
+
+  for (const key of blocked) {
+    delete result[key];
+    delete result[key.toLowerCase()];
+  }
+
+  return result;
+}
+
+async function statIfFile(filePath) {
+  try {
+    const stats = await fs.promises.stat(filePath);
+    return stats.isFile() ? stats : null;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+
+function sendText(res, statusCode, message) {
+  res.writeHead(statusCode, { "content-type": "text/plain; charset=utf-8" });
+  res.end(message);
+}
+
+function buildUrl(req, forcedProtocol = null) {
+  const raw = req.url || "/";
+  if (/^https?:\/\//i.test(raw)) {
+    return new URL(raw);
+  }
+
+  const host = req.headers.host || req.socket.__mitmHost;
+  if (!host) {
+    throw new Error("Missing host header");
+  }
+
+  const protocol = forcedProtocol || "http:";
+  return new URL(`${protocol}//${host}${raw}`);
+}
+
+async function serveFile(res, req, filePath) {
+  const stats = await statIfFile(filePath);
+  if (!stats) {
+    sendText(res, 404, "Not Found");
+    return;
+  }
+
+  res.setHeader("content-length", String(stats.size));
+  if (!res.hasHeader("x-cache")) {
+    res.setHeader("x-cache", "HIT");
+  }
+
+  if (req.method === "HEAD") {
+    res.writeHead(200);
+    res.end();
+    return;
+  }
+
+  res.writeHead(200);
+  fs.createReadStream(filePath).pipe(res);
+}
+
+function forwardDirectRequest(req, res, urlObj, timeoutMs, upstreamProxyManager = null) {
+  const client = pickClient(urlObj.protocol);
+  const headers = sanitizeHeaders(req.headers);
+  headers.host = urlObj.host;
+  const agent = upstreamProxyManager ? upstreamProxyManager.getAgentForUrl(urlObj) : undefined;
+
+  if (agent) {
+    console.log(`[proxy] direct forward via upstream host=${urlObj.hostname} protocol=${urlObj.protocol}`);
+  }
+
+  const upstreamReq = client.request(
+    {
+      protocol: urlObj.protocol,
+      hostname: urlObj.hostname,
+      port: urlObj.port || (urlObj.protocol === "https:" ? 443 : 80),
+      method: req.method,
+      path: `${urlObj.pathname}${urlObj.search}`,
+      headers,
+      agent,
+    },
+    (upstreamRes) => {
+      res.writeHead(upstreamRes.statusCode || 502, upstreamRes.headers);
+      upstreamRes.pipe(res);
+    },
+  );
+
+  upstreamReq.setTimeout(timeoutMs, () => {
+    upstreamReq.destroy(new Error(`Upstream timeout after ${timeoutMs}ms`));
+  });
+
+  upstreamReq.on("error", (error) => {
+    if (!res.headersSent) {
+      sendText(res, 502, `Proxy forward failed: ${error.message}`);
+    } else {
+      res.destroy(error);
+    }
+  });
+
+  req.pipe(upstreamReq);
+}
+
+export function createHttpRequestHandler({ config, downloader, upstreamProxyManager = null, matchesDomain }) {
+  return async function handleHttpRequestPath(req, res, forcedProtocol = null) {
+    let urlObj;
+    try {
+      urlObj = buildUrl(req, forcedProtocol);
+    } catch (error) {
+      sendText(res, 400, `Bad request: ${error.message}`);
+      return;
+    }
+
+    const method = (req.method || "GET").toUpperCase();
+    if (method !== "GET" && method !== "HEAD") {
+      forwardDirectRequest(req, res, urlObj, config.downloadTimeoutMs, upstreamProxyManager);
+      return;
+    }
+
+    let cachePath;
+    try {
+      const ecosystem = detectPackageEcosystem(urlObj, config, matchesDomain);
+      cachePath = getCacheFilePath(config.cacheDir, urlObj, {
+        ecosystem,
+        includeHost: ecosystem !== "maven",
+      });
+    } catch (error) {
+      sendText(res, 400, `Invalid cache path: ${error.message}`);
+      return;
+    }
+
+    const existing = await statIfFile(cachePath);
+    if (existing) {
+      await serveFile(res, req, cachePath);
+      return;
+    }
+
+    try {
+      await fs.promises.mkdir(path.dirname(cachePath), { recursive: true });
+      await downloader.ensureCached(urlObj, cachePath, req.headers);
+      res.setHeader("x-cache", "MISS");
+      await serveFile(res, req, cachePath);
+    } catch (error) {
+      const statusCode = error.statusCode || 502;
+      sendText(res, statusCode, `Download failed: ${error.message}`);
+    }
+  };
+}
+
+export function createMitmHttpServer(handleHttpRequestPath) {
+  const server = http.createServer((req, res) => {
+    handleHttpRequestPath(req, res, "https:").catch((error) => {
+      sendText(res, 500, `MITM request failed: ${error.message}`);
+    });
+  });
+
+  server.on("clientError", (error, socket) => {
+    socket.destroy(error);
+  });
+
+  return server;
+}

package/src/proxy/proxy-server.js

@@ -1,35 +1,35 @@
-import http from "node:http";
-import { createHttpRequestHandler, createMitmHttpServer } from "./proxy-http-handler.js";
-import { attachConnectHandler } from "./proxy-connect-handler.js";
-
-function sendText(res, statusCode, message) {
-  res.writeHead(statusCode, { "content-type": "text/plain; charset=utf-8" });
-  res.end(message);
-}
-
-export function startProxyServer(config, certManager, downloader, matchesDomain, upstreamProxyManager = null) {
-  const handleHttpRequestPath = createHttpRequestHandler({
-    config,
-    downloader,
-    upstreamProxyManager,
-    matchesDomain,
-  });
-  const mitmHttpServer = createMitmHttpServer(handleHttpRequestPath);
-
-  const server = http.createServer((req, res) => {
-    handleHttpRequestPath(req, res, null).catch((error) => {
-      sendText(res, 500, `Proxy request failed: ${error.message}`);
-    });
-  });
-
-  attachConnectHandler(server, {
-    config,
-    certManager,
-    matchesDomain,
-    upstreamProxyManager,
-    mitmHttpServer,
-  });
-
-  server.listen(config.proxyPort);
-  return { proxyServer: server, mitmHttpServer };
-}
+import http from "node:http";
+import { createHttpRequestHandler, createMitmHttpServer } from "./proxy-http-handler.js";
+import { attachConnectHandler } from "./proxy-connect-handler.js";
+
+function sendText(res, statusCode, message) {
+  res.writeHead(statusCode, { "content-type": "text/plain; charset=utf-8" });
+  res.end(message);
+}
+
+export function startProxyServer(config, certManager, downloader, matchesDomain, upstreamProxyManager = null) {
+  const handleHttpRequestPath = createHttpRequestHandler({
+    config,
+    downloader,
+    upstreamProxyManager,
+    matchesDomain,
+  });
+  const mitmHttpServer = createMitmHttpServer(handleHttpRequestPath);
+
+  const server = http.createServer((req, res) => {
+    handleHttpRequestPath(req, res, null).catch((error) => {
+      sendText(res, 500, `Proxy request failed: ${error.message}`);
+    });
+  });
+
+  attachConnectHandler(server, {
+    config,
+    certManager,
+    matchesDomain,
+    upstreamProxyManager,
+    mitmHttpServer,
+  });
+
+  server.listen(config.proxyPort);
+  return { proxyServer: server, mitmHttpServer };
+}