feat(server): 권장 JDK 목록을 Adoptium 에서 동적으로 + 자세히 보기(스냅샷)

- 하드코딩 [8,11,17,21,25] 대신 Adoptium(Temurin) API 에서 실제 배포 버전을 가져와
  편집기 드롭다운을 채운다. 브라우저 CORS 차단이라 서버가 프록시:
  GET /op/jdk-versions (메이저 목록), GET /op/jdk-versions/:major (GA/EA 릴리스명).
  6h 캐시 + 네트워크 실패 시 정적 폴백.
- 편집기: 기본은 LTS(25/21/17/11/8)만 표시, "자세히 보기" 체크 시 비-LTS 메이저까지
  펼치고 선택 메이저의 GA/EA 스냅샷 릴리스명을 함께 보여준다.
- normalizeRecommendedJdk 를 고정 목록 대신 8~99 범위로 완화(동적 메이저 허용).
- 버전 0.4.7→0.4.8.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

docs/installer.md

@@ -28,9 +28,12 @@
 
 ### 3-2. JDK 확인
 
-- 환경변수(`JAVA_HOME`, `JDK_HOME`) → 자동 설치 위치(`%APPDATA%\jdk\temurin-21`) → `C:\Program Files\Java` 순으로 자동 탐색.
-- **자동 설치** 버튼을 누르면 Adoptium Temurin 21 LTS Windows x64 zip 을 받아 `%APPDATA%\jdk\temurin-21\` 에 풀어 사용합니다.
+- 각 음악퀴즈(pack)는 사이트 편집기에서 **권장 JDK 버전**(예: Java 25)을 지정합니다. 설치기는 이 권장 버전을 기준으로 동작합니다.
+- 탐색 순서: **① 권장 JDK 자동 설치 위치(`%APPDATA%\jdk\temurin-<권장>`) 를 가장 먼저** 확인 → 없으면 **② 컴퓨터의 JDK(`JAVA_HOME` / `JDK_HOME` / `C:\Program Files\Java`)** 를 확인.
+- 최신 마인크래프트 서버는 특정 자바 버전 이상을 요구합니다(예: 서버 번들러 class file 69.0 = Java 25). 그보다 낮은 자바는 있어도 `UnsupportedClassVersionError` 로 서버가 뜨지 않으므로, 자동 탐색은 **권장 버전 미만을 "없음"으로 처리**해 자동 설치로 유도합니다. 직접 선택/입력한 경로도 "다음" 에서 버전을 검증해 미만이면 진행을 막습니다.
+- **자동 설치** 버튼을 누르면 Adoptium Temurin(권장 버전) Windows x64 zip 을 받아 `%APPDATA%\jdk\temurin-<권장>\` 에 풀어 사용합니다.
 - 설치 중 같은 버튼이 "설치 취소" 로 바뀌고, 누르면 다운로드를 즉시 중단하고 부분 파일을 정리합니다.
+- 서버 zip 의 `run.bat` 이 시스템 PATH 의 `java` 를 그대로 쓰면 낡은 자바로 실행돼 실패할 수 있어, 설치기가 준비/선택한 JDK 의 `java` 를 쓰도록 `run.bat` 을 자동으로 수정합니다(자동 설치 JDK 는 `%APPDATA%` 전개형 경로라 한글 사용자명에도 안전).
 
 ### 3-3. 서버 다운로드 및 설치
 

installer-rp/renderer.js

@@ -226,8 +226,12 @@ function renderAgreementWithKinds(KINDS) {
     // 새 약관 페이지는 화면 맨 위에서부터 보이도록 스크롤을 올린다.
     if (pageHost) pageHost.scrollTop = 0
 
+    // 약관 본문이 정상 로드된 뒤에만 동의를 허용한다. 로드 실패 상태에서는
+    // 스크롤을 해도 동의 체크가 켜지지 않는다("무조건 약관을 읽도록").
+    var termLoaded = false
+
     function markReadable() {
-      if (!accept.disabled) return
+      if (!termLoaded || !accept.disabled) return
       accept.disabled = false
       hint.textContent = ''
     }
@@ -257,6 +261,7 @@ function renderAgreementWithKinds(KINDS) {
     })
 
     function afterLoad() {
+      termLoaded = true
       body.scrollTop = 0
       if (accepted[k.id]) {
         accept.disabled = false
@@ -270,15 +275,31 @@ function renderAgreementWithKinds(KINDS) {
       }, 0)
     }
 
+    // 약관 본문 로드 실패: 동의 불가 상태를 유지하고 다시 시도만 허용한다.
+    function showLoadError(message) {
+      termLoaded = false
+      accept.disabled = true
+      accept.checked = false
+      accepted[k.id] = false
+      nextBtn.disabled = true
+      hint.textContent = tt('agreement.readToBottom')
+      body.innerHTML =
+        '<p class="formMessage error">' + escapeHtml(tt('agreement.loadFailed', { message: message || '' })) + '</p>' +
+        '<div class="actionRow" style="margin-top:10px;"><button class="secondaryBtn" id="agRetry">' + escapeHtml(tt('agreement.retry')) + '</button></div>'
+      var retry = section.querySelector('#agRetry')
+      if (retry) retry.addEventListener('click', loadTerm)
+    }
+
+    function loadTerm() {
       if (cache[k.id]) {
         body.innerHTML = cache[k.id]
         afterLoad()
-    } else {
+        return
+      }
       body.textContent = tt('agreement.loading')
       api.getTerm(k.id).then(function (res) {
         if (!res.ok) {
-          body.innerHTML = '<p class="formMessage error">' + escapeHtml(tt('agreement.loadFailed', { message: res.message || '' })) + '</p>'
-          markReadable()
+          showLoadError(res.message || '')
           return
         }
         var html = renderTermsMarkdown(res.content || '')
@@ -286,10 +307,11 @@ function renderAgreementWithKinds(KINDS) {
         body.innerHTML = html
         afterLoad()
       }).catch(function (err) {
-        body.innerHTML = '<p class="formMessage error">' + escapeHtml(tt('agreement.loadFailed', { message: err.message })) + '</p>'
-        markReadable()
+        showLoadError(err && err.message ? err.message : '')
       })
     }
+
+    loadTerm()
   }
 
   renderCurrent()

installer/renderer.js

@@ -266,8 +266,12 @@ function renderAgreementWithKinds(KINDS) {
     // 새 약관 페이지는 화면 맨 위에서부터 보이도록 스크롤을 올린다.
     if (pageHost) pageHost.scrollTop = 0
 
+    // 약관 본문이 정상 로드된 뒤에만 동의를 허용한다. 로드 실패 상태에서는
+    // 스크롤을 해도 동의 체크가 켜지지 않는다("무조건 약관을 읽도록").
+    var termLoaded = false
+
     function markReadable() {
-      if (!accept.disabled) return
+      if (!termLoaded || !accept.disabled) return
       accept.disabled = false
       hint.textContent = ''
     }
@@ -298,6 +302,7 @@ function renderAgreementWithKinds(KINDS) {
     })
 
     function afterLoad() {
+      termLoaded = true
       body.scrollTop = 0
       // 이미 동의했던 약관으로 되돌아온 경우: 체크/다음 활성화 유지.
       if (accepted[k.id]) {
@@ -313,15 +318,31 @@ function renderAgreementWithKinds(KINDS) {
       }, 0)
     }
 
+    // 약관 본문 로드 실패: 동의 불가 상태를 유지하고 다시 시도만 허용한다.
+    function showLoadError(message) {
+      termLoaded = false
+      accept.disabled = true
+      accept.checked = false
+      accepted[k.id] = false
+      nextBtn.disabled = true
+      hint.textContent = tt('agreement.readToBottom')
+      body.innerHTML =
+        '<p class="formMessage error">' + tt('agreement.loadFailed', { message: message || '' }) + '</p>' +
+        '<div class="actionRow" style="margin-top:10px;"><button class="secondaryBtn" id="agRetry">' + tt('agreement.retry') + '</button></div>'
+      var retry = section.querySelector('#agRetry')
+      if (retry) retry.addEventListener('click', loadTerm)
+    }
+
+    function loadTerm() {
       if (cache[k.id]) {
         body.innerHTML = cache[k.id]
         afterLoad()
-    } else {
+        return
+      }
       body.textContent = tt('agreement.loading')
       installerApi.getTerm(k.id).then(function (res) {
         if (!res.ok) {
-          body.innerHTML = '<p class="formMessage error">' + tt('agreement.loadFailed', { message: res.message || '' }) + '</p>'
-          markReadable()
+          showLoadError(res.message || '')
           return
         }
         var html = renderTermsMarkdown(res.content || '')
@@ -329,10 +350,11 @@ function renderAgreementWithKinds(KINDS) {
         body.innerHTML = html
         afterLoad()
       }).catch(function (err) {
-        body.innerHTML = '<p class="formMessage error">' + tt('agreement.loadFailed', { message: err.message }) + '</p>'
-        markReadable()
+        showLoadError(err && err.message ? err.message : '')
       })
     }
+
+    loadTerm()
   }
 
   renderCurrent()
@@ -571,10 +593,17 @@ function renderSubStep31(host, back, done) {
 }
 
 function renderSubStep32(host, back, done) {
+  // 선택한 음악퀴즈(pack)의 권장 JDK. 설치기는 이 버전을 우선 찾고/설치한다.
+  var selPack = (state.packs && state.packs.find)
+    ? state.packs.find(function (p) { return p.key === state.selectedPackKey })
+    : null
+  var recommendedJdk = (selPack && selPack.pack && selPack.pack.recommendedJdk) ? selPack.pack.recommendedJdk : 25
+
   host.innerHTML =
     '<h3>' + tt('step3.sub32.heading') + '</h3>' +
     '<p class="formMessage">' + tt('step3.sub32.description') + '</p>' +
-    '<div class="fieldset"><label><input id="jdkPath" type="text" placeholder="C:\\Program Files\\Java\\jdk-17" value="' + (state.serverInstall.jdk || '') + '" /></label>' +
+    '<p class="formMessage"><strong>' + tt('step3.sub32.recommended', { major: recommendedJdk }) + '</strong></p>' +
+    '<div class="fieldset"><label><input id="jdkPath" type="text" placeholder="C:\\Program Files\\Java\\jdk-' + recommendedJdk + '" value="' + (state.serverInstall.jdk || '') + '" /></label>' +
     '<button class="secondaryBtn" id="pickJdk">' + tt('step3.sub32.pickFolder') + '</button>' +
     '<button class="secondaryBtn" id="auto">' + tt('step3.sub32.auto') + '</button>' +
     '<button class="secondaryBtn" id="install">' + tt('step3.sub32.install') + '</button></div>' +
@@ -611,14 +640,20 @@ function renderSubStep32(host, back, done) {
 
   autoBtn.addEventListener('click', async function () {
     if (installing) return
-    var detect = await installerApi.detectJdk()
-    if (detect.found) {
+    var detect = await installerApi.detectJdk(recommendedJdk)
+    if (detect.found && detect.match) {
       input.value = detect.path
-      msg.textContent = tt('step3.sub32.found', { path: detect.path })
+      msg.textContent = tt('step3.sub32.foundRecommended', { path: detect.path, major: recommendedJdk })
       msg.classList.remove('error')
       msg.classList.add('success')
+    } else if (detect.found) {
+      // 권장 버전이 아닌 다른 JDK 를 찾음 → 경고와 함께 채워 넣는다.
+      input.value = detect.path
+      msg.textContent = tt('step3.sub32.foundMismatch', { path: detect.path, major: detect.major, required: recommendedJdk })
+      msg.classList.remove('success')
+      msg.classList.add('error')
     } else {
-      msg.textContent = tt('step3.sub32.notFound')
+      msg.textContent = tt('step3.sub32.notFound', { major: recommendedJdk })
       msg.classList.remove('success')
       msg.classList.add('error')
     }
@@ -640,7 +675,7 @@ function renderSubStep32(host, back, done) {
     msg.classList.remove('success', 'error')
     msg.textContent = tt('step3.sub32.downloading')
     try {
-      var result = await installerApi.installJdk()
+      var result = await installerApi.installJdk(recommendedJdk)
       if (result.ok && result.path) {
         input.value = result.path
         state.serverInstall.jdk = result.path
@@ -664,24 +699,62 @@ function renderSubStep32(host, back, done) {
     if (installing) return
     back()
   })
-  nextBtn.addEventListener('click', function () {
+  nextBtn.addEventListener('click', async function () {
     if (installing) return
-    if (!input.value.trim()) {
+    var val = input.value.trim()
+    if (!val) {
       msg.textContent = tt('step3.sub32.pathRequired')
       msg.classList.add('error')
       return
     }
-    state.serverInstall.jdk = input.value.trim()
+    // 직접 입력/선택한 JDK 를 확인한다. 자바를 못 읽으면 진행을 막고, 권장과 다른
+    // 버전이면 "정상 실행이 안 될 수 있다"는 경고를 띄운 뒤 사용자가 동의하면 진행한다.
+    nextBtn.disabled = true
+    msg.classList.remove('success', 'error')
+    msg.textContent = tt('step3.sub32.verifying')
+    var required = recommendedJdk
+    try {
+      var v = await installerApi.verifyJdk(val, recommendedJdk)
+      required = (v && v.required) || recommendedJdk
+      if (!v || !v.major) {
+        msg.classList.add('error')
+        msg.textContent = tt('step3.sub32.versionUnknown')
+        nextBtn.disabled = false
+        return
+      }
+      if (!v.match) {
+        // 권장 버전과 다름 → 경고 후 동의 시에만 계속.
+        var proceed = window.confirm(tt('step3.sub32.mismatchConfirm', { major: v.major, required: required }))
+        if (!proceed) {
+          msg.classList.add('error')
+          msg.textContent = tt('step3.sub32.foundMismatch', { path: val, major: v.major, required: required })
+          nextBtn.disabled = false
+          return
+        }
+      }
+    } catch (err) {
+      msg.classList.add('error')
+      msg.textContent = tt('step3.sub32.versionUnknown')
+      nextBtn.disabled = false
+      return
+    }
+    nextBtn.disabled = false
+    state.serverInstall.jdk = val
     done()
   })
   ;(async function () {
-    var detect = await installerApi.detectJdk()
+    var detect = await installerApi.detectJdk(recommendedJdk)
     if (detect.found && !input.value) {
       input.value = detect.path
-      msg.textContent = tt('step3.sub32.autoDetected', { path: detect.path })
+      if (detect.match) {
+        msg.textContent = tt('step3.sub32.foundRecommended', { path: detect.path, major: recommendedJdk })
         msg.classList.add('success')
+      } else {
+        msg.textContent = tt('step3.sub32.foundMismatch', { path: detect.path, major: detect.major, required: recommendedJdk })
+        msg.classList.add('error')
+      }
     } else if (!detect.found) {
-      msg.textContent = tt('step3.sub32.notFoundHint')
+      msg.textContent = tt('step3.sub32.notFoundHint', { major: recommendedJdk })
     }
   })()
 }

locales/installer-rp/ko-kr.json

@@ -100,6 +100,8 @@
     "imageDownloading": "{{idx}}번 사진 다운로드 중…",
     "imageDone": "{{idx}}번 사진 완료: {{name}}",
     "imageSkip": "{{idx}}번 사진은 이전에 받아둠 → 건너뜀(이어받기)",
+    "imageCooldown": "음악 다운로드 직후라 유튜브 속도제한을 피하려고 {{secs}}초 대기합니다…",
+    "imageRetry": "{{idx}}번 사진 재시도 {{attempt}}회차 (HTTP {{code}}) — {{secs}}초 후 다시 시도",
     "baseDownload": "베이스 리소스팩 다운로드: {{path}}",
     "baseUrl": "  URL: {{url}}",
     "baseReceived": "베이스 리소스팩 받음 ({{kb}} KB)",
@@ -133,7 +135,8 @@
     "baseDownloading": "베이스 리소스팩 다운로드 중",
     "buildingWithBase": "베이스에 음악·사진 추가 중",
     "buildingZip": "zip 빌드 중",
-    "installComplete": "설치 완료"
+    "installComplete": "설치 완료",
+    "imageRetry": "속도제한(HTTP {{code}}) — {{secs}}초 후 재시도"
   },
   "pack": {
     "description": "음악퀴즈 리소스팩 - {{name}}"
@@ -145,6 +148,7 @@
     "cancelledByUser": "사용자가 설치를 취소했습니다.",
     "musicDownloadFailed": "{{idx}}번 노래 다운로드 실패: {{message}}",
     "imageDownloadFailed": "{{idx}}번 사진 다운로드 실패: {{message}}",
+    "imageRateLimitHint": "유튜브가 IP를 잠시 속도제한(429)했습니다. 몇 분 뒤 다시 설치를 시도하면 이미 받은 사진은 건너뛰고 이어받습니다.",
     "imageNormalizeFailed": "{{idx}}번 사진 정규화 실패: {{message}}",
     "baseDownloadFailed": "베이스 리소스팩 다운로드 실패: {{message}}",
     "ytdlpSignal": "yt-dlp 가 신호 {{signal}} 로 종료됨",

locales/installer/ko-kr.json

@@ -90,17 +90,24 @@
       "auto": "자동 탐색",
       "install": "자동 설치",
       "installCancel": "설치 취소",
+      "recommended": "권장 JDK: Java {{major}} (이 음악퀴즈 서버 실행용)",
       "found": "JDK 발견: {{path}}",
+      "foundRecommended": "권장 JDK(Java {{major}}) 발견: {{path}}",
+      "foundMismatch": "⚠ 권장(Java {{required}})이 아닌 Java {{major}} 를 찾았습니다: {{path}} — 권장 버전과 달라 서버가 정상 실행되지 않을 수 있습니다. 권장 버전을 쓰려면 \"자동 설치\" 를 누르세요.",
+      "mismatchConfirm": "선택한 Java {{major}} 는 권장 버전(Java {{required}})과 다릅니다. 권장 버전과 달라 서버가 정상 실행되지 않을 수 있습니다. 이대로 계속하시겠습니까?",
       "autoDetected": "JDK 자동 탐색됨: {{path}}",
-      "notFound": "JDK를 자동으로 찾지 못했습니다. \"자동 설치\" 를 눌러 JDK를 설치하거나 직접 선택해 주세요.",
-      "notFoundHint": "JDK를 자동으로 찾지 못했습니다. \"자동 설치\" 를 누르면 JDK를 받아 설치합니다.",
+      "notFound": "서버 실행에 필요한 Java {{major}} 이상을 찾지 못했습니다(낮은 버전이 설치돼 있어도 서버가 뜨지 않습니다). \"자동 설치\" 를 눌러 설치하거나 직접 선택해 주세요.",
+      "notFoundHint": "Java {{major}} 이상을 찾지 못했습니다. \"자동 설치\" 를 누르면 Temurin {{major}} 를 받아 설치합니다.",
       "cancelRequested": "JDK 설치 취소 요청 중...",
       "downloading": "JDK 다운로드 중...",
       "installComplete": "JDK 자동 설치 완료: {{path}}",
       "installCanceled": "JDK 설치 취소됨",
       "installFailed": "JDK 설치 실패: {{message}}",
       "installError": "JDK 설치 오류: {{message}}",
-      "pathRequired": "JDK 경로를 입력해 주세요."
+      "pathRequired": "JDK 경로를 입력해 주세요.",
+      "verifying": "선택한 JDK 버전을 확인하는 중…",
+      "versionTooLow": "선택한 Java {{major}} 는 너무 낮습니다. 서버 실행에는 Java {{required}} 이상이 필요합니다. \"자동 설치\" 로 Temurin {{required}} 를 받거나 Java {{required}} 이상 폴더를 선택해 주세요.",
+      "versionUnknown": "선택한 경로에서 Java 실행 파일을 찾지 못했거나 버전을 확인할 수 없습니다. JDK 폴더(bin\\java.exe 가 있는 곳)를 선택하거나 \"자동 설치\" 를 눌러 주세요."
     },
     "sub33": {
       "heading": "서버 다운로드 및 설치",
@@ -201,7 +208,7 @@
     "packLoadFail": "pack 로드 실패 ({{file}}): {{message}}",
     "packsLoaded": "로드된 음악퀴즈: {{count}}개",
     "selectedPack": "선택: {{key}}",
-    "jdkInstallStart": "JDK(Temurin 21) 자동 설치 시작 — 다운로드 중...",
+    "jdkInstallStart": "JDK(Temurin {{major}}) 자동 설치 시작 — 다운로드 중...",
     "jdkDownloadProgress": "JDK 다운로드: {{percent}}% ({{loaded}}MB / {{total}}MB)",
     "jdkExtracting": "JDK 압축 해제 중...",
     "jdkDoneRoot": "JDK 자동 설치 완료: {{path}}",
@@ -224,6 +231,8 @@
     "skipResourcepack": "resourcepackPath가 비어 있어 리소스팩 다운로드를 건너뜁니다.",
     "resourcepackDownload": "리소스팩 다운로드: {{url}}",
     "serverInstallPath": "서버 설치 경로: {{path}}",
+    "runBatJavaPatched": "run.bat 이 설치기가 준비한 자바를 쓰도록 수정했습니다: {{java}}",
+    "runBatJavaSkip": "설치기가 준비한 JDK 를 찾지 못해 run.bat 의 자바 경로는 그대로 둡니다(시스템 자바 사용).",
     "mojangEulaFetchFail": "Minecraft EULA 페이지 조회 실패: {{message}}",
     "eulaAccepted": "EULA 동의 저장 완료.",
     "configEditorOpen": "서버 설정 편집기 실행: {{url}}",

locales/server/ko-kr.json

@@ -125,6 +125,13 @@
     "serverMaxRam": "서버 최대 램 (MB)",
     "clientMinRam": "클라이언트 최소 램 (MB)",
     "clientRecommendedRam": "클라이언트 권장 램 (MB)",
+    "recommendedJdk": "권장 JDK (서버 실행용)",
+    "recommendedJdkHint": "설치기가 이 버전을 우선 찾고, 없으면 자동 설치합니다. 서버가 요구하는 자바 버전에 맞춰 고르세요(최신 마인크래프트는 보통 Java 25). 목록은 Adoptium(Temurin)에서 실제 배포되는 버전을 불러옵니다.",
+    "jdkShowDetails": "자세히 보기 (모든 버전·스냅샷)",
+    "jdkDetailsGa": "정식(GA)",
+    "jdkDetailsEa": "개발 스냅샷(EA)",
+    "jdkDetailsNone": "상세 버전 정보를 불러오지 못했습니다.",
+    "jdkLtsSuffix": " (LTS)",
     "mapPath": "맵 파일 (.zip)",
     "mapPathHint": "/file/maps/ 아래 zip 파일 이름.",
     "serverPath": "서버 파일 (.zip)",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "minecraft-music-quiz-installer",
-  "version": "0.4.1",
+  "version": "0.4.8",
   "description": "마인크래프트 음악퀴즈 간편설치기 + 관리 사이트",
   "main": "dist/installer/main.js",
   "scripts": {

src/installer-rp/images.ts

@@ -35,10 +35,16 @@ export function ytIdFromUrl(url: string): string {
  * 5xx 게이트웨이 계열도 잠깐 뒤 다시 받으면 성공하는 경우가 많다.
  */
 const TRANSIENT_CODES = new Set([408, 425, 429, 500, 502, 503, 504])
-const MAX_RETRIES = 5
+const MAX_RETRIES = 6
 /** 백오프 상한(ms). Retry-After 헤더가 비정상적으로 커도 이 이상은 기다리지 않는다. */
 const MAX_BACKOFF_MS = 60000
 
+/**
+ * 재시도가 일어날 때 호출되는 훅. 상위(main)에서 로그/진행률로 표시해, 429 백오프
+ * 대기 중에도 화면이 멈춘 것처럼 보이지 않게 한다.
+ */
+export type ImageRetryHook = (info: { attempt: number; delayMs: number; code: number | null }) => void
+
 /** Retry-After 헤더(초 또는 HTTP-date) → 대기 ms. 못 읽으면 null. */
 function parseRetryAfter(h: string | string[] | undefined): number | null {
   if (!h) return null
@@ -57,7 +63,7 @@ const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms
  * 429/5xx 등 일시적 오류는 지수 백오프(+jitter, Retry-After 우선)로 최대
  * MAX_RETRIES 회 재시도한다. 그 외 4xx 나 재시도 소진 시 reject.
  */
-function fetchBuffer(url: string, redirects = 0, attempt = 0): Promise<Buffer> {
+function fetchBuffer(url: string, redirects = 0, attempt = 0, onRetry?: ImageRetryHook): Promise<Buffer> {
   return new Promise((resolve, reject) => {
     if (redirects > 8) {
       reject(new Error(t('common.tooManyRedirects')))
@@ -65,10 +71,11 @@ function fetchBuffer(url: string, redirects = 0, attempt = 0): Promise<Buffer> {
     }
     const target = new URL(url)
     const lib = target.protocol === 'https:' ? https : http
-    const retryLater = (headerDelay: number | null): void => {
+    const retryLater = (headerDelay: number | null, code: number | null): void => {
       const backoff = Math.min(MAX_BACKOFF_MS, 1000 * 2 ** attempt) + Math.floor(Math.random() * 500)
       const delay = headerDelay ?? backoff
-      sleep(delay).then(() => fetchBuffer(url, redirects, attempt + 1).then(resolve, reject))
+      try { onRetry?.({ attempt: attempt + 1, delayMs: delay, code }) } catch { /* noop */ }
+      sleep(delay).then(() => fetchBuffer(url, redirects, attempt + 1, onRetry).then(resolve, reject))
     }
     const req = lib.get(target, {
       timeout: 30000,
@@ -77,13 +84,13 @@ function fetchBuffer(url: string, redirects = 0, attempt = 0): Promise<Buffer> {
       const code = res.statusCode || 0
       if (code >= 300 && code < 400 && res.headers.location) {
         res.resume()
-        fetchBuffer(new URL(res.headers.location, target).toString(), redirects + 1, attempt)
+        fetchBuffer(new URL(res.headers.location, target).toString(), redirects + 1, attempt, onRetry)
           .then(resolve, reject)
         return
       }
       if (TRANSIENT_CODES.has(code) && attempt < MAX_RETRIES) {
         res.resume()
-        retryLater(parseRetryAfter(res.headers['retry-after']))
+        retryLater(parseRetryAfter(res.headers['retry-after']), code)
         return
       }
       if (code !== 200) {
@@ -98,7 +105,7 @@ function fetchBuffer(url: string, redirects = 0, attempt = 0): Promise<Buffer> {
     req.on('error', (err) => {
       // 연결 끊김/리셋 등 네트워크 오류도 몇 번은 재시도.
       if (attempt < MAX_RETRIES) {
-        retryLater(null)
+        retryLater(null, null)
         return
       }
       reject(err)
@@ -134,18 +141,18 @@ function decodeDataUrl(url: string): Buffer | null {
  *   실패하면 `hqdefault.jpg` 로 폴백.
  * - 그 외 URL 은 HTTP GET 으로 그대로 받음.
  */
-export async function downloadImage(rawUrl: string): Promise<Buffer> {
+export async function downloadImage(rawUrl: string, onRetry?: ImageRetryHook): Promise<Buffer> {
   const dataBuf = decodeDataUrl(rawUrl)
   if (dataBuf) return dataBuf
   const ytId = ytIdFromUrl(rawUrl)
   if (ytId) {
     try {
-      return await fetchBuffer(`https://i.ytimg.com/vi/${ytId}/maxresdefault.jpg`)
+      return await fetchBuffer(`https://i.ytimg.com/vi/${ytId}/maxresdefault.jpg`, 0, 0, onRetry)
     } catch {
-      return await fetchBuffer(`https://i.ytimg.com/vi/${ytId}/hqdefault.jpg`)
+      return await fetchBuffer(`https://i.ytimg.com/vi/${ytId}/hqdefault.jpg`, 0, 0, onRetry)
     }
   }
