Fix: Ship Complete Native Remotely Releases.

Author: RedxAx

.github/workflows/release.yml

@@ -141,20 +141,34 @@ jobs:
           token: ${{ secrets.REPROJECTS_PAT }}
           path: ReProjects/ReSync
           ref: ${{ steps.refs.outputs.resync }}
-      - name: Build Remotely Jar
+      - name: Build Remotely Jar And Linux AppImage
         working-directory: ReProjects/Remotely
         shell: bash
         run: |
           chmod +x gradlew
-          flock /var/lock/restudio-release-build.lock ./gradlew -Premotely.version=${{ needs.prepare.outputs.version }} fatJar --no-daemon --stacktrace
+          flock /var/lock/restudio-release-build.lock ./gradlew -Premotely.version=${{ needs.prepare.outputs.version }} fatJar createLinuxAppImage --no-daemon --stacktrace
           install -d release-artifacts
           cp build/libs/Remotely-Fat.jar "release-artifacts/Remotely-${{ needs.prepare.outputs.version }}.jar"
+          app_dir=build/app-image/Remotely
+          ln -s bin/Remotely "$app_dir/AppRun"
+          cp packaging/Remotely.png "$app_dir/remotely.png"
+          printf '[Desktop Entry]\nType=Application\nName=Remotely\nComment=Minecraft Server IDE\nExec=Remotely\nIcon=remotely\nCategories=Development;\nTerminal=false\n' > "$app_dir/remotely.desktop"
+          curl --fail --location --retry 3 --output appimagetool.AppImage https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-x86_64.AppImage
+          printf 'a6d71e2b6cd66f8e8d16c37ad164658985e0cf5fcaa950c90a482890cb9d13e0  appimagetool.AppImage\n' | sha256sum --check
+          chmod +x appimagetool.AppImage
+          APPIMAGE_EXTRACT_AND_RUN=1 ARCH=x86_64 ./appimagetool.AppImage "$app_dir" "release-artifacts/Remotely-${{ needs.prepare.outputs.version }}.AppImage"
       - uses: actions/upload-artifact@v7
         with:
           name: remotely-jar
           path: ReProjects/Remotely/release-artifacts/*.jar
           if-no-files-found: error
           retention-days: 30
+      - uses: actions/upload-artifact@v7
+        with:
+          name: remotely-linux
+          path: ReProjects/Remotely/release-artifacts/*.AppImage
+          if-no-files-found: error
+          retention-days: 30
 
   windows:
     needs: prepare
@@ -224,8 +238,89 @@ jobs:
           if-no-files-found: error
           retention-days: 30
 
+  macos:
+    needs: prepare
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - runner: macos-15
+            platform: macos-arm64
+          - runner: macos-15-intel
+            platform: macos-x64
+    runs-on: ${{ matrix.runner }}
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          path: ReProjects/Remotely
+          ref: ${{ needs.prepare.outputs.source_ref }}
+      - id: refs
+        shell: bash
+        run: |
+          lock=ReProjects/Remotely/.restudio/workspace.lock.json
+          for project in ReScreen Remodel Rebase Recast ReSync; do
+            printf '%s=%s\n' "${project,,}" "$(jq -r --arg project "$project" '.[$project]' "$lock")" >> "$GITHUB_OUTPUT"
+          done
+      - uses: actions/checkout@v7
+        with:
+          repository: RedxAx/ReScreen
+          token: ${{ secrets.REPROJECTS_PAT }}
+          path: ReProjects/ReScreen
+          ref: ${{ steps.refs.outputs.rescreen }}
+      - uses: actions/checkout@v7
+        with:
+          repository: RedxAx/Remodel
+          token: ${{ secrets.REPROJECTS_PAT }}
+          path: ReProjects/Remodel
+          ref: ${{ steps.refs.outputs.remodel }}
+      - uses: actions/checkout@v7
+        with:
+          repository: RedxAx/Rebase
+          token: ${{ secrets.REPROJECTS_PAT }}
+          path: ReProjects/Rebase
+          ref: ${{ steps.refs.outputs.rebase }}
+      - uses: actions/checkout@v7
+        with:
+          repository: RedxAx/Recast
+          token: ${{ secrets.REPROJECTS_PAT }}
+          path: ReProjects/Recast
+          ref: ${{ steps.refs.outputs.recast }}
+      - uses: actions/checkout@v7
+        with:
+          repository: RedxAx/ReSync
+          token: ${{ secrets.REPROJECTS_PAT }}
+          path: ReProjects/ReSync
+          ref: ${{ steps.refs.outputs.resync }}
+      - uses: actions/setup-java@v5
+        with:
+          distribution: temurin
+          java-version: '21'
+          cache: gradle
+      - name: Build Remotely Disk Image
+        working-directory: ReProjects/Remotely
+        shell: bash
+        run: |
+          iconset=build/Remotely.iconset
+          mkdir -p "$iconset" release-artifacts
+          for entry in '16 icon_16x16.png' '32 icon_16x16@2x.png' '32 icon_32x32.png' '64 icon_32x32@2x.png' '128 icon_128x128.png' '256 icon_128x128@2x.png' '256 icon_256x256.png' '512 icon_256x256@2x.png' '512 icon_512x512.png' '1024 icon_512x512@2x.png'; do
+            read -r size name <<< "$entry"
+            sips -z "$size" "$size" packaging/Remotely.png --out "$iconset/$name" >/dev/null
+          done
+          iconutil --convert icns "$iconset" --output build/Remotely.icns
+          chmod +x gradlew
+          ./gradlew -Premotely.version=${{ needs.prepare.outputs.version }} -Premotely.packageIcon="$PWD/build/Remotely.icns" createMacDmg --no-daemon --stacktrace
+          disk_image=$(find build/dist-macos -maxdepth 1 -type f -name '*.dmg' -print -quit)
+          [[ -n "$disk_image" ]] || { printf 'Remotely Disk Image Was Not Created\n' >&2; exit 1; }
+          cp "$disk_image" "release-artifacts/Remotely-${{ needs.prepare.outputs.version }}-${{ matrix.platform }}.dmg"
+      - uses: actions/upload-artifact@v7
+        with:
+          name: remotely-${{ matrix.platform }}
+          path: ReProjects/Remotely/release-artifacts/*.dmg
+          if-no-files-found: error
+          retention-days: 30
+
   publish:
-    needs: [prepare, jar, windows]
+    needs: [prepare, jar, windows, macos]
     runs-on: [self-hosted, node1, linux, release]
     environment: production
     permissions:
@@ -262,3 +357,6 @@ jobs:
           fi
           release-tools/scripts/releases/publish-release.sh "artifacts/Remotely-${{ needs.prepare.outputs.version }}.jar" "$project" "${{ needs.prepare.outputs.version }}" "$channel" crossplatform "$visibility"
           release-tools/scripts/releases/publish-release.sh "artifacts/Remotely-${{ needs.prepare.outputs.version }}.exe" "$project" "${{ needs.prepare.outputs.version }}" "$channel" windows "$visibility"
+          release-tools/scripts/releases/publish-release.sh "artifacts/Remotely-${{ needs.prepare.outputs.version }}.AppImage" "$project" "${{ needs.prepare.outputs.version }}" "$channel" linux "$visibility"
+          release-tools/scripts/releases/publish-release.sh "artifacts/Remotely-${{ needs.prepare.outputs.version }}-macos-arm64.dmg" "$project" "${{ needs.prepare.outputs.version }}" "$channel" macos-arm64 "$visibility"
+          release-tools/scripts/releases/publish-release.sh "artifacts/Remotely-${{ needs.prepare.outputs.version }}-macos-x64.dmg" "$project" "${{ needs.prepare.outputs.version }}" "$channel" macos-x64 "$visibility"

build.gradle.kts

@@ -1,6 +1,7 @@
 import groovy.json.JsonSlurper
 import org.gradle.api.file.DuplicatesStrategy
 import org.gradle.api.publish.maven.MavenPublication
+import java.util.zip.ZipFile
 
 plugins {
     id("java-library")
@@ -16,6 +17,38 @@ application {
     mainClass.set("redxax.oxy.remotely.RemotelyInit")
 }
 
+val reStudioReleaseJarTasks: List<Any> = if (useReStudioSourceDependencies) {
+    listOf(
+        gradle.includedBuild("ReScreen").task(":jar"),
+        gradle.includedBuild("Remodel").task(":jar"),
+        gradle.includedBuild("Rebase").task(":jar"),
+        gradle.includedBuild("Recast").task(":recast-api:jar"),
+        gradle.includedBuild("Recast").task(":recast-bridge:jar"),
+        gradle.includedBuild("ReSync").task(":ReSyncCore:jar")
+    )
+} else {
+    emptyList()
+}
+
+val releaseRequiredClasses = listOf(
+    "restudio/rescreen/config/UiConfigStore.class",
+    "restudio/rebase/Rebase.class",
+    "redxax/restudio/Remodel/Main.class",
+    "dev/restudio/recast/api/FeatureDescriptor.class",
+    "dev/restudio/recast/bridge/BridgeEntry.class",
+    "restudio/resync/network/NetworkFrame.class"
+)
+
+fun requireReleaseClasses(archives: Collection<File>, artifactName: String) {
+    val jarFiles = archives.filter { it.isFile && it.extension.equals("jar", ignoreCase = true) }
+    val missingClasses = releaseRequiredClasses.filter { className ->
+        jarFiles.none { archive -> ZipFile(archive).use { it.getEntry(className) != null } }
+    }
+    require(missingClasses.isEmpty()) {
+        "$artifactName Is Missing Required Classes: ${missingClasses.joinToString()}"
+    }
+}
+
 tasks.named<JavaExec>("run") {
     if (useReStudioSourceDependencies) {
         dependsOn(
@@ -424,81 +457,129 @@ tasks.jar {
     archiveFileName.set("Remotely-App.jar")
 }
 
-tasks.register<Exec>("createInstaller") {
-    dependsOn("clean", "jar")
+tasks.register<Jar>("fatJar") {
+    group = "build"
+    dependsOn(reStudioReleaseJarTasks)
+    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+    archiveFileName.set("Remotely-Fat.jar")
+    from(sourceSets.main.get().output)
+    from({
+        configurations.runtimeClasspath.get().filter { it.exists() }.map {
+            if (it.isDirectory) it else zipTree(it)
+        }
+    })
+    exclude("META-INF/*.SF", "META-INF/*.DSA", "META-INF/*.RSA")
+    manifest {
+        attributes["Main-Class"] = "redxax.oxy.remotely.RemotelyInit"
+        attributes["Implementation-Version"] = project.version.toString()
+        attributes["Automatic-Module-Name"] = "dev.restudio.remotely.app"
+    }
+    doLast {
+        requireReleaseClasses(listOf(archiveFile.get().asFile), "Remotely Fat Jar")
+    }
+}
 
-    val javaToolchains = project.extensions.getByType<JavaToolchainService>()
-    val javaLauncher = javaToolchains.launcherFor {
-        languageVersion.set(JavaLanguageVersion.of(21))
-    }.get()
+val packageJarName = "Remotely-App.jar"
+val cleanVersion = version.toString().substringBefore('-').replace(Regex("[^0-9.]"), "")
+val javaLauncher = extensions.getByType<JavaToolchainService>().launcherFor {
+    languageVersion.set(JavaLanguageVersion.of(21))
+}
+val jpackageExecutable = javaLauncher.map {
+    val executable = if (System.getProperty("os.name").startsWith("Windows", ignoreCase = true)) "jpackage.exe" else "jpackage"
+    File(it.metadata.installationPath.asFile, "bin/$executable").absolutePath
+}
 
-    val jdkHome = javaLauncher.metadata.installationPath.asFile
-    val jpackagePath = File(jdkHome, "bin/jpackage.exe").absolutePath
+fun preparePackageInput(stagingDir: File, outputDir: File, artifactName: String) {
+    outputDir.deleteRecursively()
+    stagingDir.deleteRecursively()
+    stagingDir.mkdirs()
+    copy {
+        from(tasks.named<Jar>("fatJar").flatMap { it.archiveFile })
+        into(stagingDir)
+        rename { packageJarName }
+    }
+    requireReleaseClasses(fileTree(stagingDir) { include("*.jar") }.files, artifactName)
+}
 
-    val stagingDir = layout.buildDirectory.dir("staging").get().asFile.absolutePath
-    val inputDir = layout.buildDirectory.dir("libs").get().asFile.absolutePath
-    val outputDir = layout.buildDirectory.dir("dist").get().asFile.absolutePath
-    val jarName = "Remotely-App.jar"
+tasks.register<Exec>("createInstaller") {
+    dependsOn("fatJar")
+
+    val stagingDir = layout.buildDirectory.dir("package-input/windows").get().asFile
+    val outputDir = layout.buildDirectory.dir("dist").get().asFile
     val iconPath = layout.projectDirectory.file("packaging/Remotely.ico").asFile.absolutePath
-    val cleanVersion = version.toString().split("-")[0].replace(Regex("[^0-9.]"), "")
 
     doFirst {
-        println("--------------------------------------------------")
-        println("Using jpackage:  $jpackagePath")
-        println("--------------------------------------------------")
-
-        file(outputDir).deleteRecursively()
-        file(stagingDir).deleteRecursively()
-        file(stagingDir).mkdirs()
-
-        copy {
-            from(inputDir)
-            into(stagingDir)
-            include(jarName)
-        }
-
-        copy {
-            from(configurations.runtimeClasspath)
-            into(stagingDir)
-        }
-
-        println("Staging directory contents:")
-        file(stagingDir).listFiles()?.forEach { println(it.name) }
+        preparePackageInput(stagingDir, outputDir, "Remotely Windows Installer")
     }
 
     commandLine(
-        jpackagePath,
+        jpackageExecutable.get(),
         "--type", "exe",
-        "--dest", outputDir,
-        "--input", stagingDir,
+        "--dest", outputDir.absolutePath,
+        "--input", stagingDir.absolutePath,
         "--name", "Remotely",
-        "--main-jar", jarName,
+        "--main-jar", packageJarName,
         "--main-class", application.mainClass.get(),
         "--app-version", cleanVersion,
         "--icon", iconPath,
         "--win-shortcut",
         "--win-menu",
         "--win-menu-group", "ReStudio",
         "--win-dir-chooser",
-//        "--win-console",
         "--java-options", "-Dfile.encoding=UTF-8 -Xmx4G"
     )
 }
 
-tasks.register<Jar>("fatJar") {
-    group = "build"
-    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-    archiveFileName.set("Remotely-Fat.jar")
-    from(sourceSets.main.get().output)
-    from({
-        configurations.runtimeClasspath.get().filter { it.exists() }.map {
-            if (it.isDirectory) it else zipTree(it)
-        }
-    })
-    exclude("META-INF/*.SF", "META-INF/*.DSA", "META-INF/*.RSA")
-    manifest {
-        attributes["Main-Class"] = "redxax.oxy.remotely.RemotelyInit"
-        attributes["Implementation-Version"] = project.version.toString()
-        attributes["Automatic-Module-Name"] = "dev.restudio.remotely.app"
+tasks.register<Exec>("createLinuxAppImage") {
+    dependsOn("fatJar")
+
+    val stagingDir = layout.buildDirectory.dir("package-input/linux").get().asFile
+    val outputDir = layout.buildDirectory.dir("app-image").get().asFile
+    val iconPath = layout.projectDirectory.file("packaging/Remotely.png").asFile.absolutePath
+
+    doFirst {
+        preparePackageInput(stagingDir, outputDir, "Remotely Linux AppImage")
+    }
+
+    commandLine(
+        jpackageExecutable.get(),
+        "--type", "app-image",
+        "--dest", outputDir.absolutePath,
+        "--input", stagingDir.absolutePath,
+        "--name", "Remotely",
+        "--main-jar", packageJarName,
+        "--main-class", application.mainClass.get(),
+        "--app-version", cleanVersion,
+        "--icon", iconPath,
+        "--java-options", "-Dfile.encoding=UTF-8 -Xmx4G"
+    )
+}
+
+tasks.register<Exec>("createMacDmg") {
+    dependsOn("fatJar")
+
+    val stagingDir = layout.buildDirectory.dir("package-input/macos").get().asFile
+    val outputDir = layout.buildDirectory.dir("dist-macos").get().asFile
+    val iconPath = providers.gradleProperty("remotely.packageIcon").orElse(
+        layout.projectDirectory.file("packaging/Remotely.icns").asFile.absolutePath
+    )
+    val macVersion = cleanVersion.split('.').take(3).joinToString(".")
+
+    doFirst {
+        preparePackageInput(stagingDir, outputDir, "Remotely macOS Disk Image")
     }
+
+    commandLine(
+        jpackageExecutable.get(),
+        "--type", "dmg",
+        "--dest", outputDir.absolutePath,
+        "--input", stagingDir.absolutePath,
+        "--name", "Remotely",
+        "--main-jar", packageJarName,
+        "--main-class", application.mainClass.get(),
+        "--app-version", macVersion,
+        "--icon", iconPath.get(),
+        "--mac-package-identifier", "net.restudiomc.remotely",
+        "--java-options", "-Dfile.encoding=UTF-8 -Xmx4G"
+    )
 }