maven-proxy 1.0.1

package/src/common/java-home.js

@@ -0,0 +1,328 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+function runCommandCapture(command, args) {
+  const result = spawnSync(command, args, {
+    shell: false,
+    encoding: "utf8",
+  });
+
+  if (result.error || result.status !== 0) {
+    return "";
+  }
+
+  return String(result.stdout || "").trim();
+}
+
+function isFile(filePath) {
+  try {
+    return fs.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function isDirectory(dirPath) {
+  try {
+    return fs.statSync(dirPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function isLikelyJavaHome(homePath, platform) {
+  const javaName = platform === "win32" ? "java.exe" : "java";
+
+  if (!isFile(path.join(homePath, "bin", javaName))) {
+    return false;
+  }
+
+  if (isFile(path.join(homePath, "release"))) {
+    return true;
+  }
+
+  if (isFile(path.join(homePath, "lib", "security", "cacerts"))) {
+    return true;
+  }
+
+  if (isFile(path.join(homePath, "jre", "lib", "security", "cacerts"))) {
+    return true;
+  }
+
+  return false;
+}
+
+function safeRealpath(targetPath) {
+  try {
+    return fs.realpathSync(targetPath);
+  } catch {
+    return targetPath;
+  }
+}
+
+function deriveJavaHomeFromJavaBin(javaBinPath) {
+  const resolved = safeRealpath(javaBinPath);
+  const executableName = path.basename(resolved).toLowerCase();
+
+  if (executableName !== "java" && executableName !== "java.exe") {
+    return "";
+  }
+
+  const binDir = path.dirname(resolved);
+  if (path.basename(binDir).toLowerCase() !== "bin") {
+    return "";
+  }
+
+  const javaHome = path.dirname(binDir);
+  if (!isDirectory(javaHome)) {
+    return "";
+  }
+
+  const platform = os.platform();
+  return isLikelyJavaHome(javaHome, platform) ? javaHome : "";
+}
+
+function normalizeConfiguredJavaHome(configured, platform) {
+  if (!configured) {
+    return "";
+  }
+
+  const resolved = safeRealpath(configured);
+  if (isDirectory(resolved)) {
+    if (isLikelyJavaHome(resolved, platform)) {
+      return resolved;
+    }
+
+    if (path.basename(resolved).toLowerCase() === "bin") {
+      const base = path.dirname(resolved);
+      if (isLikelyJavaHome(base, platform)) {
+        return base;
+      }
+    }
+
+    return "";
+  }
+
+  if (isFile(resolved)) {
+    return deriveJavaHomeFromJavaBin(resolved);
+  }
+
+  return "";
+}
+
+function detectFromJavaCommand(platform) {
+  const command = platform === "win32" ? "where" : "which";
+  const output = runCommandCapture(command, ["java"]);
+  if (!output) {
+    return "";
+  }
+
+  const firstPath = output
+    .split(/\r?\n/g)
+    .map((line) => line.trim())
+    .find(Boolean);
+
+  if (!firstPath) {
+    return "";
+  }
+
+  return deriveJavaHomeFromJavaBin(firstPath);
+}
+
+function detectFromLinuxCommonPaths() {
+  const directCandidates = [
+    "/usr/bin/java",
+    "/usr/local/bin/java",
+  ];
+
+  for (const javaPath of directCandidates) {
+    if (!isFile(javaPath)) {
+      continue;
+    }
+
+    const home = deriveJavaHomeFromJavaBin(javaPath);
+    if (home) {
+      return home;
+    }
+  }
+
+  const roots = [
+    "/usr/lib/jvm",
+    "/usr/java",
+    "/opt/java",
+    "/opt/jdk",
+  ];
+
+  for (const root of roots) {
+    if (!isDirectory(root)) {
+      continue;
+    }
+
+    let children = [];
+    try {
+      children = fs.readdirSync(root, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .sort((a, b) => b.localeCompare(a));
+    } catch {
+      continue;
+    }
+
+    for (const child of children) {
+      const candidate = path.join(root, child);
+      if (isFile(path.join(candidate, "bin", "java"))) {
+        return candidate;
+      }
+    }
+  }
+
+  return "";
+}
+
+function detectFromMacJavaHomeCommand() {
+  const output = runCommandCapture("/usr/libexec/java_home", []);
+  if (!output) {
+    return "";
+  }
+
+  return isDirectory(output) ? output : "";
+}
+
+function detectFromWindowsCommonPaths() {
+  const roots = [
+    "C:\\Program Files\\Java",
+    "C:\\Program Files (x86)\\Java",
+    "C:\\Program Files\\Eclipse Adoptium",
+    "C:\\Program Files\\Microsoft",
+    "C:\\Program Files\\Amazon Corretto",
+    "C:\\Program Files\\Zulu",
+  ];
+
+  for (const root of roots) {
+    if (!isDirectory(root)) {
+      continue;
+    }
+
+    let children = [];
+    try {
+      children = fs.readdirSync(root, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .sort((a, b) => b.localeCompare(a));
+    } catch {
+      continue;
+    }
+
+    for (const child of children) {
+      const base = path.join(root, child);
+      const candidates = [base, path.join(base, "jre")];
+      for (const candidate of candidates) {
+        if (isFile(path.join(candidate, "bin", "java.exe"))) {
+          return candidate;
+        }
+      }
+    }
+  }
+
+  return "";
+}
+
+function detectAutoJavaHome(platform) {
+  if (platform === "darwin") {
+    const fromMacCommand = detectFromMacJavaHomeCommand();
+    if (fromMacCommand) {
+      return {
+        javaHome: fromMacCommand,
+        source: "auto-macos-java-home",
+      };
+    }
+
+    const fromCommand = detectFromJavaCommand(platform);
+    if (fromCommand) {
+      return {
+        javaHome: fromCommand,
+        source: "auto-java-command",
+      };
+    }
+
+    return { javaHome: "", source: "none" };
+  }
+
+  if (platform === "win32") {
+    const fromCommand = detectFromJavaCommand(platform);
+    if (fromCommand) {
+      return {
+        javaHome: fromCommand,
+        source: "auto-java-command",
+      };
+    }
+
+    const fromWindowsPath = detectFromWindowsCommonPaths();
+    if (fromWindowsPath) {
+      return {
+        javaHome: fromWindowsPath,
+        source: "auto-windows-common-path",
+      };
+    }
+
+    return { javaHome: "", source: "none" };
+  }
+
+  const fromCommand = detectFromJavaCommand(platform);
+  if (fromCommand) {
+    return {
+      javaHome: fromCommand,
+      source: "auto-java-command",
+    };
+  }
+
+  if (platform === "linux") {
+    const fromLinuxPath = detectFromLinuxCommonPaths();
+    if (fromLinuxPath) {
+      return {
+        javaHome: fromLinuxPath,
+        source: "auto-linux-common-path",
+      };
+    }
+  }
+
+  return { javaHome: "", source: "none" };
+}
+
+export function detectJavaHome(configuredJavaHome = "", platform = os.platform()) {
+  const configured = String(configuredJavaHome || "").trim();
+  const normalizedConfigured = normalizeConfiguredJavaHome(configured, platform);
+
+  if (normalizedConfigured) {
+    return {
+      javaHome: normalizedConfigured,
+      source: "env",
+      configuredJavaHome: configured,
+    };
+  }
+
+  const autoDetected = detectAutoJavaHome(platform);
+  if (autoDetected.javaHome) {
+    return {
+      javaHome: autoDetected.javaHome,
+      source: configured ? "auto-fallback" : autoDetected.source,
+      configuredJavaHome: configured,
+    };
+  }
+
+  if (configured) {
+    return {
+      javaHome: configured,
+      source: "env-missing",
+      configuredJavaHome: configured,
+    };
+  }
+
+  return {
+    javaHome: "",
+    source: "none",
+    configuredJavaHome: "",
+  };
+}

package/src/config/config.js

@@ -0,0 +1,213 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import dotenv from "dotenv";
+import { detectJavaHome } from "../common/java-home.js";
+
+const cwd = process.cwd();
+const userConfigDir = path.resolve(os.homedir(), "maven-proxy");
+const defaultUserConfigPath = path.join(userConfigDir, "config");
+
+function normalizeConfigMode(value) {
+  const normalized = String(value || "").trim().toLowerCase();
+
+  if (["dev", "development", "project"].includes(normalized)) {
+    return "development";
+  }
+
+  if (["user", "home", "global", "production", "prod"].includes(normalized)) {
+    return "user";
+  }
+
+  return "";
+}
+
+function isProjectWorkspace(dirPath) {
+  const packageJsonPath = path.resolve(dirPath, "package.json");
+  const entryPath = path.resolve(dirPath, "src/index.js");
+
+  if (!fs.existsSync(packageJsonPath) || !fs.existsSync(entryPath)) {
+    return false;
+  }
+
+  try {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    return packageJson?.name === "maven-proxy";
+  } catch {
+    return false;
+  }
+}
+
+function resolveConfigMode() {
+  const forced = normalizeConfigMode(process.env.MAVEN_PROXY_CONFIG_MODE);
+  if (forced) {
+    return forced;
+  }
+
+  return isProjectWorkspace(cwd) ? "development" : "user";
+}
+
+function resolveConfigFilePath(configMode) {
+  const envPath = String(process.env.MAVEN_PROXY_CONFIG_FILE || "").trim();
+  if (envPath) {
+    return path.isAbsolute(envPath) ? envPath : path.resolve(cwd, envPath);
+  }
+
+  if (configMode === "development") {
+    const devCandidates = [
+      path.resolve(cwd, ".env"),
+      path.resolve(cwd, ".evn"),
+    ];
+
+    for (const candidate of devCandidates) {
+      if (fs.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+
+    return "";
+  }
+
+  return fs.existsSync(defaultUserConfigPath) ? defaultUserConfigPath : "";
+}
+
+function loadEnvFromFile(filePath) {
+  if (filePath && fs.existsSync(filePath)) {
+    dotenv.config({ path: filePath, override: false });
+    return filePath;
+  }
+
+  return "";
+}
+
+const configMode = resolveConfigMode();
+const resolvedConfigFilePath = resolveConfigFilePath(configMode);
+const loadedConfigFile = loadEnvFromFile(resolvedConfigFilePath);
+const configBaseDir = configMode === "development"
+  ? cwd
+  : (resolvedConfigFilePath ? path.dirname(resolvedConfigFilePath) : userConfigDir);
+const javaHomeResolution = detectJavaHome(process.env.JAVA_HOME || "");
+
+function toBool(value, defaultValue) {
+  if (value == null || value === "") {
+    return defaultValue;
+  }
+  return ["1", "true", "yes", "on"].includes(String(value).toLowerCase());
+}
+
+function toInt(value, defaultValue) {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : defaultValue;
+}
+
+function toList(value, defaultValue = []) {
+  if (!value) {
+    return defaultValue;
+  }
+  return String(value)
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function normalizeRepoList(value, defaultValue = []) {
+  const raw = toList(value, defaultValue);
+  return raw
+    .map((item) => String(item).trim())
+    .filter((item) => /^https?:\/\//i.test(item))
+    .map((item) => item.replace(/\/+$/, ""));
+}
+
+function normalizeProxyUrl(value) {
+  if (!value) {
+    return "";
+  }
+
+  const trimmed = String(value).trim();
+  if (!trimmed) {
+    return "";
+  }
+
+  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(trimmed)) {
+    return trimmed;
+  }
+
+  return `http://${trimmed}`;
+}
+
+function extractHostsFromUrls(urls) {
+  const hosts = [];
+
+  for (const rawUrl of urls) {
+    try {
+      hosts.push(new URL(rawUrl).hostname.toLowerCase());
+    } catch {
+      // ignore invalid URL
+    }
+  }
+
+  return [...new Set(hosts)];
+}
+
+const defaultRepoFallbackRepos = [
+  "https://repo1.maven.org/maven2",
+  "https://jitpack.io",
+  "https://plugins.gradle.org/m2",
+  "https://maven.google.com",
+];
+
+const repoFallbackRepos = normalizeRepoList(
+  process.env.REPO_FALLBACK_REPOS,
+  defaultRepoFallbackRepos,
+);
+
+const defaultMavenRepoDomains = [
+  "repo1.maven.org",
+  "repo.maven.apache.org",
+  "jitpack.io",
+  "plugins.gradle.org",
+  "maven.google.com",
+  ...extractHostsFromUrls(repoFallbackRepos),
+];
+
+const cacheDir = path.resolve(configBaseDir, process.env.CACHE_DIR || "data/cache");
+
+export const config = {
+  configMode,
+  configBaseDir,
+  loadedConfigFile,
+  defaultUserConfigPath,
+  proxyPort: toInt(process.env.PROXY_PORT, 8080),
+  repoPort: toInt(process.env.REPO_PORT, 8081),
+  cacheDir,
+  mavenCacheDir: path.resolve(cacheDir, "maven"),
+  npmCacheDir: path.resolve(cacheDir, "npm"),
+  genericCacheDir: path.resolve(cacheDir, "generic"),
+  enableHttpsProxy: toBool(process.env.ENABLE_HTTPS_PROXY, true),
+  httpsMitmDomains: toList(process.env.HTTPS_MITM_DOMAINS, ["repo1.maven.org", "repo.maven.apache.org", "registry.npmjs.org"]),
+  npmRegistryDomains: toList(process.env.NPM_REGISTRY_DOMAINS, ["registry.npmjs.org", "registry.npmmirror.com", "npm.pkg.github.com"]),
+  mavenRepoDomains: toList(process.env.MAVEN_REPO_DOMAINS, [...new Set(defaultMavenRepoDomains)]),
+  multiThreadDomains: toList(process.env.MULTI_THREAD_DOMAINS, ["repo1.maven.org"]),
+  multiThreadCount: Math.max(1, toInt(process.env.MULTI_THREAD_COUNT, 4)),
+  multiThreadMinSizeBytes: Math.max(0, toInt(process.env.MULTI_THREAD_MIN_SIZE_BYTES, 1024 * 1024)),
+  downloadTimeoutMs: Math.max(1000, toInt(process.env.DOWNLOAD_TIMEOUT_MS, 60000)),
+  downloadLogDir: path.resolve(configBaseDir, process.env.DOWNLOAD_LOG_DIR || "data/logs/downloads"),
+  logRetentionDays: Math.max(1, toInt(process.env.LOG_RETENTION_DAYS, 7)),
+  certDir: path.resolve(configBaseDir, process.env.CERT_DIR || "data/certs"),
+  rootCertPath: path.resolve(configBaseDir, process.env.ROOT_CERT_PATH || "data/certs/root-ca.crt"),
+  rootKeyPath: path.resolve(configBaseDir, process.env.ROOT_KEY_PATH || "data/certs/root-ca.key.pem"),
+  leafCertDir: path.resolve(configBaseDir, process.env.LEAF_CERT_DIR || "data/certs/leaf"),
+  trustStorePath: path.resolve(configBaseDir, process.env.TRUST_STORE_PATH || "data/certs/proxy-truststore.jks"),
+  trustStoreAlias: process.env.TRUST_STORE_ALIAS || "maven-proxy-root-ca",
+  trustStorePassword: process.env.TRUST_STORE_PASSWORD || "changeit",
+  javaHome: javaHomeResolution.javaHome,
+  javaHomeSource: javaHomeResolution.source,
+  javaHomeConfigured: javaHomeResolution.configuredJavaHome || "",
+  httpsPassthroughForUnmatched: toBool(process.env.HTTPS_PASSTHROUGH_FOR_UNMATCHED, true),
+  upstreamProxyUrl: normalizeProxyUrl(process.env.UPSTREAM_PROXY_URL || process.env.ALL_PROXY || process.env.all_proxy || ""),
+  upstreamHttpProxyUrl: normalizeProxyUrl(process.env.UPSTREAM_HTTP_PROXY_URL || process.env.HTTP_PROXY || process.env.http_proxy || ""),
+  upstreamHttpsProxyUrl: normalizeProxyUrl(process.env.UPSTREAM_HTTPS_PROXY_URL || process.env.HTTPS_PROXY || process.env.https_proxy || ""),
+  upstreamNoProxyDomains: toList(process.env.UPSTREAM_NO_PROXY || process.env.NO_PROXY || process.env.no_proxy || ""),
+  upstreamIgnoreDomains: toList(process.env.UPSTREAM_IGNORE_DOMAINS || ""),
+  repoFallbackRepos,
+};

package/src/index.js

@@ -0,0 +1,93 @@
+import fs from "node:fs";
+import { config } from "./config/config.js";
+import { matchesDomain } from "./common/domain-match.js";
+import { CertManager } from "./cert/cert-manager.js";
+import { Downloader } from "./cache/downloader.js";
+import { startProxyServer } from "./proxy/proxy-server.js";
+import { startRepoServer } from "./repo/repo-server.js";
+import { getTrustStoreCommands } from "./cert/truststore-utils.js";
+import { UpstreamProxyManager } from "./proxy/upstream-proxy.js";
+import { installConsoleLogFileMirror, installGlobalErrorLogging } from "./common/console-log-file.js";
+
+installConsoleLogFileMirror({
+  logDir: config.downloadLogDir,
+  retentionDays: config.logRetentionDays,
+});
+installGlobalErrorLogging();
+
+async function main() {
+  await fs.promises.mkdir(config.cacheDir, { recursive: true });
+  await fs.promises.mkdir(config.mavenCacheDir, { recursive: true });
+  await fs.promises.mkdir(config.npmCacheDir, { recursive: true });
+  await fs.promises.mkdir(config.genericCacheDir, { recursive: true });
+  await fs.promises.mkdir(config.downloadLogDir, { recursive: true });
+  await fs.promises.mkdir(config.certDir, { recursive: true });
+  await fs.promises.mkdir(config.leafCertDir, { recursive: true });
+
+  const certManager = new CertManager(config);
+  await certManager.init();
+
+  for (const pattern of config.httpsMitmDomains) {
+    if (!pattern.includes("*")) {
+      await certManager.getOrCreateLeaf(pattern);
+    }
+  }
+
+  const upstreamProxyManager = new UpstreamProxyManager(config, matchesDomain);
+
+  const downloader = new Downloader(config, matchesDomain, upstreamProxyManager);
+
+  const { proxyServer, mitmHttpServer } = startProxyServer(
+    config,
+    certManager,
+    downloader,
+    matchesDomain,
+    upstreamProxyManager,
+  );
+  const repoServer = startRepoServer(config, downloader);
+
+  const trustCommands = getTrustStoreCommands(config);
+
+  console.log("[maven-proxy] started");
+  console.log(`[maven-proxy] config mode: ${config.configMode}`);
+  console.log(`[maven-proxy] config file: ${config.loadedConfigFile || "(none)"}`);
+  console.log(`[maven-proxy] config base: ${config.configBaseDir}`);
+  if (config.configMode === "user") {
+    console.log(`[maven-proxy] default user config: ${config.defaultUserConfigPath}`);
+  }
+  console.log(`[maven-proxy] proxy port: ${config.proxyPort}`);
+  console.log(`[maven-proxy] repo  port: ${config.repoPort}`);
+  console.log(`[maven-proxy] cache dir : ${config.cacheDir}`);
+  console.log(`[maven-proxy] cache maven: ${config.mavenCacheDir}`);
+  console.log(`[maven-proxy] cache npm  : ${config.npmCacheDir}`);
+  console.log(`[maven-proxy] cache other: ${config.genericCacheDir}`);
+  console.log(`[maven-proxy] download log: ${config.downloadLogDir}`);
+  console.log(`[maven-proxy] log retention days: ${config.logRetentionDays}`);
+  console.log(`[maven-proxy] root cert : ${config.rootCertPath}`);
+  console.log(`[maven-proxy] repo fallback repos: ${(config.repoFallbackRepos || []).join(",") || "(none)"}`);
+  if (config.upstreamProxyUrl || config.upstreamHttpProxyUrl || config.upstreamHttpsProxyUrl) {
+    console.log(`[maven-proxy] upstream proxy (generic): ${config.upstreamProxyUrl || "(none)"}`);
+    console.log(`[maven-proxy] upstream proxy (http)   : ${config.upstreamHttpProxyUrl || "(none)"}`);
+    console.log(`[maven-proxy] upstream proxy (https)  : ${config.upstreamHttpsProxyUrl || "(none)"}`);
+    console.log(`[maven-proxy] upstream no-proxy       : ${(config.upstreamNoProxyDomains || []).join(",") || "(none)"}`);
+    console.log(`[maven-proxy] upstream ignore-domains : ${(config.upstreamIgnoreDomains || []).join(",") || "(none)"}`);
+  }
+  console.log("[maven-proxy] trust store command (copy):");
+  console.log(trustCommands.copyCmd);
+  console.log("[maven-proxy] trust store command (import):");
+  console.log(trustCommands.importCmd);
+
+  const shutdown = () => {
+    proxyServer.close();
+    mitmHttpServer.close();
+    repoServer.close();
+  };
+
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+
+main().catch((error) => {
+  console.error("[maven-proxy] fatal error:", error);
+  process.exit(1);
+});