-  return fetchBuffer(rawUrl)
+  return fetchBuffer(rawUrl, 0, 0, onRetry)
 }
 
 /**

src/installer-rp/main.ts

@@ -77,6 +77,13 @@ function pickMusicConcurrency(): number {
  */
 const MUSIC_START_STAGGER_MS = 2000
 
+/** 사진(썸네일) 다운로드 사이 최소 간격(ms). i.ytimg.com 429(rate limit) 를 유발하지 않도록 순차 요청을 살짝 벌린다. */
+const IMAGE_REQUEST_INTERVAL_MS = 800
+/** 음악(yt-dlp) 단계 직후엔 유튜브가 IP 를 일시 throttle 할 수 있어, 사진 단계 전 잠깐 쉬어 429 를 피한다. */
+const IMAGE_PHASE_COOLDOWN_MS = 4000
+
+const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms))
+
 /** start-gate. 여러 worker 가 동시에 acquire 해도 직렬화되어 순차 통과. */
 let musicStartChain: Promise<void> = Promise.resolve()
 let nextMusicStartAt = 0
@@ -503,6 +510,13 @@ ipcMain.handle('rp:install:start', async (): Promise<{ resourcepackPath: string
     const paintingDir = path.join(tempRoot, 'painting')
     await fsp.mkdir(paintingDir, { recursive: true })
     sendLog(t('log.imageStart', { total: imageTotal }))
+    // 음악(yt-dlp) 단계에서 유튜브를 많이 두드렸다면 IP throttle 이 남아 사진 첫 장부터
+    // 429 가 날 수 있다. 다운로드할 사진이 실제로 있고 직전에 음악을 받았다면 잠깐 쉰다.
+    if (imageTotal > 0 && musicTotal > 0) {
+      sendLog(t('log.imageCooldown', { secs: Math.round(IMAGE_PHASE_COOLDOWN_MS / 1000) }))
+      await sleep(IMAGE_PHASE_COOLDOWN_MS)
+    }
+    let imageRequests = 0
     for (let i = 0; i < imageTotal; i++) {
       throwIfCancelled()
       const entry = pack.list.images[i]
@@ -514,16 +528,30 @@ ipcMain.handle('rp:install:start', async (): Promise<{ resourcepackPath: string
         sendProgress({ phase: 'item', kind: 'image', index: idx, total: imageTotal, percent: 100, status: 'done' })
         continue
       }
+      // 실제 네트워크 요청을 하는 사진들 사이에만 간격을 둔다(건너뛴 것 사이엔 대기 없음).
+      if (imageRequests > 0) await sleep(IMAGE_REQUEST_INTERVAL_MS + Math.floor(Math.random() * 300))
+      imageRequests++
       sendLog(t('log.imageDownloading', { idx }))
       sendProgress({ phase: 'item', kind: 'image', index: idx, total: imageTotal, percent: 10, status: 'running' })
       let buf: Buffer
       try {
-        buf = await downloadImage(entry.url)
+        buf = await downloadImage(entry.url, (info) => {
+          const secs = Math.ceil(info.delayMs / 1000)
+          sendLog(t('log.imageRetry', { idx, attempt: info.attempt, code: info.code ?? '-', secs }))
+          sendProgress({
+            phase: 'item', kind: 'image', index: idx, total: imageTotal, percent: 10, status: 'running',
+            message: t('progress.imageRetry', { code: info.code ?? '-', secs })
+          })
+        })
       } catch (err) {
         // 부분 생성됐을 수 있는 커버 파일 제거(이어받기 시 완성본 오인 방지).
         await fsp.rm(coverPath, { force: true }).catch(() => {})
-        sendProgress({ phase: 'item', kind: 'image', index: idx, total: imageTotal, percent: 0, status: 'error', message: (err as Error).message })
-        throw new Error(t('errors.imageDownloadFailed', { idx, message: (err as Error).message }))
+        const rawMsg = (err as Error).message
+        // 429(rate limit)는 유튜브가 IP 를 일시 차단한 것. 잠시 뒤 다시 시도하면
+        // 이미 받은 사진은 건너뛰고 이어받는다는 안내를 덧붙인다.
+        const msg = /429/.test(rawMsg) ? `${rawMsg} — ${t('errors.imageRateLimitHint')}` : rawMsg
+        sendProgress({ phase: 'item', kind: 'image', index: idx, total: imageTotal, percent: 0, status: 'error', message: msg })
+        throw new Error(t('errors.imageDownloadFailed', { idx, message: msg }))
       }
       throwIfCancelled()
       sendProgress({ phase: 'item', kind: 'image', index: idx, total: imageTotal, percent: 60, status: 'running' })

src/installer/main.ts

@@ -6,7 +6,7 @@ import os from 'node:os'
 import path from 'node:path'
 import fs from 'node:fs'
 import fsp from 'node:fs/promises'
-import { spawn } from 'node:child_process'
+import { spawn, spawnSync } from 'node:child_process'
 import { URL } from 'node:url'
 import natUpnp from 'nat-upnp'
 // extract-zip은 CommonJS 기본 export.
@@ -19,7 +19,7 @@ import type {
   ServerInstallPayload
 } from './types.js'
 import type { Manifest, PackDefinition } from '../shared/types.js'
-import { normalizePackDefinition } from '../shared/store.js'
+import { normalizePackDefinition, normalizeRecommendedJdk } from '../shared/store.js'
 import { getMcCustomDirName, withCustomDirName } from '../shared/paths.js'
 import { loadEnv, getManifestUrl } from '../shared/env.js'
 import { loadComponentI18n } from '../shared/i18n.js'
@@ -252,43 +252,140 @@ ipcMain.handle('install:validatePath', async (_event, target: string) => {
   return { ok: true, message: absolute }
 })
 
-ipcMain.handle('jdk:detect', async () => {
-  const candidates: string[] = []
-  if (process.env.JAVA_HOME) candidates.push(process.env.JAVA_HOME)
-  if (process.env.JDK_HOME) candidates.push(process.env.JDK_HOME)
-  // 자동 설치 위치(우리 설치기가 만든 JDK)도 후보에 포함.
-  candidates.push(path.join(getAppDataDir(), 'jdk', 'temurin-21'))
-  candidates.push('C:\\Program Files\\Java')
+// 권장 JDK 메이저는 사이트의 pack.recommendedJdk 로 결정된다(미지정/이상값은 기본값 25).
+// 최신 마인크래프트 서버 jar 이 "class file version 69.0"(=Java 25)처럼 특정 자바 버전을
+// 요구하며, 그보다 낮은 자바로 실행하면 UnsupportedClassVersionError 로 서버가 뜨지 않는다.
+/** 자동 설치 폴더 이름(예: temurin-25). */
+function jdkDirName(major: number): string {
+  return `temurin-${major}`
+}
 
-  for (const candidate of candidates) {
-    if (!candidate) continue
+/**
+ * java 실행 파일의 메이저 버전을 조회한다(`java -version` 은 stderr 로 출력).
+ *   'openjdk version "25.0.3"' → 25,  '"1.8.0_xx"' → 8.
+ * 실행 실패/파싱 실패 시 0.
+ */
+function getJavaMajor(javaExe: string): number {
   try {
-      const stat = await fsp.stat(candidate)
-      if (stat.isFile()) {
-        return { found: true, path: candidate }
-      }
-      if (stat.isDirectory()) {
-        const javaExe = path.join(candidate, 'bin', process.platform === 'win32' ? 'java.exe' : 'java')
-        if (fs.existsSync(javaExe)) {
-          return { found: true, path: candidate }
-        }
-        const entries = await fsp.readdir(candidate)
-        for (const entry of entries) {
-          const child = path.join(candidate, entry)
-          const childJava = path.join(child, 'bin', process.platform === 'win32' ? 'java.exe' : 'java')
-          if (fs.existsSync(childJava)) {
-            return { found: true, path: child }
+    const res = spawnSync(javaExe, ['-version'], { encoding: 'utf8', timeout: 8000 })
+    const out = `${res.stdout || ''}${res.stderr || ''}`
+    const m = out.match(/version\s+"(\d+)(?:\.(\d+))?/i)
+    if (!m) return 0
+    let major = parseInt(m[1], 10)
+    if (major === 1 && m[2]) major = parseInt(m[2], 10) // 1.8 → 8
+    return Number.isNaN(major) ? 0 : major
+  } catch {
+    return 0
   }
 }
+
+/** 후보 JDK 홈에서 java 실행 파일 경로를 찾는다(홈 직하 또는 한 단계 감싼 jdk-* 하위까지). */
+function findJavaExeInHome(candidate: string): string {
+  const javaName = process.platform === 'win32' ? 'java.exe' : 'java'
+  try {
+    const stat = fs.statSync(candidate)
+    if (stat.isFile()) return candidate
+    const direct = path.join(candidate, 'bin', javaName)
+    if (fs.existsSync(direct)) return direct
+    for (const entry of fs.readdirSync(candidate)) {
+      const childJava = path.join(candidate, entry, 'bin', javaName)
+      if (fs.existsSync(childJava)) return childJava
     }
   } catch {
-      continue
+    return ''
   }
+  return ''
 }
-  return { found: false, path: '' }
+
+/** %appdata%/<.mc_custom>. 자동 설치 JDK 는 이 폴더 아래 jdk/ 에 둔다. */
+function customRootDir(): string {
+  return path.join(getAppDataDir(), getMcCustomDirName())
+}
+
+/** 설치기 자동 설치 JDK 의 루트(.mc_custom/jdk). */
+function installerJdkRoot(): string {
+  return path.join(customRootDir(), 'jdk')
+}
+
+/** dir(또는 그 한 단계 하위 jdk-* 폴더)에서 java 를 찾아 실제 JDK 홈(<home>/bin/java)을 돌려준다. 없으면 ''. */
+function resolveJdkHome(dir: string): string {
+  const javaExe = findJavaExeInHome(dir)
+  if (!javaExe) return ''
+  // findJavaExeInHome 은 항상 <home>/bin/java(.exe) 를 돌려준다 → 상위 두 단계가 홈.
+  return path.basename(path.dirname(javaExe)) === 'bin' ? path.dirname(path.dirname(javaExe)) : dir
+}
+
+/**
+ * parent 아래에서 JDK 홈들을 모두 찾는다. parent 자신, 그리고 각 하위 폴더를 검사하되,
+ * Adoptium zip 처럼 한 단계 더 감싼 `jdk-*` 하위까지 resolveJdkHome 으로 풀어낸다.
+ * (예: .mc_custom/jdk/temurin-25/jdk-25.0.3+9/bin/java.exe)
+ */
+function jdkHomesUnder(parent: string): string[] {
+  const out: string[] = []
+  const add = (h: string): void => { if (h) out.push(h) }
+  add(resolveJdkHome(parent))
+  try {
+    for (const entry of fs.readdirSync(parent)) {
+      add(resolveJdkHome(path.join(parent, entry)))
+    }
+  } catch {
+    /* 폴더 없음 등 무시 */
+  }
+  return out
+}
+
+/**
+ * 컴퓨터에 설치된 JDK 홈 목록을 우선순위대로 모은다(중복 제거).
+ * 순서: ① 기본 자바 설치 위치 C:\Program Files\Java → ② 환경변수(JAVA_HOME/JDK_HOME)
+ *       → ③ 설치기 자동 설치 위치(.mc_custom/jdk, 구버전 %APPDATA%/jdk 호환).
+ */
+function collectJdkHomes(): string[] {
+  const homes: string[] = []
+  const push = (h: string): void => {
+    if (h && !homes.some((x) => x.toLowerCase() === h.toLowerCase())) homes.push(h)
+  }
+  for (const h of jdkHomesUnder('C:\\Program Files\\Java')) push(h)
+  for (const env of [process.env.JAVA_HOME, process.env.JDK_HOME]) {
+    if (env) push(resolveJdkHome(env))
+  }
+  for (const base of [installerJdkRoot(), path.join(getAppDataDir(), 'jdk')]) {
+    for (const h of jdkHomesUnder(base)) push(h)
+  }
+  return homes
+}
+
+// 권장 JDK 를 우선 찾는다. C:\Program Files\Java → 환경변수 → 설치기 자동설치 위치를
+// 훑어, ① 권장 버전과 정확히 일치하는 JDK 가 있으면 그걸 쓰고(match=true),
+// ② 없으면 가장 높은 버전을 대신 고르되 "권장과 다름"(match=false)으로 표시해 렌더러가
+//    경고를 띄우게 한다. ③ 아무 JDK 도 없으면 not found → 자동 설치 유도.
+ipcMain.handle('jdk:detect', async (_event, recommendedInput?: number) => {
+  const required = normalizeRecommendedJdk(recommendedInput)
+  const javaName = process.platform === 'win32' ? 'java.exe' : 'java'
+  const found = collectJdkHomes()
+    .map((home) => ({ home, major: getJavaMajor(path.join(home, 'bin', javaName)) }))
+    .filter((x) => x.major > 0)
+
+  const exact = found.find((x) => x.major === required)
+  if (exact) return { found: true, path: exact.home, major: required, match: true }
+  if (found.length > 0) {
+    const best = found.slice().sort((a, b) => b.major - a.major)[0]
+    return { found: true, path: best.home, major: best.major, match: false }
+  }
+  return { found: false, path: '', major: required, match: false }
 })
 
-// ── JDK 자동 설치(Temurin 21, 취소 가능) ──────────────────────────────
+// 사용자가 직접 입력/선택한 JDK 경로의 자바 버전을 확인한다.
+//   major=0        → 경로에서 java 를 못 찾거나 버전을 못 읽음(진행 차단용).
+//   match=true     → 권장 버전과 정확히 일치.
+//   match=false    → 다른 버전(진행은 허용하되 렌더러가 경고를 띄운다).
+ipcMain.handle('jdk:verify', async (_event, jdkPath: string, recommendedInput?: number): Promise<{ ok: boolean; major: number; required: number; match: boolean }> => {
+  const required = normalizeRecommendedJdk(recommendedInput)
+  const javaExe = jdkPath ? findJavaExeInHome(jdkPath) : ''
+  const major = javaExe ? getJavaMajor(javaExe) : 0
+  return { ok: major > 0, major, required, match: major === required }
+})
+
+// ── JDK 자동 설치(권장 버전 Temurin, .mc_custom/jdk 에 설치, 취소 가능) ──────
 interface JdkInstallState {
   controller: AbortController | null
   destDir: string | null
@@ -362,22 +459,24 @@ function downloadStream(
   })
 }
 
-ipcMain.handle('jdk:install', async (): Promise<{ ok: boolean; path?: string; message?: string }> => {
+ipcMain.handle('jdk:install', async (_event, recommendedInput?: number): Promise<{ ok: boolean; path?: string; message?: string }> => {
   if (jdkInstall.inProgress) {
     return { ok: false, message: t('errors.jdkBusy') }
   }
+  const required = normalizeRecommendedJdk(recommendedInput)
   jdkInstall.inProgress = true
   const controller = new AbortController()
   jdkInstall.controller = controller
-  const tmpRoot = path.join(getAppDataDir(), 'jdk-cache')
+  // 자동 설치 JDK 는 .mc_custom/jdk 아래에 둔다(파일제거기가 .mc_custom 통째로 정리 가능).
+  const tmpRoot = path.join(installerJdkRoot(), '.cache')
   await fsp.mkdir(tmpRoot, { recursive: true })
-  const tempZip = path.join(tmpRoot, `temurin-21-${Date.now()}.zip`)
-  const destDir = path.join(getAppDataDir(), 'jdk', 'temurin-21')
+  const tempZip = path.join(tmpRoot, `${jdkDirName(required)}-${Date.now()}.zip`)
+  const destDir = path.join(installerJdkRoot(), jdkDirName(required))
   jdkInstall.destDir = destDir
   try {
-    // Adoptium API v3: latest GA JDK 21 Windows x64. 본문은 307 로 GitHub 릴리즈로 리다이렉트.
-    const url = 'https://api.adoptium.net/v3/binary/latest/21/ga/windows/x64/jdk/hotspot/normal/eclipse?project=jdk'
-    sendLog(t('log.jdkInstallStart'))
+    // Adoptium API v3: latest GA JDK(Windows x64). 본문은 307 로 GitHub 릴리즈로 리다이렉트.
+    const url = `https://api.adoptium.net/v3/binary/latest/${required}/ga/windows/x64/jdk/hotspot/normal/eclipse?project=jdk`
+    sendLog(t('log.jdkInstallStart', { major: required }))
     let lastPctReported = -1
     await downloadStream(url, tempZip, controller.signal, (loaded, total) => {
       if (total > 0) {
@@ -614,6 +713,54 @@ async function downloadResourcepackZip(pack: PackDefinition, customRoot: string)
   await downloadFile(url, target)
 }
 
+/**
+ * run.bat 에 넣을 java 실행 명령을 만든다. 자동 설치 JDK 는 %APPDATA% 아래에 있으므로
+ * 사용자명이 한글이어도 인코딩 문제 없이 실행되도록 `%APPDATA%\...\java.exe` 형태로
+ * 만든다(사용자명은 cmd 가 런타임에 전개). %APPDATA% 밖(예: Program Files)이면 절대경로.
+ */
+function javaCommandForRunBat(javaExe: string): string {
+  const appData = getAppDataDir()
+  const rel = path.relative(appData, javaExe)
+  if (rel && !rel.startsWith('..') && !path.isAbsolute(rel)) {
+    return `"%APPDATA%\\${rel.split(/[\\/]/).join('\\')}"`
+  }
+  return `"${javaExe}"`
+}
+
+/**
+ * 서버 zip 의 run.bat 이 시스템 PATH 의 `java` 를 그대로 쓰면, 사용자의 낡은 자바(예: 17)로
+ * 실행돼 최신 마인크래프트 서버가 UnsupportedClassVersionError 로 뜨지 않는다.
+ * 설치기가 준비/선택한 JDK 의 java 를 쓰도록 run.bat 의 `java` 실행 토큰을 치환한다.
+ *   - `java ... -jar ...`, `java @args nogui`, `"java" ...` 형태 지원.
+ *   - 이미 경로/다른 실행기를 쓰는 줄은 건드리지 않는다.
+ * 바이트 보존을 위해 latin1 로 읽고 쓰되(비-ASCII 주석 깨짐 방지), 삽입하는 경로는
+ * %APPDATA% 전개형이라 ASCII 라 안전하다.
+ */
+async function patchServerRunBatJava(installPath: string, jdkPath: string): Promise<void> {
+  const runBat = path.join(installPath, 'run.bat')
+  if (!fs.existsSync(runBat)) return
+  const javaExe = findJavaExeInHome(jdkPath)
+  if (!javaExe) {
+    sendLog(t('log.runBatJavaSkip'))
+    return
+  }
+  const command = javaCommandForRunBat(javaExe)
+  const original = await fsp.readFile(runBat, { encoding: 'latin1' })
+  const lines = original.split(/\r?\n/)
+  let changed = false
+  for (let i = 0; i < lines.length; i++) {
+    const m = lines[i].match(/^(\s*)"?java(?:\.exe)?"?(\s+.*)$/i)
+    if (m && /(-jar|\bnogui\b|@|-Xm)/i.test(m[2])) {
+      lines[i] = `${m[1]}${command}${m[2]}`
+      changed = true
+    }
+  }
+  if (changed) {
+    await fsp.writeFile(runBat, lines.join('\r\n'), { encoding: 'latin1' })
+    sendLog(t('log.runBatJavaPatched', { java: command }))
+  }
+}
+
 ipcMain.handle('server:install', async (_event, payload: ServerInstallPayload) => {
   const pack = state.packs.get(payload.packKey)
   if (!pack) throw new Error(t('errors.packNotFound2'))
@@ -630,6 +777,8 @@ ipcMain.handle('server:install', async (_event, payload: ServerInstallPayload) =
   // 동의 흐름은 renderer가 별도 IPC로 읽고 동의 시 덮어쓴다.
   // 설치기는 포트를 직접 열지 않는다(요청). run.bat 에 UPnP 자동 개방을 주입하지
   // 않으며, 사용자가 라우터에서 수동 포워딩을 하고 포트포워딩 페이지에서 확인만 한다.
+  // 단, run.bat 이 시스템의 낡은 자바를 쓰지 않도록 설치기가 준비한 JDK 로 바꿔준다.
+  await patchServerRunBatJava(installPath, payload.jdkPath)
 })
 
 ipcMain.handle('server:readEula', async (_event, installPath: string): Promise<{ exists: boolean; content: string }> => {

src/installer/preload.ts

@@ -24,8 +24,12 @@ const api = {
     ipcRenderer.invoke('install:validatePath', target),
 
   // 3-2
-  detectJdk: (): Promise<{ found: boolean; path: string }> => ipcRenderer.invoke('jdk:detect'),
-  installJdk: (): Promise<{ ok: boolean; path?: string; message?: string }> => ipcRenderer.invoke('jdk:install'),
+  detectJdk: (recommendedJdk?: number): Promise<{ found: boolean; path: string; major: number; match: boolean }> =>
+    ipcRenderer.invoke('jdk:detect', recommendedJdk),
+  verifyJdk: (jdkPath: string, recommendedJdk?: number): Promise<{ ok: boolean; major: number; required: number; match: boolean }> =>
+    ipcRenderer.invoke('jdk:verify', jdkPath, recommendedJdk),
+  installJdk: (recommendedJdk?: number): Promise<{ ok: boolean; path?: string; message?: string }> =>
+    ipcRenderer.invoke('jdk:install', recommendedJdk),
   cancelJdkInstall: (): Promise<{ ok: boolean }> => ipcRenderer.invoke('jdk:cancelInstall'),
 
   // 3-3

src/server/routes/op.ts

@@ -23,10 +23,12 @@ import {
   savePackList,
   setPackPublic,
   setTermVisibility,
-  writeAccounts
+  writeAccounts,
+  SUPPORTED_JDK_MAJORS
 } from '../../shared/store.js'
 import { hashPassword, isHashed, verifyPassword } from '../password.js'
 import { fetchReleaseVersions } from '../../shared/mojang.js'
+import { fetchJdkAvailability, fetchJdkReleaseNames } from '../../shared/jdkVersions.js'
 import { fetchPlaylistEntries, fetchVideoMeta, YtDlpUnavailableError } from '../youtube.js'
 import { requireAuth } from '../middleware/auth.js'
 import type { PackDefinition, PackList } from '../../shared/types.js'
@@ -187,13 +189,39 @@ opRouter.get('/op/dashboard/:packName', requireAuth, async (req, res, next) => {
       packKey,
       pack: definition,
       releases,
-      isPublic
+      isPublic,
+      jdkOptions: SUPPORTED_JDK_MAJORS
     })
   } catch (error) {
     next(error)
   }
 })
 
+// ─── /op/jdk-versions ───────────────────────────────────────────────────
+// Adoptium(Temurin) 에서 실제 배포되는 JDK 메이저 목록을 프록시(브라우저 직접 호출은
+// CORS 로 막힘). 편집기의 "권장 JDK" 드롭다운을 이 결과로 채운다.
+opRouter.get('/op/jdk-versions', requireAuth, async (_req, res, next) => {
+  try {
+    res.json(await fetchJdkAvailability())
+  } catch (error) {
+    next(error)
+  }
+})
+
+// 특정 메이저의 상세 릴리스 이름(GA + EA 스냅샷). "자세히 보기" 에서 사용.
+opRouter.get('/op/jdk-versions/:major', requireAuth, async (req, res, next) => {
+  try {
+    const major = Number(req.params.major)
+    if (!Number.isInteger(major) || major < 8 || major > 99) {
+      res.status(400).json({ error: 'invalid major' })
+      return
+    }
+    res.json(await fetchJdkReleaseNames(major))
+  } catch (error) {
+    next(error)
+  }
+})
+
 // ─── /op/list ──────────────────────────────────────────────────────────
 // 음악퀴즈를 카드 한 줄로 표시. 카드 클릭 → /op/list/:packName
 opRouter.get('/op/list', requireAuth, async (req, res, next) => {
@@ -570,6 +598,7 @@ opRouter.post('/op/dashboard/:packName', requireAuth, async (req, res, next) =>
       serverMaxRam: Number(pickFirstValue(req.body.serverMaxRam)),
       clientMinRam: Number(pickFirstValue(req.body.clientMinRam)),
       clientRecommendedRam: Number(pickFirstValue(req.body.clientRecommendedRam)),
+      recommendedJdk: Number(pickFirstValue(req.body.recommendedJdk)),
       mapPath: pickFirstValue(req.body.mapPath),
       serverPath: pickFirstValue(req.body.serverPath)
     }

src/shared/jdkVersions.ts

@@ -0,0 +1,118 @@
+import https from 'node:https'
+
+// Adoptium(Temurin) API 로부터 실제 배포되는 JDK 버전을 가져온다. 설치기가 이 벤더를
+// 쓰므로 사이트의 "권장 JDK" 목록도 같은 소스에서 채운다(하드코딩 금지). 네트워크
+// 실패 시에는 정적 폴백을 돌려줘 편집기가 항상 동작하도록 한다.
+
+const AVAILABLE_URL = 'https://api.adoptium.net/v3/info/available_releases'
+const CACHE_TTL_MS = 6 * 60 * 60 * 1000 // 6시간
+
+const FALLBACK_MAJORS = [8, 11, 17, 21, 25]
+const FALLBACK_LTS = [8, 11, 17, 21, 25]
+
+export interface JdkAvailability {
+  /** 배포되는 모든 메이저(예: 8,11,17,21,25,26). 내림차순. */
+  available: number[]
+  /** LTS 메이저만(예: 8,11,17,21,25). 내림차순. */
+  lts: number[]
+  mostRecentLts: number
+  mostRecentFeature: number
+}
+
+export interface JdkReleaseNames {
+  major: number
+  /** 정식(GA) 릴리스 이름들(예: jdk-25.0.3+9). */
+  ga: string[]
+  /** 개발 스냅샷(EA) 릴리스 이름들(예: jdk-25.0.4+6-ea-beta). */
+  ea: string[]
+}
+
+let availCache: { data: JdkAvailability; at: number } | null = null
+const releaseNamesCache = new Map<number, { data: JdkReleaseNames; at: number }>()
+
+function fetchJson<T>(url: string): Promise<T> {
+  return new Promise((resolve, reject) => {
+    const request = https.get(url, { timeout: 8000, headers: { accept: 'application/json' } }, (response) => {
+      const code = response.statusCode ?? 0
+      if (code !== 200) {
+        response.resume()
+        reject(new Error(`Adoptium HTTP ${code}`))
+        return
+      }
+      const chunks: Buffer[] = []
+      response.on('data', (c: Buffer) => chunks.push(c))
+      response.on('end', () => {
+        try {
+          resolve(JSON.parse(Buffer.concat(chunks).toString('utf8')) as T)
+        } catch (error) {
+          reject(error as Error)
+        }
+      })
+    })
+    request.on('error', reject)
+    request.on('timeout', () => request.destroy(new Error('Adoptium timeout')))
+  })
+}
+
+const sortDesc = (nums: number[]): number[] => [...new Set(nums)].sort((a, b) => b - a)
+
+export async function fetchJdkAvailability(): Promise<JdkAvailability> {
+  if (availCache && Date.now() - availCache.at < CACHE_TTL_MS) return availCache.data
+  try {
+    const raw = await fetchJson<{
+      available_releases?: number[]
+      available_lts_releases?: number[]
+      most_recent_lts?: number
+      most_recent_feature_release?: number
+    }>(AVAILABLE_URL)
+    const available = sortDesc(
+      (Array.isArray(raw.available_releases) ? raw.available_releases : FALLBACK_MAJORS).filter((n) => Number.isInteger(n))
+    )
+    const lts = sortDesc(
+      (Array.isArray(raw.available_lts_releases) ? raw.available_lts_releases : FALLBACK_LTS).filter((n) => Number.isInteger(n))
+    )
+    const data: JdkAvailability = {
+      available,
+      lts,
+      mostRecentLts: Number(raw.most_recent_lts) || (lts[0] ?? 21),
+      mostRecentFeature: Number(raw.most_recent_feature_release) || (available[0] ?? 25)
+    }
+    availCache = { data, at: Date.now() }
+    return data
+  } catch {
+    return (
+      availCache?.data ?? {
+        available: sortDesc(FALLBACK_MAJORS),
+        lts: sortDesc(FALLBACK_LTS),
+        mostRecentLts: 25,
+        mostRecentFeature: 25
+      }
+    )
+  }
+}
+
+async function fetchReleaseNames(major: number, type: 'ga' | 'ea'): Promise<string[]> {
+  const url =
+    `https://api.adoptium.net/v3/assets/feature_releases/${major}/${type}` +
+    '?architecture=x64&image_type=jdk&os=windows&vendor=eclipse&page_size=10'
+  try {
+    const arr = await fetchJson<Array<{ release_name?: string }>>(url)
+    if (!Array.isArray(arr)) return []
+    const names: string[] = []
+    for (const r of arr) {
+      if (typeof r?.release_name === 'string' && !names.includes(r.release_name)) names.push(r.release_name)
+    }
+    return names
+  } catch {
+    return []
+  }
+}
+
+export async function fetchJdkReleaseNames(major: number): Promise<JdkReleaseNames> {
+  const cached = releaseNamesCache.get(major)
+  if (cached && Date.now() - cached.at < CACHE_TTL_MS) return cached.data
+  const [ga, ea] = await Promise.all([fetchReleaseNames(major, 'ga'), fetchReleaseNames(major, 'ea')])
+  const data: JdkReleaseNames = { major, ga, ea }
+  releaseNamesCache.set(major, { data, at: Date.now() })
+  return data
+}

src/shared/store.ts

@@ -52,6 +52,7 @@ export function defaultPackDefinition(name: string): PackDefinition {
     serverMaxRam: 4096,
     clientMinRam: 2048,
     clientRecommendedRam: 4096,
+    recommendedJdk: DEFAULT_JDK_MAJOR,
     mapPath: '',
     serverPath: ''
   }
@@ -78,6 +79,24 @@ function sanitizeFolderName(input: unknown): string {
 
 const ALLOWED_LOADERS: LoaderType[] = ['vanilla', 'forge', 'fabric', 'neoforge']
 
+/**
+ * 편집기 드롭다운의 정적 폴백 목록(LTS). 실제 목록은 Adoptium API 에서 가져오며,
+ * 네트워크 실패 시에만 이 값을 쓴다.
+ * 마인크래프트 버전대별: 8(구버전) / 11(1.17) / 17(1.18~1.20.4) / 21(1.20.5~) / 25(최신).
+ */
+export const SUPPORTED_JDK_MAJORS: number[] = [8, 11, 17, 21, 25]
+/** recommendedJdk 미지정/이상값일 때의 기본 권장 버전. */
+export const DEFAULT_JDK_MAJOR = 25
+
+/**
+ * 입력값을 JDK 메이저로 보정. 특정 목록에 얽매이지 않고 실제 배포되는 자바 메이저
+ * 범위(8~99)면 허용하고, 벗어나면 기본값. (목록은 Adoptium 에서 동적으로 온다.)
+ */
+export function normalizeRecommendedJdk(input: unknown): number {
+  const n = Math.floor(Number(input))
+  return Number.isFinite(n) && n >= 8 && n <= 99 ? n : DEFAULT_JDK_MAJOR
+}
+
 export function normalizePackDefinition(input: Partial<PackDefinition> & Record<string, unknown>): PackDefinition {
   const fallback = defaultPackDefinition(typeof input.name === 'string' ? input.name : 'new')
   const platform = (input.platform ?? {}) as Partial<PackDefinition['platform']>
@@ -112,6 +131,7 @@ export function normalizePackDefinition(input: Partial<PackDefinition> & Record<
     serverMaxRam: clampNumber(input.serverMaxRam, fallback.serverMaxRam),
     clientMinRam: clampNumber(input.clientMinRam, fallback.clientMinRam),
     clientRecommendedRam: clampNumber(input.clientRecommendedRam, fallback.clientRecommendedRam),
+    recommendedJdk: normalizeRecommendedJdk(input.recommendedJdk),
     mapPath: sanitizeZipFileName(input.mapPath),
     serverPath: sanitizeZipFileName(input.serverPath)
   }

src/shared/types.ts

@@ -28,6 +28,11 @@ export interface PackDefinition {
   serverMaxRam: number
   clientMinRam: number
   clientRecommendedRam: number
+  /**
+   * 서버 실행에 권장하는 JDK 메이저 버전(예: 25). 설치기가 이 버전을 우선 탐색/설치한다.
+   * 사이트에서 선택하며, 허용 목록(SUPPORTED_JDK_MAJORS) 밖의 값은 기본값으로 보정된다.
+   */
+  recommendedJdk: number
   /** /file/maps/<mapPath> 에서 받아 .mc_custom/saves 로 풀 zip 파일 이름. */
   mapPath: string
   /** /file/servers/<serverPath> 에서 받아 서버 설치 경로로 풀 zip 파일 이름. */

views/op/editor.ejs

@@ -80,6 +80,17 @@
           <span><%= t('editor.clientRecommendedRam') %></span>
           <input type="number" name="clientRecommendedRam" value="<%= pack.clientRecommendedRam %>" min="512" required />
         </label>
+        <label>
+          <span><%= t('editor.recommendedJdk') %></span>
+          <select name="recommendedJdk" id="recommendedJdk" data-current="<%= pack.recommendedJdk %>" required>
+            <option value="<%= pack.recommendedJdk %>" selected>Java <%= pack.recommendedJdk %></option>
+          </select>
+          <label class="muted" style="font-weight:normal;display:flex;align-items:center;gap:6px;margin-top:4px;">
+            <input type="checkbox" id="jdkShowDetails" style="width:auto;" /> <%= t('editor.jdkShowDetails') %>
+          </label>
+          <div id="jdkDetails" class="muted" hidden style="margin-top:4px;font-size:12px;line-height:1.6;word-break:break-all;"></div>
+          <small class="muted"><%= t('editor.recommendedJdkHint') %></small>
+        </label>
         <label>
           <span><%= t('editor.mapPath') %></span>
           <input name="mapPath" value="<%= pack.mapPath %>" placeholder="my-map.zip" pattern=".+\.zip" />
@@ -126,6 +137,73 @@
     function formatLoaderLoadFailed(message) {
       return I18N.loaderLoadFailedPrefix.replace('__M__', message)
     }
+    var JDK = {
+      current: <%= pack.recommendedJdk %>,
+      fallback: <%- JSON.stringify(jdkOptions) %>,
+      detailsGa: <%- JSON.stringify(t('editor.jdkDetailsGa')) %>,
+      detailsEa: <%- JSON.stringify(t('editor.jdkDetailsEa')) %>,
+      detailsLoading: <%- JSON.stringify(t('common.loading')) %>,
+      detailsNone: <%- JSON.stringify(t('editor.jdkDetailsNone')) %>,
+      ltsSuffix: <%- JSON.stringify(t('editor.jdkLtsSuffix')) %>
+    }
+  </script>
+  <script>
+    (function () {
+      var sel = document.getElementById('recommendedJdk')
+      var details = document.getElementById('jdkDetails')
+      var toggle = document.getElementById('jdkShowDetails')
+      if (!sel || !toggle) return
+      var current = Number(sel.getAttribute('data-current')) || JDK.current
+      var avail = null // { available:[], lts:[] }
+
+      function rebuild() {
+        var availList, ltsList
+        if (avail) { availList = avail.available; ltsList = avail.lts }
+        else { availList = JDK.fallback.slice().sort(function (a, b) { return b - a }); ltsList = availList }
+        var ltsSet = {}
+        ltsList.forEach(function (m) { ltsSet[m] = true })
+        var list = toggle.checked ? availList.slice() : ltsList.slice()
+        if (list.indexOf(current) < 0) list = [current].concat(list)
+        var seen = {}, html = ''
+        list.forEach(function (m) {
+          if (seen[m]) return
+          seen[m] = true
+          var label = 'Java ' + m + (ltsSet[m] ? JDK.ltsSuffix : '')
+          html += '<option value="' + m + '"' + (m === current ? ' selected' : '') + '>' + label + '</option>'
+        })
+        sel.innerHTML = html
+        sel.value = String(current)
+      }
+
+      function loadDetails(major) {
+        details.hidden = false
+        details.textContent = JDK.detailsLoading
+        fetch('/op/jdk-versions/' + major)
+          .then(function (r) { if (!r.ok) throw new Error('HTTP ' + r.status); return r.json() })
+          .then(function (d) {
+            var html = ''
+            if (d.ga && d.ga.length) html += '<div><strong>' + JDK.detailsGa + ':</strong> ' + d.ga.slice(0, 6).join(', ') + '</div>'
+            if (d.ea && d.ea.length) html += '<div><strong>' + JDK.detailsEa + ':</strong> ' + d.ea.slice(0, 6).join(', ') + '</div>'
+            details.innerHTML = html || JDK.detailsNone
+          })
+          .catch(function () { details.textContent = JDK.detailsNone })
+      }
+
+      sel.addEventListener('change', function () {
+        current = Number(sel.value)
+        if (toggle.checked) loadDetails(current)
+      })
+      toggle.addEventListener('change', function () {
+        rebuild()
+        if (toggle.checked) loadDetails(current)
+        else { details.hidden = true; details.innerHTML = '' }
+      })
+
+      fetch('/op/jdk-versions')
+        .then(function (r) { if (!r.ok) throw new Error('HTTP ' + r.status); return r.json() })
+        .then(function (d) { avail = d; rebuild() })
+        .catch(function () { rebuild() })
+    })()
   </script>
   <script>
     (function () {