jetkvm · ym · May 20, 2025 · May 20, 2025 · May 20, 2025
diff --git a/.golangci.yml b/.golangci.yml
@@ -22,6 +22,9 @@ linters:
       - linters:
           - errcheck
         path: _test.go
+      - linters:
+          - forbidigo
+        path: cmd/main.go
     paths:
       - third_party$
       - builtin$

diff --git a/cmd/main.go b/cmd/main.go
@@ -1,9 +1,27 @@
 package main
 
 import (
+	"flag"
+	"fmt"
+	"os"
+
 	"github.com/jetkvm/kvm"
 )
 
 func main() {
+	versionPtr := flag.Bool("version", false, "print version and exit")
+	versionJsonPtr := flag.Bool("version-json", false, "print version as json and exit")
+	flag.Parse()
+
+	if *versionPtr || *versionJsonPtr {
+		versionData, err := kvm.GetVersionData(*versionJsonPtr)
+		if err != nil {
+			fmt.Printf("failed to get version data: %v\n", err)
+			os.Exit(1)
+		}
+		fmt.Println(string(versionData))
+		return
+	}
+
 	kvm.Main()
 }
diff --git a/dev_deploy.sh b/dev_deploy.sh
@@ -174,7 +174,7 @@ cd "${REMOTE_PATH}"
 chmod +x jetkvm_app_debug
 
 # Run the application in the background
-PION_LOG_TRACE=${LOG_TRACE_SCOPES} ./jetkvm_app_debug
+PION_LOG_TRACE=${LOG_TRACE_SCOPES} ./jetkvm_app_debug | tee -a /tmp/jetkvm_app_debug.log
 EOF
 
 echo "Deployment complete."
