Added cli flags for running installer and udev warning

gui/electron/main/cli.ts

@@ -2,11 +2,14 @@ import { program } from "commander";
 
 program
   .option('-p --path <path>', 'set launch path')
+  .option("-s --steam [os]", 'steam mode')
+  .option("-i --install [os]", 'run the driver installer')
   .option(
     '--skip-server-if-running',
     'gui will not launch the server if it is already running'
   )
   .allowUnknownOption();
 
+console.log(process.argv)
 program.parse(process.argv);
 export const options = program.opts();

gui/electron/main/index.ts

@@ -363,7 +363,12 @@ const spawnServer = async () => {
 
   logger.info({ javaBin, serverJar }, 'Found Java and server jar');
 
-  const process = spawn(javaBin, ['-Xmx128M', '-jar', serverJar, 'run']);
+  if (options.steam)
+    logger.info('launching in steam mode');
+
+  logger.info(`Java start command: ${['-Xmx128M', '-jar', serverJar, (options.steam ? [`--steam=${options.steam}`] : [undefined]), ...(options.install ? [`--install=${options.install}`] : []), 'run']}`)
+
+  const process = spawn(javaBin, ['-Xmx128M', '-jar', serverJar, ...(options.steam ? [`--steam=${options.steam}`] : []), ...(options.install ? [`--install=${options.install}`] : []), 'run']);
 
   process.stdout?.on('data', (message) => {
     mainWindow?.webContents.send(IPC_CHANNELS.SERVER_STATUS, {

server/core/src/main/java/dev/slimevr/FeatureFlags.kt

@@ -0,0 +1,9 @@
+package dev.slimevr
+
+data class FeatureFlags(
+	var steam: Boolean = false,
+	var steamArgs: String = "",
+	var installer: Boolean = false,
+	var installerArgs: String = "",
+	var noUdev: Boolean = false,
+)

server/core/src/main/java/dev/slimevr/VRServer.kt

@@ -56,6 +56,7 @@ const val SLIMEVR_IDENTIFIER = "dev.slimevr.SlimeVR"
 
 class VRServer @JvmOverloads constructor(
 	bridgeProvider: BridgeProvider = { _, _ -> sequence {} },
+	featureFlagsProvider: (VRServer) -> FeatureFlags = { _ -> FeatureFlags() },
 	serialHandlerProvider: (VRServer) -> SerialHandler = { _ -> SerialHandlerStub() },
 	flashingHandlerProvider: (VRServer) -> SerialFlashingHandler? = { _ -> null },
 	vrcConfigHandlerProvider: (VRServer) -> VRCConfigHandler = { _ -> VRCConfigHandlerStub() },
@@ -83,6 +84,9 @@ class VRServer @JvmOverloads constructor(
 	@JvmField
 	val deviceManager: DeviceManager
 
+	@JvmField
+	val featureFlags: FeatureFlags
+
 	@JvmField
 	val bvhRecorder: BVHRecorder
 
@@ -127,6 +131,7 @@ class VRServer @JvmOverloads constructor(
 
 	init {
 		// UwU
+		featureFlags = featureFlagsProvider(this)
 		deviceManager = DeviceManager(this)
 		serialHandler = serialHandlerProvider(this)
 		serialFlashingHandler = flashingHandlerProvider(this)

server/core/src/main/java/dev/slimevr/protocol/rpc/installinfo/RPCInstallInfoHandler.kt

@@ -13,23 +13,12 @@ import java.io.IOException
 
 class RPCInstallInfoHandler(var rpcHandler: RPCHandler, var api: ProtocolAPI) {
 
-	val os = System.getProperty("os.name").lowercase()
-
 	init {
 		rpcHandler.registerPacketListener(RpcMessage.InstalledInfoRequest, ::onInstalledInfoRequest)
 	}
 
 	fun onInstalledInfoRequest(conn: GenericConnection, messageHeader: RpcMessageHeader?) {
-		if (os.contains("linux")) {
-			val linuxFlavour = try {
-				File("/etc/os-release").readText()
-			} catch (e: Exception) {
-				LogManager.warning("Couldn't determine OS distribution: $e")
-				return
-			}
-			if (linuxFlavour.contains("ID=steamos") || linuxFlavour.contains("ID=nixos") || linuxFlavour.contains("ID_LIKE=nixos")) {
-				return
-			}
+		if (!api.server.featureFlags.noUdev) {
 			val udevResponse = executeShellCommand("udevadm", "cat")
 			if (udevResponse == null) {
 				LogManager.warning("Server couldn't verify if udev is installed")
@@ -46,16 +35,16 @@ class RPCInstallInfoHandler(var rpcHandler: RPCHandler, var api: ProtocolAPI) {
 			conn.send(fbb.dataBuffer())
 		}
 	}
-
-	private fun executeShellCommand(vararg command: String): String? = try {
-		val process = ProcessBuilder(*command)
-			.redirectErrorStream(true)
-			.start()
-		process.inputStream.bufferedReader().readText().also {
-			process.waitFor()
-		}
-	} catch (e: IOException) {
-		LogManager.warning("Error executing shell command: ${e.message}")
-		null
-	}
+}
+
+private fun executeShellCommand(vararg command: String): String? = try {
+	val process = ProcessBuilder(*command)
+		.redirectErrorStream(true)
+		.start()
+	process.inputStream.bufferedReader().readText().also {
+		process.waitFor()
+	}
+} catch (e: IOException) {
+	LogManager.warning("Error executing shell command: ${e.message}")
+	null
 }

server/desktop/src/main/java/dev/slimevr/desktop/Main.kt

@@ -2,6 +2,7 @@
 
 package dev.slimevr.desktop
 
+import dev.slimevr.FeatureFlags
 import dev.slimevr.Keybinding
 import dev.slimevr.SLIMEVR_IDENTIFIER
 import dev.slimevr.VRServer
@@ -44,7 +45,7 @@ val VERSION =
 	(GIT_VERSION_TAG.ifEmpty { GIT_COMMIT_HASH }) +
 		if (GIT_CLEAN) "" else "-dirty"
 
-var IS_STEAM = false
+val featureFlags = FeatureFlags()
 
 fun main(args: Array<String>) {
 	System.setProperty("awt.useSystemAAFontSettings", "on")
@@ -55,15 +56,16 @@ fun main(args: Array<String>) {
 	val options = Options()
 	options.addOption("h", "help", false, "Show help")
 	options.addOption("V", "version", false, "Show version")
-	options.addOption("i", "install", false, "Run the driver install")
-	options.addOption("S", "steam", false, "Run the server in steam mode")
+	options.addOption("i", "install", true, "Run the driver install")
+	options.addOption("s", "steam", true, "Run the server in steam mode")
+	options.addOption("u", "no-udev", false, "Skip the checking of installed udev rules")
 	val cmd: CommandLine = try {
 		parser.parse(options, args, true)
 	} catch (e: org.apache.commons.cli.ParseException) {
 		formatter.printHelp("slimevr.jar", options)
 		exitProcess(1)
 	}
-
+	LogManager.info("Parsing options")
 	if (cmd.hasOption("help")) {
 		formatter.printHelp("slimevr.jar", options)
 		exitProcess(0)
@@ -73,13 +75,18 @@ fun main(args: Array<String>) {
 		exitProcess(0)
 	}
 	if (cmd.hasOption("install")) {
+		featureFlags.installer = true
+		featureFlags.installerArgs = cmd.getOptionValue("install")
 		LogManager.info("Driver install")
 		val installDrivers = InstallDrivers()
 		installDrivers.runInstaller()
 	}
 	if (cmd.hasOption("steam")) {
-		LogManager.info("Running in steam")
-		IS_STEAM = true
+		featureFlags.steam = true
+		featureFlags.steamArgs = cmd.getOptionValue("steam")
+	}
+	if (cmd.hasOption("no-udev")) {
+		featureFlags.noUdev = true
 	}
 
 	if (cmd.args.isEmpty()) {
@@ -100,6 +107,9 @@ fun main(args: Array<String>) {
 	}
 	LogManager.info("Using log folder: $dir")
 	LogManager.info("Running version $VERSION")
+	LogManager.info("Running in steam ${featureFlags.steam} with arg ${featureFlags.steamArgs}")
+	LogManager.info("Do we need to check udev rules ${featureFlags.noUdev}")
+	LogManager.info("Running installer ${featureFlags.installer} with arg ${featureFlags.installerArgs}")
 	if (!SystemUtils.isJavaVersionAtLeast(org.apache.commons.lang3.JavaVersion.JAVA_17)) {
 		LogManager.severe("SlimeVR start-up error! A minimum of Java 17 is required.")
 		JOptionPane
@@ -114,7 +124,7 @@ fun main(args: Array<String>) {
 	}
 
 	val isInstallDisabled = System.getenv("SLIME_SERVER_DISABLE_INSTALLER")?.toInt()
-	if (IS_STEAM && isInstallDisabled != 1) {
+	if (featureFlags.steam && isInstallDisabled != 1) {
 		val installDrivers = InstallDrivers()
 		installDrivers.runInstaller()
 	}
@@ -146,6 +156,7 @@ fun main(args: Array<String>) {
 	try {
 		val vrServer = VRServer(
 			::provideBridges,
+			{ _ -> FeatureFlags() },
 			{ _ -> DesktopSerialHandler() },
 			{ _ -> DesktopSerialFlashingHandler() },
 			{ _ -> DesktopVRCConfigHandler() },
@@ -153,7 +164,7 @@ fun main(args: Array<String>) {
 			configManager = configManager,
 		)
 		vrServer.start()
-
+		LogManager.info("udev ${featureFlags.noUdev}, steam ${featureFlags.steam}")
 		// Start service for USB HID trackers
 		DesktopHIDManager(
 			"Sensors HID service",