fix: Cannot install neoforge for new minecraft

xmcl-keystone-ui/src/composables/instanceCreation.ts

@@ -21,9 +21,18 @@ export function useInstanceCreation(gameProfile: Ref<GameProfile>, versions: Ref
   const { getLatestMinecraftRelease } = useService(VersionMetadataServiceKey)
   let latest = ''
   getLatestMinecraftRelease().then(v => { latest = v })
+  const getNewRuntime = () => ({
+    minecraft: latest || '',
+    forge: '',
+    liteloader: '',
+    fabricLoader: '',
+    yarn: '',
+    quiltLoader: '',
+    neoForged: '',
+  })
   const data = reactive<InstanceData>({
     name: '',
-    runtime: { forge: '', minecraft: latest || '', liteloader: '', fabricLoader: '', yarn: '', labyMod: '' } as RuntimeVersions,
+    runtime: getNewRuntime(),
     version: '',
     java: '',
     showLog: false,
@@ -70,13 +79,7 @@ export function useInstanceCreation(gameProfile: Ref<GameProfile>, versions: Ref
      */
     reset() {
       data.name = ''
-      data.runtime = {
-        minecraft: latest || '',
-        forge: '',
-        liteloader: '',
-        fabricLoader: '',
-        yarn: '',
-      }
+      data.runtime = getNewRuntime()
       data.java = ''
       data.showLog = false
       data.hideLauncher = true

xmcl-keystone-ui/src/composables/instanceVersionDiagnose.ts

@@ -1,4 +1,4 @@
-import { InstallServiceKey, DiagnoseServiceKey, LocalVersionHeader, RuntimeVersions, getExpectVersion } from '@xmcl/runtime-api'
+import { InstallServiceKey, DiagnoseServiceKey, LocalVersionHeader, RuntimeVersions, getExpectVersion, InstanceServiceKey } from '@xmcl/runtime-api'
 import { InjectionKey, Ref } from 'vue'
 import { InstanceResolveVersion } from './instanceVersion'
 import { useInstanceVersionInstall } from './instanceVersionInstall'
@@ -7,13 +7,14 @@ import { useService } from './service'
 
 export const kInstanceVersionDiagnose: InjectionKey<ReturnType<typeof useInstanceVersionDiagnose>> = Symbol('InstanceVersionDiagnose')
 
-export function useInstanceVersionDiagnose(runtime: Ref<RuntimeVersions>, resolvedVersion: Ref<InstanceResolveVersion | undefined>, versions: Ref<LocalVersionHeader[]>) {
+export function useInstanceVersionDiagnose(path: Ref<string>, runtime: Ref<RuntimeVersions>, resolvedVersion: Ref<InstanceResolveVersion | undefined>, versions: Ref<LocalVersionHeader[]>) {
   const { diagnoseAssetIndex, diagnoseAssets, diagnoseJar, diagnoseLibraries, diagnoseProfile } = useService(DiagnoseServiceKey)
   const issueItems = ref([] as LaunchMenuItem[])
   let operation = undefined as undefined | (() => Promise<void>)
   const { t } = useI18n()
   const { install } = useInstanceVersionInstall(versions)
   const { installAssetsForVersion, installAssets, installLibraries, installDependencies, installByProfile } = useService(InstallServiceKey)
+  const { editInstance } = useService(InstanceServiceKey)
   let abortController = new AbortController()
 
   const loading = ref(false)
@@ -41,6 +42,10 @@ export function useInstanceVersionDiagnose(runtime: Ref<RuntimeVersions>, resolv
         if (version) {
           await installDependencies(version)
         }
+        await editInstance({
+          instancePath: path.value,
+          version,
+        })
         await _update(resolvedVersion.value)
       }
       issueItems.value = [reactive({

xmcl-keystone-ui/src/composables/instanceVersionInstall.ts

@@ -57,7 +57,7 @@ export function useInstanceVersionInstall(versions: Ref<LocalVersionHeader[]>) {
     if (neoForged) {
       const localNeoForge = local.find(v => v.neoForged === neoForged && v.minecraft === minecraft)
       if (!localNeoForge) {
-        const neoForgedVersion = await getCacheOrFetch('/neoforged-versions', () => getNeoForgedVersionList())
+        const neoForgedVersion = await getCacheOrFetch(`/neoforged-versions/${minecraft}`, () => getNeoForgedVersionList(minecraft))
         const found = neoForgedVersion.versions.find(v => v === neoForged)
         const id = found ?? neoForged
         forgeVersion = await installNeoForged({ version: id, minecraft })

xmcl-keystone-ui/src/composables/version.ts

@@ -128,13 +128,13 @@ export function useQuiltVersions(minecraftVersion: Ref<string>, local: Ref<Local
   }
 }
 
-export function useNeoForgedVersions(local: Ref<LocalVersionHeader[]>) {
+export function useNeoForgedVersions(minecraft: Ref<string>, local: Ref<LocalVersionHeader[]>) {
   const { getNeoForgedVersionList } = useService(VersionMetadataServiceKey)
   const _refreshing = useServiceBusy(VersionMetadataServiceKey, 'getNeoForgedVersionList')
 
-  const { data, isValidating, mutate, error } = useSWRV('/neoforged-versions',
+  const { data, isValidating, mutate, error } = useSWRV(computed(() => `/neoforged-versions/${minecraft.value}`),
     async () => {
-      const result = await getNeoForgedVersionList().then(markRaw)
+      const result = await getNeoForgedVersionList(minecraft.value).then(markRaw)
       return result
     },
     inject(kSWRVConfig))

xmcl-keystone-ui/src/composables/versionList.ts

@@ -57,14 +57,13 @@ export function useMinecraftVersionList(version: Ref<string>, local: Ref<LocalVe
 }
 
 export function useNeoForgedVersionList(minecraft: Ref<string>, version: Ref<string>, local: Ref<LocalVersionHeader[]>) {
-  const { versions, installed, latest, recommended, refresh, refreshing, error } = useNeoForgedVersions(local)
+  const { versions, installed, latest, recommended, refresh, refreshing, error } = useNeoForgedVersions(minecraft, local)
   const { semaphores } = injection(kSemaphores)
   const { t } = useI18n()
 
   const items = computed(() => {
     const vers = versions.value
     const result: VersionItem[] = vers
-      .filter(v => v.startsWith(minecraft.value))
       .map(v => {
         const key = LockKey.version(`neoforge-${v}`)
         return reactive({

xmcl-keystone-ui/src/util/instanceModLoaderDefault.ts

@@ -52,7 +52,7 @@ export function useInstanceModLoaderDefault(path: Ref<string>, runtime: Ref<Runt
           return true
         }
       } else if (loader === 'neoforge') {
-        const versions = await swrvGet('/neoforged-versions', () => getNeoForgedVersionList(), cache, dedupingInterval)
+        const versions = await swrvGet(`/neoforged-versions/${runtime.value.minecraft}`, () => getNeoForgedVersionList(runtime.value.minecraft), cache, dedupingInterval)
         const version = versions.release
         if (version) {
           await editInstance({

xmcl-keystone-ui/src/windows/main/Context.ts

@@ -83,7 +83,7 @@ export default defineComponent({
     const resourcePackSearch = useResourcePackSearch(instance.runtime, resourcePacks.enabled, resourcePacks.disabled)
     const shaderPackSearch = useShaderPackSearch(instance.runtime, shaderPacks.shaderPack)
 
-    const versionDiagnose = useInstanceVersionDiagnose(instance.runtime, instanceVersion.resolvedVersion, localVersions.versions)
+    const versionDiagnose = useInstanceVersionDiagnose(instance.path, instance.runtime, instanceVersion.resolvedVersion, localVersions.versions)
     const javaDiagnose = useInstanceJavaDiagnose(java.all, instanceJava.java, instanceJava.recommendation, queue)
     const filesDiagnose = useInstanceFilesDiagnose(files.files, files.install)
     const userDiagnose = useUserDiagnose(user.userProfile)

xmcl-runtime-api/src/entities/version.ts

@@ -240,8 +240,16 @@ export function findNeoForgedVersion(minecraft: string, resolvedVersion: Resolve
   const hasNeoForged = resolvedVersion.libraries.some(lib => lib.groupId === 'net.neoforged.fancymodloader')
   if (!hasNeoForged) return ''
   const forgeIndex = resolvedVersion.arguments.game.indexOf('--fml.forgeVersion')
-  const version = resolvedVersion.arguments.game[forgeIndex + 1]
-  return `${minecraft}-${version}` as string
+  const neoForgeIndex = resolvedVersion.arguments.game.indexOf('--fml.neoForgeVersion')
+  if (forgeIndex !== -1) {
+    const version = resolvedVersion.arguments.game[forgeIndex + 1]
+    return `${minecraft}-${version}` as string
+  }
+  if (neoForgeIndex !== -1) {
+    const version = resolvedVersion.arguments.game[neoForgeIndex + 1]
+    return version as string
+  }
+  return ''
 }
 
 export function findLabyModVersion(resolvedVersion: ResolvedVersion) {
@@ -373,6 +381,7 @@ function isVersionMatched(version: LocalVersionHeader,
   }
 
   if (neoForged) {
+    console.log(version.neoForged)
     // require neoForged
     if (!version.neoForged || version.neoForged !== neoForged) {
       // require neoForged but not neoForged

xmcl-runtime-api/src/services/VersionMetadataService.ts

@@ -16,7 +16,7 @@ export interface VersionMetadataService {
   /**
    * Get the neo forge version list
    */
-  getNeoForgedVersionList(): Promise<NeoForgedVersions>
+  getNeoForgedVersionList(minecraftVersion: string): Promise<NeoForgedVersions>
   /**
    * Get liteloader version list in the store.
    */

xmcl-runtime/install/InstallService.ts

@@ -305,13 +305,13 @@ export class InstallService extends AbstractService implements IInstallService {
     let version: string | undefined
     for (const java of validJavaPaths) {
       try {
-        this.log(`Start to install forge ${options.version} on ${options.minecraft} by ${java.path}`)
-        version = await this.submit(installNeoForgedTask(options.version, this.getPath(), {
+        this.log(`Start to install neoforge ${options.version} on ${options.minecraft} by ${java.path}`)
+        version = await this.submit(installNeoForgedTask(options.version.startsWith(options.minecraft) ? 'forge' : 'neoforge', options.version, this.getPath(), {
           ...installOptions,
           java: java.path,
           inheritsFrom: options.minecraft,
         }).setName('installForge', { id: options.version }))
-        this.log(`Success to install forge ${options.version} on ${options.minecraft}`)
+        this.log(`Success to install neoforge ${options.version} on ${options.minecraft}`)
         break
       } catch (err) {
         if (err instanceof Error) {

xmcl-runtime/install/VersionMetadataService.ts

@@ -97,8 +97,13 @@ export class VersionMetadataService extends AbstractService implements IVersionM
   }
 
   @Singleton()
-  async getNeoForgedVersionList() {
-    const response = await request('https://maven.neoforged.net/releases/net/neoforged/forge/maven-metadata.xml')
+  async getNeoForgedVersionList(version: string) {
+    const allowed = ['1.20.1', '1.20.2'/* 20.2.x */, '1.20.3'/* 20.3.x */, '1.20.4'/* 20.4.x */]
+    if (!allowed.includes(version)) { return { latest: '', release: '', versions: [] } }
+    const url = version === '1.20.1'
+      ? 'https://maven.neoforged.net/releases/net/neoforged/forge/maven-metadata.xml'
+      : 'https://maven.neoforged.net/releases/net/neoforged/neoforge/maven-metadata.xml'
+    const response = await request(url)
     const body = await response.body.text()
     const parser = new XMLParser()
     const forgeMetadata = parser.parse(body)
@@ -108,6 +113,13 @@ export class VersionMetadataService extends AbstractService implements IVersionM
       release: forgeMetadata.metadata.versioning.release,
       versions: versions.version,
     }
+    if (version === '1.20.2') {
+      result.versions = result.versions.filter(v => v.startsWith('20.2'))
+    } else if (version === '1.20.3') {
+      result.versions = result.versions.filter(v => v.startsWith('20.3'))
+    } else if (version === '1.20.4') {
+      result.versions = result.versions.filter(v => v.startsWith('20.4'))
+    }
     return result
   }