diff --git a/jsonrpc.go b/jsonrpc.go
@@ -266,8 +266,13 @@ func rpcSetDevChannelState(enabled bool) error {
 func rpcGetUpdateStatus() (*UpdateStatus, error) {
 	includePreRelease := config.IncludePreRelease
 	updateStatus, err := GetUpdateStatus(context.Background(), GetDeviceID(), includePreRelease)
+	// to ensure backwards compatibility,
+	// if there's an error, we won't return an error, but we will set the error field
 	if err != nil {
-		return nil, fmt.Errorf("error checking for updates: %w", err)
+		if updateStatus == nil {
+			return nil, fmt.Errorf("error checking for updates: %w", err)
+		}
+		updateStatus.Error = err.Error()
 	}
 
 	return updateStatus, nil

diff --git a/native.go b/native.go
@@ -8,6 +8,7 @@ import (
 	"io"
 	"net"
 	"os"
+	"strings"
 	"sync"
 	"time"
 
@@ -282,14 +283,30 @@ func shouldOverwrite(destPath string, srcHash []byte) bool {
 	return !bytes.Equal(srcHash, dstHash)
 }
 
+func getNativeSha256() ([]byte, error) {
+	version, err := resource.ResourceFS.ReadFile("jetkvm_native.sha256")
+	if err != nil {
+		return nil, err
+	}
+	return version, nil
+}
+
+func GetNativeVersion() (string, error) {
+	version, err := getNativeSha256()
+	if err != nil {
+		return "", err
+	}
+	return strings.TrimSpace(string(version)), nil
+}
+
 func ensureBinaryUpdated(destPath string) error {
 	srcFile, err := resource.ResourceFS.Open("jetkvm_native")
 	if err != nil {
 		return err
 	}
 	defer srcFile.Close()
 
-	srcHash, err := resource.ResourceFS.ReadFile("jetkvm_native.sha256")
+	srcHash, err := getNativeSha256()
 	if err != nil {
 		nativeLogger.Debug().Msg("error reading embedded jetkvm_native.sha256, proceeding with update")
 		srcHash = nil

diff --git a/ota.go b/ota.go
@@ -41,12 +41,19 @@ type UpdateStatus struct {
 	Remote                *UpdateMetadata `json:"remote"`
 	SystemUpdateAvailable bool            `json:"systemUpdateAvailable"`
 	AppUpdateAvailable    bool            `json:"appUpdateAvailable"`
+
+	// for backwards compatibility
+	Error string `json:"error,omitempty"`
 }
 
 const UpdateMetadataUrl = "https://api.jetkvm.com/releases"
 
 var builtAppVersion = "0.1.0+dev"
 
+func GetBuiltAppVersion() string {
+	return builtAppVersion
+}
+
 func GetLocalVersion() (systemVersion *semver.Version, appVersion *semver.Version, err error) {
 	appVersion, err = semver.NewVersion(builtAppVersion)
 	if err != nil {
@@ -489,52 +496,47 @@ func TryUpdate(ctx context.Context, deviceId string, includePreRelease bool) err
 }
 
 func GetUpdateStatus(ctx context.Context, deviceId string, includePreRelease bool) (*UpdateStatus, error) {
+	updateStatus := &UpdateStatus{}
+
 	// Get local versions
 	systemVersionLocal, appVersionLocal, err := GetLocalVersion()
 	if err != nil {
-		return nil, fmt.Errorf("error getting local version: %w", err)
+		return updateStatus, fmt.Errorf("error getting local version: %w", err)
+	}
+	updateStatus.Local = &LocalMetadata{
+		AppVersion:    appVersionLocal.String(),
+		SystemVersion: systemVersionLocal.String(),
 	}
 
 	// Get remote metadata
 	remoteMetadata, err := fetchUpdateMetadata(ctx, deviceId, includePreRelease)
 	if err != nil {
-		return nil, fmt.Errorf("error checking for updates: %w", err)
-	}
-
-	// Build local UpdateMetadata
-	localMetadata := &LocalMetadata{
-		AppVersion:    appVersionLocal.String(),
-		SystemVersion: systemVersionLocal.String(),
+		return updateStatus, fmt.Errorf("error checking for updates: %w", err)
 	}
+	updateStatus.Remote = remoteMetadata
 
+	// Get remote versions
 	systemVersionRemote, err := semver.NewVersion(remoteMetadata.SystemVersion)
 	if err != nil {
-		return nil, fmt.Errorf("error parsing remote system version: %w", err)
+		return updateStatus, fmt.Errorf("error parsing remote system version: %w", err)
 	}
 	appVersionRemote, err := semver.NewVersion(remoteMetadata.AppVersion)
 	if err != nil {
-		return nil, fmt.Errorf("error parsing remote app version: %w, %s", err, remoteMetadata.AppVersion)
+		return updateStatus, fmt.Errorf("error parsing remote app version: %w, %s", err, remoteMetadata.AppVersion)
 	}
 
-	systemUpdateAvailable := systemVersionRemote.GreaterThan(systemVersionLocal)
-	appUpdateAvailable := appVersionRemote.GreaterThan(appVersionLocal)
+	updateStatus.SystemUpdateAvailable = systemVersionRemote.GreaterThan(systemVersionLocal)
+	updateStatus.AppUpdateAvailable = appVersionRemote.GreaterThan(appVersionLocal)
 
 	// Handle pre-release updates
 	isRemoteSystemPreRelease := systemVersionRemote.Prerelease() != ""
 	isRemoteAppPreRelease := appVersionRemote.Prerelease() != ""
 
 	if isRemoteSystemPreRelease && !includePreRelease {
-		systemUpdateAvailable = false
+		updateStatus.SystemUpdateAvailable = false
 	}
 	if isRemoteAppPreRelease && !includePreRelease {
-		appUpdateAvailable = false
-	}
-
-	updateStatus := &UpdateStatus{
-		Local:                 localMetadata,
-		Remote:                remoteMetadata,
-		SystemUpdateAvailable: systemUpdateAvailable,
-		AppUpdateAvailable:    appUpdateAvailable,
+		updateStatus.AppUpdateAvailable = false
 	}
 
 	return updateStatus, nil

diff --git a/ui/src/routes/devices.$id.settings.general.update.tsx b/ui/src/routes/devices.$id.settings.general.update.tsx
@@ -43,9 +43,10 @@ export default function SettingsGeneralUpdateRoute() {
 
 export interface SystemVersionInfo {
   local: { appVersion: string; systemVersion: string };
-  remote: { appVersion: string; systemVersion: string };
+  remote?: { appVersion: string; systemVersion: string };
   systemUpdateAvailable: boolean;
   appUpdateAvailable: boolean;
+  error?: string;
 }
 
 export function Dialog({
@@ -142,13 +143,19 @@ function LoadingState({
     return new Promise<SystemVersionInfo>((resolve, reject) => {
       send("getUpdateStatus", {}, async resp => {
         if ("error" in resp) {
-          notifications.error("Failed to check for updates");
+          notifications.error(`Failed to check for updates: ${resp.error}`);
           reject(new Error("Failed to check for updates"));
         } else {
           const result = resp.result as SystemVersionInfo;
           setAppVersion(result.local.appVersion);
           setSystemVersion(result.local.systemVersion);
-          resolve(result);
+
+          if (result.error) {
+            notifications.error(`Failed to check for updates: ${result.error}`);
+            reject(new Error("Failed to check for updates"));
+          } else {
+            resolve(result);
+          }
         }
       });
     });
@@ -235,9 +242,9 @@ function UpdatingDeviceState({
 
     console.log(
       `For ${type}:\n` +
-        `  Download Progress: ${downloadProgress}% (${otaState[`${type}DownloadProgress`]})\n` +
-        `  Update Progress: ${updateProgress}% (${otaState[`${type}UpdateProgress`]})\n` +
-        `  Verification Progress: ${verificationProgress}% (${otaState[`${type}VerificationProgress`]})`,
+      `  Download Progress: ${downloadProgress}% (${otaState[`${type}DownloadProgress`]})\n` +
+      `  Update Progress: ${updateProgress}% (${otaState[`${type}UpdateProgress`]})\n` +
+      `  Verification Progress: ${verificationProgress}% (${otaState[`${type}VerificationProgress`]})`,
     );
 
     if (type === "app") {
@@ -442,13 +449,14 @@ function UpdateAvailableState({
           {versionInfo?.systemUpdateAvailable ? (
             <>
               <span className="font-semibold&q
10000
uot;>System:</span>{" "}
-              {versionInfo?.remote.systemVersion}
+              {versionInfo?.remote?.systemVersion}
               <br />
             </>
           ) : null}
           {versionInfo?.appUpdateAvailable ? (
             <>
-              <span className="font-semibold">App:</span> {versionInfo?.remote.appVersion}
+              <span className="font-semibold">App:</span>{" "}
+              {versionInfo?.remote?.appVersion}
             </>
           ) : null}
         </p>

diff --git a/ui/src/routes/devices.$id.tsx b/ui/src/routes/devices.$id.tsx
@@ -703,12 +703,17 @@ export default function KvmIdRoute() {
 
     send("getUpdateStatus", {}, async resp => {
       if ("error" in resp) {
-        notifications.error("Failed to get device version");
-      } else {
-        const result = resp.result as SystemVersionInfo;
-        setAppVersion(result.local.appVersion);
-        setSystemVersion(result.local.systemVersion);
+        notifications.error(`Failed to get device version: ${resp.error}`);
+        return 
       }
+
+      const result = resp.result as SystemVersionInfo;
+      if (result.error) {
+        notifications.error(`Failed to get device version: ${result.error}`);
+      }
+
+      setAppVersion(result.local.appVersion);
+      setSystemVersion(result.local.systemVersion);
     });
   }, [appVersion, send, setAppVersion, setSystemVersion]);
 

diff --git a/version.go b/version.go
@@ -0,0 +1,56 @@
+package kvm
+
+import (
+	"bytes"
+	"encoding/json"
+	"html/template"
+	"runtime"
+
+	"github.com/prometheus/common/version"
+)
+
+var versionInfoTmpl = `
+JetKVM Application, version {{.version}} (branch: {{.branch}}, revision: {{.revision}})
+  build date:       {{.buildDate}}
+  go version:       {{.goVersion}}
+  platform:         {{.platform}}
+
+{{if .nativeVersion}}
+JetKVM Native, version {{.nativeVersion}}
+{{end}}
+`
+
+func GetVersionData(isJson bool) ([]byte, error) {
+	version.Version = GetBuiltAppVersion()
+
+	m := map[string]string{
+		"version":   version.Version,
+		"revision":  version.GetRevision(),
+		"branch":    version.Branch,
+		"buildDate": version.BuildDate,
+		"goVersion": version.GoVersion,
+		"platform":  runtime.GOOS + "/" + runtime.GOARCH,
+	}
+
+	nativeVersion, err := GetNativeVersion()
+	if err == nil {
+		m["nativeVersion"] = nativeVersion
+	}
+
+	if isJson {
+		jsonData, err := json.Marshal(m)
+		if err != nil {
+			return nil, err
+		}
+		return jsonData, nil
+	}
+
+	t := template.Must(template.New("version").Parse(versionInfoTmpl))
+
+	var buf bytes.Buffer
+	if err := t.ExecuteTemplate(&buf, "version", m); err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}