8 | {children}
9 |
10 | );
11 | }
12 |
--------------------------------------------------------------------------------
/block_device_notlinux.go:
--------------------------------------------------------------------------------
1 | //go:build !linux
2 |
3 | package kvm
4 |
5 | import (
6 | "os"
7 | )
8 |
9 | func (d *NBDDevice) runClientConn() {
10 | d.l.Error().Msg("platform not supported")
11 | os.Exit(1)
12 | }
13 |
14 | func (d *NBDDevice) Close() {
15 | d.l.Error().Msg("platform not supported")
16 | os.Exit(1)
17 | }
18 |
--------------------------------------------------------------------------------
/pkg/nmlite/udhcpc/options.go:
--------------------------------------------------------------------------------
1 | package udhcpc
2 |
3 | func (u *DHCPClient) GetNtpServers() []string {
4 | if u.lease == nil {
5 | return nil
6 | }
7 | servers := make([]string, len(u.lease.NTPServers))
8 | for i, server := range u.lease.NTPServers {
9 | servers[i] = server.String()
10 | }
11 | return servers
12 | }
13 |
--------------------------------------------------------------------------------
/internal/timesync/rtc_notlinux.go:
--------------------------------------------------------------------------------
1 | //go:build !linux
2 |
3 | package timesync
4 |
5 | import (
6 | "errors"
7 | "time"
8 | )
9 |
10 | func (t *TimeSync) readRtcTime() (time.Time, error) {
11 | return time.Now(), nil
12 | }
13 |
14 | func (t *TimeSync) setRtcTime(tu time.Time) error {
15 | return errors.New("not supported")
16 | }
17 |
--------------------------------------------------------------------------------
/ui/src/providers/FeatureFlagContext.tsx:
--------------------------------------------------------------------------------
1 | import { createContext } from "react";
2 |
3 | import { FeatureFlagContextType } from "./FeatureFlagProvider";
4 |
5 | // Create the context
6 |
7 | export const FeatureFlagContext = createContext
12 |
15 | );
16 | }
17 |
--------------------------------------------------------------------------------
/ui/src/routes/devices.$id.settings._index.tsx:
--------------------------------------------------------------------------------
1 | import { redirect } from "react-router";
2 | import type { LoaderFunction, LoaderFunctionArgs } from "react-router";
3 |
4 | import { getDeviceUiPath } from "@hooks/useAppNavigation";
5 |
6 | const loader: LoaderFunction = ({ params }: LoaderFunctionArgs) => {
7 | return redirect(getDeviceUiPath("/settings/general", params.id));
8 | }
9 |
10 | export default function SettingIndexRoute() {
11 | return (<>);
12 | }
13 |
14 | SettingIndexRoute.loader = loader;
--------------------------------------------------------------------------------
/internal/native/eez/src/ui/fonts.h:
--------------------------------------------------------------------------------
1 | #ifndef EEZ_LVGL_UI_FONTS_H
2 | #define EEZ_LVGL_UI_FONTS_H
3 |
4 | #include {title}
13 |{description}
14 |
18 | {children}
19 |
20 | );
21 | }
22 |
23 |
--------------------------------------------------------------------------------
/.vscode/c_cpp_properties.json:
--------------------------------------------------------------------------------
1 | {
2 | "configurations": [
3 | {
4 | "name": "Linux",
5 | "includePath": [
6 | "${workspaceFolder}/**"
7 | ],
8 | "defines": [],
9 | "compilerPath": "/opt/jetkvm-native-buildkit/bin/arm-rockchip830-linux-uclibcgnueabihf-gcc",
10 | "cStandard": "c17",
11 | "cppStandard": "gnu++17",
12 | "intelliSenseMode": "linux-gcc-arm",
13 | "configurationProvider": "ms-vscode.cmake-tools"
14 | }
15 | ],
16 | "version": 4
17 | }
--------------------------------------------------------------------------------
/internal/ota/errors.go:
--------------------------------------------------------------------------------
1 | package ota
2 |
3 | import (
4 | "errors"
5 | "fmt"
6 |
7 | "github.com/rs/zerolog"
8 | )
9 |
10 | var (
11 | // ErrVersionNotFound is returned when the specified version is not found
12 | ErrVersionNotFound = errors.New("specified version not found")
13 | )
14 |
15 | func (s *State) componentUpdateError(prefix string, err error, l *zerolog.Logger) error {
16 | if l == nil {
17 | l = s.l
18 | }
19 | l.Error().Err(err).Msg(prefix)
20 | s.error = fmt.Sprintf("%s: %v", prefix, err)
21 | s.updating = false
22 | s.triggerStateUpdate()
23 | return err
24 | }
25 |
--------------------------------------------------------------------------------
/Dockerfile.build:
--------------------------------------------------------------------------------
1 | # syntax=docker/dockerfile:1
2 | FROM --platform=${BUILDPLATFORM} golang:1.25.1-trixie AS builder
3 |
4 | ENV GOTOOLCHAIN=local
5 | ENV GOPATH=/go
6 | ENV PATH=$GOPATH/bin:/usr/local/go/bin:$PATH
7 |
8 | COPY install-deps.sh /install-deps.sh
9 | RUN /install-deps.sh
10 |
11 | # Create build directory
12 | RUN mkdir -p /build/
13 |
14 | # Copy go.mod and go.sum
15 | COPY go.mod go.sum /build/
16 |
17 | WORKDIR /build
18 |
19 | RUN go mod download && go mod verify
20 |
21 | COPY entrypoint.sh /entrypoint.sh
22 | RUN chmod +x /entrypoint.sh
23 |
24 | ENTRYPOINT [ "/entrypoint.sh" ]
--------------------------------------------------------------------------------
/ui/src/components/ExtLink.tsx:
--------------------------------------------------------------------------------
1 | import React from "react";
2 |
3 | import { cx } from "@/cva.config";
4 |
5 | export default function ExtLink({
6 | className,
7 | href,
8 | id,
9 | target,
10 | children,
11 | }: {
12 | className?: string;
13 | href: string;
14 | id?: string;
15 | target?: string;
16 | children: React.ReactNode;
17 | }) {
18 | return (
19 |
26 | {children}
27 |
28 | );
29 | }
30 |
--------------------------------------------------------------------------------
/internal/native/eez/src/ui/images.c:
--------------------------------------------------------------------------------
1 | #include "images.h"
2 |
3 | const ext_img_desc_t images[14] = {
4 | { "logo", &img_logo },
5 | { "boot-logo-2", &img_boot_logo_2 },
6 | { "arrow-icon", &img_arrow_icon },
7 | { "back-caret", &img_back_caret },
8 | { "back-icon", &img_back_icon },
9 | { "check-icon", &img_check_icon },
10 | { "cloud_disconnected", &img_cloud_disconnected },
11 | { "cloud", &img_cloud },
12 | { "d2", &img_d2 },
13 | { "ethernet", &img_ethernet },
14 | { "hdmi", &img_hdmi },
15 | { "jetkvm", &img_jetkvm },
16 | { "usb", &img_usb },
17 | { "x-icon", &img_x_icon },
18 | };
19 |
--------------------------------------------------------------------------------
/mdns.go:
--------------------------------------------------------------------------------
1 | package kvm
2 |
3 | import (
4 | "fmt"
5 |
6 | "github.com/jetkvm/kvm/internal/mdns"
7 | )
8 |
9 | var mDNS *mdns.MDNS
10 |
11 | func initMdns() error {
12 | options := getMdnsOptions()
13 | if options == nil {
14 | return fmt.Errorf("failed to get mDNS options")
15 | }
16 |
17 | m, err := mdns.NewMDNS(&mdns.MDNSOptions{
18 | Logger: logger,
19 | LocalNames: options.LocalNames,
20 | ListenOptions: options.ListenOptions,
21 | })
22 | if err != nil {
23 | return err
24 | }
25 |
26 | // do not start the server yet, as we need to wait for the network state to be set
27 | mDNS = m
28 |
29 | return nil
30 | }
31 |
--------------------------------------------------------------------------------
/ui/src/assets/detach-icon.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/ui/src/assets/pointing-finger.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/internal/sync/waitgroup.go:
--------------------------------------------------------------------------------
1 | //go:build synctrace
2 |
3 | package sync
4 |
5 | import (
6 | gosync "sync"
7 | )
8 |
9 | // WaitGroup is a wrapper around the sync.WaitGroup
10 | type WaitGroup struct {
11 | wg gosync.WaitGroup
12 | }
13 |
14 | // Add adds a function to the wait group
15 | func (w *WaitGroup) Add(delta int) {
16 | logTrace("Adding to wait group")
17 | w.wg.Add(delta)
18 | }
19 |
20 | // Done decrements the wait group counter
21 | func (w *WaitGroup) Done() {
22 | logTrace("Done with wait group")
23 | w.wg.Done()
24 | }
25 |
26 | // Wait waits for the wait group to finish
27 | func (w *WaitGroup) Wait() {
28 | logTrace("Waiting for wait group")
29 | w.wg.Wait()
30 | }
31 |
--------------------------------------------------------------------------------
/ui/src/components/NotFoundPage.tsx:
--------------------------------------------------------------------------------
1 | import { ExclamationTriangleIcon } from "@heroicons/react/24/outline";
2 |
3 | import EmptyCard from "@components/EmptyCard";
4 | import { m } from "@localizations/messages.js";
5 |
6 | export default function NotFoundPage() {
7 | return (
8 |
9 |
19 | );
20 | }
21 |
--------------------------------------------------------------------------------
/ui/src/components/CardHeader.tsx:
--------------------------------------------------------------------------------
1 | import React from "react";
2 |
3 | interface Props {
4 | headline: string;
5 | description?: string | React.ReactNode;
6 | Button?: React.ReactNode;
7 | }
8 |
9 | export const CardHeader = ({ headline, description, Button }: Props) => {
10 | return (
11 |
10 |
18 |
11 |
17 |
12 |
18 | );
19 | };
20 |
--------------------------------------------------------------------------------
/ui/src/components/SettingsPageheader.tsx:
--------------------------------------------------------------------------------
1 | import { ReactNode } from "react";
2 |
3 | export function SettingsPageHeader({
4 | title,
5 | description,
6 | action,
7 | }: {
8 | title: string | ReactNode;
9 | description: string | ReactNode;
10 | action?: ReactNode;
11 | }) {
12 | return (
13 |
13 |
16 | {Button && {headline}
14 | {description &&{description}
}
15 | {Button}
}
17 |
14 |
20 | );
21 | }
--------------------------------------------------------------------------------
/ui/src/ui.config.ts:
--------------------------------------------------------------------------------
1 | const toBoolean = (value: string | undefined) => {
2 | if (!value) return false;
3 | return ["1", "true", "yes", "y"].includes(value.toLowerCase().trim());
4 | }
5 | export const CLOUD_API = import.meta.env.VITE_CLOUD_API;
6 |
7 | export const CLOUD_BACKWARDS_COMPATIBLE_VERSION = import.meta.env.VITE_CLOUD_BACKWARDS_COMPATIBLE_VERSION || "0.5.0";
8 |
9 | export const CLOUD_ENABLE_VERSIONED_UI = toBoolean(import.meta.env.VITE_CLOUD_ENABLE_VERSIONED_UI);
10 |
11 | export const DOWNGRADE_VERSION = import.meta.env.VITE_DOWNGRADE_VERSION || "0.4.8";
12 |
13 | // In device mode, an empty string uses the current hostname (the JetKVM device's IP) as the API endpoint
14 | export const DEVICE_API = "";
15 |
--------------------------------------------------------------------------------
/internal/logging/utils.go:
--------------------------------------------------------------------------------
1 | package logging
2 |
3 | import (
4 | "fmt"
5 | "os"
6 |
7 | "github.com/rs/zerolog"
8 | )
9 |
10 | var defaultLogger = zerolog.New(os.Stdout).Level(zerolog.InfoLevel)
11 |
12 | func GetDefaultLogger() *zerolog.Logger {
13 | return &defaultLogger
14 | }
15 |
16 | func ErrorfL(l *zerolog.Logger, format string, err error, args ...any) error {
17 | // TODO: move rootLogger to logging package
18 | if l == nil {
19 | l = &defaultLogger
20 | }
21 |
22 | l.Error().Err(err).Msgf(format, args...)
23 |
24 | if err == nil {
25 | return fmt.Errorf(format, args...)
26 | }
27 |
28 | err_msg := err.Error() + ": %v"
29 | err_args := append(args, err)
30 |
31 | return fmt.Errorf(err_msg, err_args...)
32 | }
33 |
--------------------------------------------------------------------------------
/internal/supervisor/consts.go:
--------------------------------------------------------------------------------
1 | package supervisor
2 |
3 | const (
4 | EnvChildID = "JETKVM_CHILD_ID" // The child ID is the version of the app that is running
5 | EnvSubcomponent = "JETKVM_SUBCOMPONENT" // The subcomponent is the component that is running
6 | ErrorDumpDir = "/userdata/jetkvm/crashdump" // The error dump directory is the directory where the error dumps are stored
7 | ErrorDumpLastFile = "last-crash.log" // The error dump last file is the last error dump file
8 | ErrorDumpTemplate = "jetkvm-%s.log" // The error dump template is the template for the error dump file
9 |
10 | FailsafeReasonVideoMaxRestartAttemptsReached = "failsafe::video.max_restart_attempts_reached"
11 | )
12 |
--------------------------------------------------------------------------------
/ui/src/components/Container.tsx:
--------------------------------------------------------------------------------
1 | /* eslint-disable react-refresh/only-export-components */
2 | import React, { ReactNode } from "react";
3 |
4 | import { cx } from "@/cva.config";
5 |
6 | function Container({ children, className }: { children: ReactNode; className?: string }) {
7 | return
15 |
18 | {action && {title}
16 |{description}
17 | {action}
}
19 | {children}
;
8 | }
9 |
10 | function Article({ children }: { children: React.ReactNode }) {
11 | return (
12 |
14 |
16 | {children}
15 |
22 |
27 | 24 | {getReasonMessage()} 25 |
26 |
13 |
14 |
24 |
25 | );
26 | }
27 |
--------------------------------------------------------------------------------
/ui/src/components/CustomTooltip.tsx:
--------------------------------------------------------------------------------
1 | import Card from "@components/Card";
2 |
3 | export interface CustomTooltipProps {
4 | payload: { payload: { date: number; metric: number }; unit: string }[];
5 | }
6 |
7 | export default function CustomTooltip({ payload }: CustomTooltipProps) {
8 | if (payload?.length) {
9 | const toolTipData = payload[0];
10 | const { date, metric } = toolTipData.payload;
11 |
12 | return (
13 |
15 |
23 |
16 |
17 | 
18 | 
19 |
20 |
22 | {actionElement}
21 |
15 |
27 |
16 | {new Date(date * 1000).toLocaleTimeString()}
17 |
18 |
19 |
26 |
20 |
21 |
22 | {metric} {toolTipData?.unit}
23 |
24 |
25 |
20 |
21 |
22 |
24 | {children}
23 |
37 | {children}
38 |
39 | );
40 | });
41 |
42 | Card.displayName = "Card";
43 |
44 | export default Card;
45 |
--------------------------------------------------------------------------------
/ui/src/components/GridBackground.tsx:
--------------------------------------------------------------------------------
1 | export default function GridBackground() {
2 | return (
3 |
4 |
39 |
40 | );
41 | }
42 |
--------------------------------------------------------------------------------
/scripts/generate_proto.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | # Generate gRPC code from proto files
3 |
4 | set -e
5 |
6 | SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
7 | PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
8 |
9 | cd "$PROJECT_ROOT"
10 |
11 | # Check if protoc is installed
12 | if ! command -v protoc &> /dev/null; then
13 | echo "Error: protoc is not installed"
14 | echo "Install it with:"
15 | echo " apt-get install protobuf-compiler # Debian/Ubuntu"
16 | echo " brew install protobuf # macOS"
17 | exit 1
18 | fi
19 |
20 | # Check if protoc-gen-go is installed
21 | if ! command -v protoc-gen-go &> /dev/null; then
22 | echo "Error: protoc-gen-go is not installed"
23 | echo "Install it with: go install google.golang.org/protobuf/cmd/protoc-gen-go@latest"
24 | exit 1
25 | fi
26 |
27 | # Check if protoc-gen-go-grpc is installed
28 | if ! command -v protoc-gen-go-grpc &> /dev/null; then
29 | echo "Error: protoc-gen-go-grpc is not installed"
30 | echo "Install it with: go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest"
31 | exit 1
32 | fi
33 |
34 | # Generate code
35 | echo "Generating gRPC code from proto files..."
36 | protoc \
37 | --go_out=. \
38 | --go_opt=paths=source_relative \
39 | --go-grpc_out=. \
40 | --go-grpc_opt=paths=source_relative \
41 | internal/native/proto/native.proto
42 |
43 | echo "Done!"
44 |
45 |
--------------------------------------------------------------------------------
/ui/src/components/EmptyCard.tsx:
--------------------------------------------------------------------------------
1 | import React from "react";
2 |
3 | import { GridCard } from "@components/Card";
4 | import { cx } from "@/cva.config";
5 |
6 | interface Props {
7 | IconElm?: React.FC<{ className: string | undefined }>;
8 | headline: string;
9 | description?: string | React.ReactNode;
10 | BtnElm?: React.ReactNode;
11 | className?: string;
12 | }
13 |
14 | export default function EmptyCard({
15 | IconElm,
16 | headline,
17 | description,
18 | BtnElm,
19 | className,
20 | }: Props) {
21 | return (
22 |
29 |
44 |
30 |
42 | {BtnElm}
43 |
31 | {IconElm && (
32 |
38 | 35 | {headline} 36 |
37 |39 | {description} 40 |
41 |
22 | {Icon ? (
23 |
24 |
45 | );
46 | }
47 |
--------------------------------------------------------------------------------
/scripts/build_cgo.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | set -e
3 |
4 | SCRIPT_PATH=$(realpath "$(dirname $(realpath "${BASH_SOURCE[0]}"))")
5 | source ${SCRIPT_PATH}/build_utils.sh
6 |
7 | CMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE:-Release}
8 |
9 | CGO_PATH=$(realpath "${SCRIPT_PATH}/../internal/native/cgo")
10 | BUILD_DIR=${CGO_PATH}/build
11 |
12 | CMAKE_TOOLCHAIN_FILE=/opt/jetkvm-native-buildkit/rv1106-jetkvm-v2.cmake
13 | CLEAN_ALL=${CLEAN_ALL:-0}
14 |
15 | if [ "$CLEAN_ALL" -eq 1 ]; then
16 | rm -rf "${BUILD_DIR}"
17 | fi
18 |
19 | TMP_DIR=$(mktemp -d)
20 | pushd "${CGO_PATH}" > /dev/null
21 |
22 | msg_info "▶ Generating UI index"
23 | ./ui_index.gen.sh
24 |
25 | msg_info "▶ Building native library"
26 | VERBOSE=1 cmake -B "${BUILD_DIR}" \
27 | -DCMAKE_SYSTEM_PROCESSOR=armv7l \
28 | -DCMAKE_SYSTEM_NAME=Linux \
29 | -DCMAKE_CROSSCOMPILING=1 \
30 | -DCMAKE_TOOLCHAIN_FILE=$CMAKE_TOOLCHAIN_FILE \
31 | -DLV_BUILD_USE_KCONFIG=ON \
32 | -DLV_BUILD_DEFCONFIG_PATH=${CGO_PATH}/lvgl_defconfig \
33 | -DCONFIG_LV_BUILD_EXAMPLES=OFF \
34 | -DCONFIG_LV_BUILD_DEMOS=OFF \
35 | -DSKIP_GLIBC_NAMES=ON \
36 | -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} \
37 | -DCMAKE_INSTALL_PREFIX="${TMP_DIR}"
38 |
39 | msg_info "▶ Copying built library and header files"
40 | cmake --build "${BUILD_DIR}" --target install
41 | cp -r "${TMP_DIR}/include" "${CGO_PATH}"
42 | cp -r "${TMP_DIR}/lib" "${CGO_PATH}"
43 | rm -rf "${TMP_DIR}"
44 |
45 | popd > /dev/null
46 |
--------------------------------------------------------------------------------
/ui/public/favicon.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/internal/native/cgo/screen.h:
--------------------------------------------------------------------------------
1 | #ifndef SCREEN_H
2 | #define SCREEN_H
3 |
4 | #include
29 |
44 |
30 | {title}
31 |
32 |
33 |
43 |
34 |
40 | {status}
41 |
42 |
39 |
40 | {label}
41 |
42 | {description && (
43 |
44 | {description}
45 |
46 | )}
47 |
48 | );
49 | } else {
50 | return <>;
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/dc_metrics.go:
--------------------------------------------------------------------------------
1 | package kvm
2 |
3 | import (
4 | "sync"
5 |
6 | "github.com/prometheus/client_golang/prometheus"
7 | )
8 |
9 | var (
10 | dcCurrentGauge = prometheus.NewGauge(prometheus.GaugeOpts{
11 | Name: "jetkvm_dc_current_amperes",
12 | Help: "Current DC power consumption in amperes",
13 | })
14 |
15 | dcPowerGauge = prometheus.NewGauge(prometheus.GaugeOpts{
16 | Name: "jetkvm_dc_power_watts",
17 | Help: "DC power consumption in watts",
18 | })
19 |
20 | dcVoltageGauge = prometheus.NewGauge(prometheus.GaugeOpts{
21 | Name: "jetkvm_dc_voltage_volts",
22 | Help: "DC voltage in volts",
23 | })
24 |
25 | dcStateGauge = prometheus.NewGauge(prometheus.GaugeOpts{
26 | Name: "jetkvm_dc_power_state",
27 | Help: "DC power state (1 = on, 0 = off)",
28 | })
29 |
30 | dcMetricsRegistered sync.Once
31 | )
32 |
33 | // registerDCMetrics registers the DC power metrics with Prometheus (called once when DC control is mounted)
34 | func registerDCMetrics() {
35 | dcMetricsRegistered.Do(func() {
36 | prometheus.MustRegister(dcCurrentGauge)
37 | prometheus.MustRegister(dcPowerGauge)
38 | prometheus.MustRegister(dcVoltageGauge)
39 | prometheus.MustRegister(dcStateGauge)
40 | })
41 | }
42 |
43 | // updateDCMetrics updates the Prometheus metrics with current DC power state values
44 | func updateDCMetrics(state DCPowerState) {
45 | dcCurrentGauge.Set(state.Current)
46 | dcPowerGauge.Set(state.Power)
47 | dcVoltageGauge.Set(state.Voltage)
48 | if state.IsOn {
49 | dcStateGauge.Set(1)
50 | } else {
51 | dcStateGauge.Set(0)
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/ui/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "compilerOptions": {
3 | "target": "ES2020",
4 | "useDefineForClassFields": true,
5 | "forceConsistentCasingInFileNames": true,
6 | "lib": [
7 | "ES2021",
8 | "DOM",
9 | "DOM.Iterable"
10 | ],
11 | "module": "ESNext",
12 | "skipLibCheck": true,
13 | "allowJs": true,
14 | /* Bundler mode */
15 | "moduleResolution": "bundler",
16 | "allowImportingTsExtensions": false,
17 | "resolveJsonModule": true,
18 | "isolatedModules": true,
19 | "noEmit": true,
20 | "jsx": "react-jsx",
21 | /* Linting */
22 | "strict": true,
23 | "noUnusedLocals": true,
24 | "noUnusedParameters": true,
25 | "noFallthroughCasesInSwitch": true,
26 | "erasableSyntaxOnly": true,
27 | "noUncheckedSideEffectImports": true,
28 | "types": [
29 | "vite/client"
30 | ],
31 | /* Import Aliases */
32 | "paths": {
33 | "@components/*": [
34 | "./src/components/*"
35 | ],
36 | "@routes/*": [
37 | "./src/routes/*"
38 | ],
39 | "@hooks/*": [
40 | "./src/hooks/*"
41 | ],
42 | "@providers/*": [
43 | "./src/providers/*"
44 | ],
45 | "@assets/*": [
46 | "./src/assets/*"
47 | ],
48 | "@localizations/*": [
49 | "./localization/paraglide/*"
50 | ],
51 | "@/*": [
52 | "./src/*"
53 | ]
54 | }
55 | },
56 | "include": [
57 | "src"
58 | ],
59 | "references": [
60 | {
61 | "path": "./tsconfig.node.json"
62 | }
63 | ]
64 | }
--------------------------------------------------------------------------------
/ui/src/keyboardLayouts.ts:
--------------------------------------------------------------------------------
1 | export interface KeyStroke { modifier: number; keys: number[]; }
2 | export interface KeyInfo { key: string | number; shift?: boolean, altRight?: boolean }
3 | export interface KeyCombo extends KeyInfo { deadKey?: boolean, accentKey?: KeyInfo }
4 | export interface KeyboardLayout {
5 | isoCode: string;
6 | name: string;
7 | chars: Record
30 |
46 |
31 |
33 |
34 | {macros.map(macro => (
35 |
45 |
13 |
15 |
38 |
39 |
40 | );
41 | }
42 |
--------------------------------------------------------------------------------
/timesync.go:
--------------------------------------------------------------------------------
1 | package kvm
2 |
3 | import (
4 | "strconv"
5 | "time"
6 |
7 | "github.com/jetkvm/kvm/internal/timesync"
8 | )
9 |
10 | var (
11 | timeSync *timesync.TimeSync
12 | builtTimestamp string
13 | )
14 |
15 | func isTimeSyncNeeded() bool {
16 | if builtTimestamp == "" {
17 | timesyncLogger.Warn().Msg("built timestamp is not set, time sync is needed")
18 | return true
19 | }
20 |
21 | ts, err := strconv.Atoi(builtTimestamp)
22 | if err != nil {
23 | timesyncLogger.Warn().Str("error", err.Error()).Msg("failed to parse built timestamp")
24 | return true
25 | }
26 |
27 | // builtTimestamp is UNIX timestamp in seconds
28 | builtTime := time.Unix(int64(ts), 0)
29 | now := time.Now()
30 |
31 | if now.Sub(builtTime) < 0 {
32 | timesyncLogger.Warn().
33 | Str("built_time", builtTime.Format(time.RFC3339)).
34 | Str("now", now.Format(time.RFC3339)).
35 | Msg("system time is behind the built time, time sync is needed")
36 | return true
37 | }
38 |
39 | return false
40 | }
41 |
42 | func initTimeSync() {
43 | timeSync = timesync.NewTimeSync(×ync.TimeSyncOptions{
44 | Logger: timesyncLogger,
45 | NetworkConfig: config.NetworkConfig,
46 | PreCheckIPv4: func() (bool, error) {
47 | if !networkManager.IPv4Ready() {
48 | return false, nil
49 | }
50 | return true, nil
51 | },
52 | PreCheckIPv6: func() (bool, error) {
53 | if !networkManager.IPv6Ready() {
54 | return false, nil
55 | }
56 | return true, nil
57 | },
58 | PreCheckFunc: func() (bool, error) {
59 | if !networkManager.IsOnline() {
60 | return false, nil
61 | }
62 | return true, nil
63 | },
64 | })
65 | }
66 |
--------------------------------------------------------------------------------
/internal/native/interface.go:
--------------------------------------------------------------------------------
1 | package native
2 |
3 | // NativeInterface defines the interface that both Native and NativeProxy implement
4 | type NativeInterface interface {
5 | Start() error
6 | VideoSetSleepMode(enabled bool) error
7 | VideoGetSleepMode() (bool, error)
8 | VideoSleepModeSupported() bool
9 | VideoSetQualityFactor(factor float64) error
10 | VideoGetQualityFactor() (float64, error)
11 | VideoSetEDID(edid string) error
12 | VideoGetEDID() (string, error)
13 | VideoLogStatus() (string, error)
14 | VideoStop() error
15 | VideoStart() error
16 | GetLVGLVersion() (string, error)
17 | UIObjHide(objName string) (bool, error)
18 | UIObjShow(objName string) (bool, error)
19 | UISetVar(name string, value string)
20 | UIGetVar(name string) string
21 | UIObjAddState(objName string, state string) (bool, error)
22 | UIObjClearState(objName string, state string) (bool, error)
23 | UIObjAddFlag(objName string, flag string) (bool, error)
24 | UIObjClearFlag(objName string, flag string) (bool, error)
25 | UIObjSetOpacity(objName string, opacity int) (bool, error)
26 | UIObjFadeIn(objName string, duration uint32) (bool, error)
27 | UIObjFadeOut(objName string, duration uint32) (bool, error)
28 | UIObjSetLabelText(objName string, text string) (bool, error)
29 | UIObjSetImageSrc(objName string, image string) (bool, error)
30 | DisplaySetRotation(rotation uint16) (bool, error)
31 | UpdateLabelIfChanged(objName string, newText string)
32 | UpdateLabelAndChangeVisibility(objName string, newText string)
33 | SwitchToScreenIf(screenName string, shouldSwitch []string)
34 | SwitchToScreenIfDifferent(screenName string)
35 | DoNotUseThisIsForCrashTestingOnly()
36 | }
37 |
--------------------------------------------------------------------------------
/internal/tzdata/gen.go:
--------------------------------------------------------------------------------
1 | //go:build ignore
2 |
3 | package main
4 |
5 | import (
6 | "archive/zip"
7 | "bytes"
8 | "flag"
9 | "fmt"
10 | "os"
11 | "text/template"
12 | )
13 |
14 | var tmpl = `// Code generated by "go run gen.go". DO NOT EDIT.
15 | //go:generate env ZONEINFO=$GOROOT/lib/time/zoneinfo.zip go run gen.go -output tzdata.go
16 | package tzdata
17 | var TimeZones = []string{
18 | {{- range . }}
19 | "{{.}}",
20 | {{- end }}
21 | }
22 | `
23 |
24 | var filename = flag.String("output", "tzdata.go", "output file name")
25 |
26 | func main() {
27 | flag.Parse()
28 |
29 | path := os.Getenv("ZONEINFO")
30 | if path == "" {
31 | fmt.Println("ZONEINFO is not set")
32 | os.Exit(1)
33 | }
34 |
35 | if _, err := os.Stat(path); os.IsNotExist(err) {
36 | fmt.Printf("ZONEINFO %s does not exist\n", path)
37 | os.Exit(1)
38 | }
39 |
40 | zipfile, err := zip.OpenReader(path)
41 | if err != nil {
42 | fmt.Printf("Error opening ZONEINFO %s: %v\n", path, err)
43 | os.Exit(1)
44 | }
45 | defer zipfile.Close()
46 |
47 | timezones := []string{}
48 |
49 | for _, file := range zipfile.File {
50 | timezones = append(timezones, file.Name)
51 | }
52 |
53 | var buf bytes.Buffer
54 |
55 | tmpl, err := template.New("tzdata").Parse(tmpl)
56 | if err != nil {
57 | fmt.Printf("Error parsing template: %v\n", err)
58 | os.Exit(1)
59 | }
60 |
61 | err = tmpl.Execute(&buf, timezones)
62 | if err != nil {
63 | fmt.Printf("Error executing template: %v\n", err)
64 | os.Exit(1)
65 | }
66 |
67 | err = os.WriteFile(*filename, buf.Bytes(), 0644)
68 | if err != nil {
69 | fmt.Printf("Error writing file %s: %v\n", *filename, err)
70 | os.Exit(1)
71 | }
72 | }
73 |
--------------------------------------------------------------------------------
/internal/websecure/ed25519_test.go:
--------------------------------------------------------------------------------
1 | package websecure
2 |
3 | import (
4 | "os"
5 | "testing"
6 | )
7 |
8 | var (
9 | fixtureEd25519Certificate = `-----BEGIN CERTIFICATE-----
10 | MIIBQDCB86ADAgECAhQdB4qB6dV0/u1lwhJofQgkmjjV1zAFBgMrZXAwLzELMAkG
11 | A1UEBhMCREUxIDAeBgNVBAMMF2VkMjU1MTktdGVzdC5qZXRrdm0uY29tMB4XDTI1
12 | MDUyMzEyNTkyN1oXDTI3MDQyMzEyNTkyN1owLzELMAkGA1UEBhMCREUxIDAeBgNV
13 | BAMMF2VkMjU1MTktdGVzdC5qZXRrdm0uY29tMCowBQYDK2VwAyEA9tLyoulJn7Ev
14 | bf8kuD1ZGdA092773pCRjFEDKpXHonyjITAfMB0GA1UdDgQWBBRkmrVMfsLY57iy
15 | r/0POP0S4QxCADAFBgMrZXADQQBfTRvqavLHDYQiKQTgbGod+Yn+fIq2lE584+1U
16 | C4wh9peIJDFocLBEAYTQpEMKxa4s0AIRxD+a7aCS5oz0e/0I
17 | -----END CERTIFICATE-----`
18 |
19 | fixtureEd25519PrivateKey = `-----BEGIN PRIVATE KEY-----
20 | MC4CAQAwBQYDK2VwBCIEIKV08xUsLRHBfMXqZwxVRzIbViOp8G7aQGjPvoRFjujB
21 | -----END PRIVATE KEY-----`
22 |
23 | certStore *CertStore
24 | certSigner *SelfSigner
25 | )
26 |
27 | func TestMain(m *testing.M) {
28 | tlsStorePath, err := os.MkdirTemp("", "jktls.*")
29 | if err != nil {
30 | defaultLogger.Fatal().Err(err).Msg("failed to create temp directory")
31 | }
32 |
33 | certStore = NewCertStore(tlsStorePath, nil)
34 | certStore.LoadCertificates()
35 |
36 | certSigner = NewSelfSigner(
37 | certStore,
38 | nil,
39 | "ci.jetkvm.com",
40 | "JetKVM",
41 | "JetKVM",
42 | "JetKVM",
43 | )
44 |
45 | m.Run()
46 |
47 | os.RemoveAll(tlsStorePath)
48 | }
49 |
50 | func TestSaveEd25519Certificate(t *testing.T) {
51 | err, _ := certStore.ValidateAndSaveCertificate("ed25519-test.jetkvm.com", fixtureEd25519Certificate, fixtureEd25519PrivateKey, true)
52 | if err != nil {
53 | t.Fatalf("failed to save certificate: %v", err)
54 | }
55 | }
56 |
--------------------------------------------------------------------------------
/pkg/nmlite/link/sysctl.go:
--------------------------------------------------------------------------------
1 | package link
2 |
3 | import (
4 | "fmt"
5 | "os"
6 | "path"
7 | "strconv"
8 | "strings"
9 | )
10 |
11 | func (nm *NetlinkManager) setSysctlValues(ifaceName string, values map[string]int) error {
12 | for name, value := range values {
13 | name = fmt.Sprintf(name, ifaceName)
14 | name = strings.ReplaceAll(name, ".", "/")
15 |
16 | if err := os.WriteFile(path.Join(sysctlBase, name), []byte(strconv.Itoa(value)), sysctlFileMode); err != nil {
17 | return fmt.Errorf("failed to set sysctl %s=%d: %w", name, value, err)
18 | }
19 | }
20 | return nil
21 | }
22 |
23 | // EnableIPv6 enables IPv6 on the interface
24 | func (nm *NetlinkManager) EnableIPv6(ifaceName string) error {
25 | return nm.setSysctlValues(ifaceName, map[string]int{
26 | "net.ipv6.conf.%s.disable_ipv6": 0,
27 | "net.ipv6.conf.%s.accept_ra": 2,
28 | })
29 | }
30 |
31 | // DisableIPv6 disables IPv6 on the interface
32 | func (nm *NetlinkManager) DisableIPv6(ifaceName string) error {
33 | return nm.setSysctlValues(ifaceName, map[string]int{
34 | "net.ipv6.conf.%s.disable_ipv6": 1,
35 | })
36 | }
37 |
38 | // EnableIPv6SLAAC enables IPv6 SLAAC on the interface
39 | func (nm *NetlinkManager) EnableIPv6SLAAC(ifaceName string) error {
40 | return nm.setSysctlValues(ifaceName, map[string]int{
41 | "net.ipv6.conf.%s.disable_ipv6": 0,
42 | "net.ipv6.conf.%s.accept_ra": 2,
43 | })
44 | }
45 |
46 | // EnableIPv6LinkLocal enables IPv6 link-local only on the interface
47 | func (nm *NetlinkManager) EnableIPv6LinkLocal(ifaceName string) error {
48 | return nm.setSysctlValues(ifaceName, map[string]int{
49 | "net.ipv6.conf.%s.disable_ipv6": 0,
50 | "net.ipv6.conf.%s.accept_ra": 0,
51 | })
52 | }
53 |
--------------------------------------------------------------------------------
/ui/src/hooks/useKeyboardLayout.ts:
--------------------------------------------------------------------------------
1 | import { useMemo } from "react";
2 |
3 | import { useSettingsStore } from "@/hooks/stores";
4 | import { keyboards } from "@/keyboardLayouts";
5 |
6 | export default function useKeyboardLayout() {
7 | const { keyboardLayout } = useSettingsStore();
8 |
9 | const keyboardOptions = useMemo(() => {
10 | return keyboards.map((keyboard) => {
11 | return { label: keyboard.name, value: keyboard.isoCode }
12 | });
13 | }, []);
14 |
15 | const isoCode = useMemo(() => {
16 | // If we don't have a specific layout, default to "en-US" because that was the original layout
17 | // developed so it is a good fallback. Additionally, we replace "en_US" with "en-US" because
18 | // the original server-side code used "en_US" as the default value, but that's not the correct
19 | // ISO code for English/United State. To ensure we remain backward compatible with devices that
20 | // have not had their Keyboard Layout selected by the user, we want to treat "en_US" as if it was
21 | // "en-US" to match the ISO standard codes now used in the keyboardLayouts.
22 | console.debug("Current keyboard layout from store:", keyboardLayout);
23 | if (keyboardLayout && keyboardLayout.length > 0)
24 | return keyboardLayout.replace("en_US", "en-US");
25 | return "en-US";
26 | }, [keyboardLayout]);
27 |
28 | const selectedKeyboard = useMemo(() => {
29 | // fallback to original behaviour of en-US if no isoCode given or matching layout not found
30 | return keyboards.find(keyboard => keyboard.isoCode === isoCode)
31 | ?? keyboards.find(keyboard => keyboard.isoCode === "en-US")!;
32 | }, [isoCode]);
33 |
34 | return { keyboardOptions, isoCode, selectedKeyboard };
35 | }
--------------------------------------------------------------------------------
/internal/utils/env_test.go:
--------------------------------------------------------------------------------
1 | package utils
2 |
3 | import (
4 | "reflect"
5 | "testing"
6 |
7 | "github.com/Masterminds/semver/v3"
8 | )
9 |
10 | type nativeOptions struct {
11 | Disable bool `env:"JETKVM_NATIVE_DISABLE"`
12 | SystemVersion *semver.Version `env:"JETKVM_NATIVE_SYSTEM_VERSION"`
13 | AppVersion *semver.Version `env:"JETKVM_NATIVE_APP_VERSION"`
14 | DisplayRotation uint16 `env:"JETKVM_NATIVE_DISPLAY_ROTATION"`
15 | DefaultQualityFactor float64 `env:"JETKVM_NATIVE_DEFAULT_QUALITY_FACTOR"`
16 | }
17 |
18 | func TestMarshalEnv(t *testing.T) {
19 | tests := []struct {
20 | name string
21 | instance interface{}
22 | want []string
23 | wantErr bool
24 | }{
25 | {
26 | name: "basic struct",
27 | instance: nativeOptions{
28 | Disable: false,
29 | SystemVersion: semver.MustParse("1.1.0"),
30 | AppVersion: semver.MustParse("1111.0.0"),
31 | DisplayRotation: 1,
32 | DefaultQualityFactor: 1.0,
33 | },
34 | want: []string{
35 | "JETKVM_NATIVE_DISABLE=false",
36 | "JETKVM_NATIVE_SYSTEM_VERSION=1.1.0",
37 | "JETKVM_NATIVE_APP_VERSION=1111.0.0",
38 | "JETKVM_NATIVE_DISPLAY_ROTATION=1",
39 | "JETKVM_NATIVE_DEFAULT_QUALITY_FACTOR=1",
40 | },
41 | wantErr: false,
42 | },
43 | }
44 |
45 | for _, tt := range tests {
46 | t.Run(tt.name, func(t *testing.T) {
47 | got, err := MarshalEnv(tt.instance)
48 | if (err != nil) != tt.wantErr {
49 | t.Errorf("MarshalEnv() error = %v, wantErr %v", err, tt.wantErr)
50 | return
51 | }
52 | if !reflect.DeepEqual(got, tt.want) {
53 | t.Errorf("MarshalEnv() = %v, want %v", got, tt.want)
54 | }
55 | })
56 | }
57 | }
58 |
--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/feature.yml:
--------------------------------------------------------------------------------
1 | name: Feature
2 | type: 'Feature'
3 | description: 🚀 Request a new feature.
4 | labels:
5 | - 'type: feature'
6 | body:
7 | - type: textarea
8 | attributes:
9 | label: A note for the community
10 | value: |
11 | > [!NOTE]
12 | > Please vote on this issue by adding a 👍 [reaction](https://blog.github.com/2016-03-10-add-reactions-to-pull-requests-issues-and-comments/) to the original issue to help the community and maintainers prioritize this request.
13 | validations:
14 | required: true
15 | - type: checkboxes
16 | attributes:
17 | label: Disclaimer
18 | description: |
19 | Before requesting a feature, check it does not already exist in the [documentation](https://jetkvm.com/docs) or our [roadmap](https://jetkvm.com/roadmap).
20 | You are quite welcome opening a feature request before spending time to implement it yourself.
21 | options:
22 | - label: I have read and understood the disclaimer.
23 | required: true
24 | - label: I plan to implement the feature myself.
25 | - type: dropdown
26 | attributes:
27 | label: Subsystem
28 | description: Provide the subsystem of the feature you request, you can choose multiple if you think it fits in multiple areas.
29 | options:
30 | - Hardware
31 | - Device Compatibility
32 | - Keyboard
33 | - Mouse
34 | - Power
35 | - UI: Screen
36 | - UI: Application
37 | - UI: Cloud
38 | validations:
39 | required: false
40 | - type: textarea
41 | attributes:
42 | label: Feature description
43 | description: |
44 | Provide a description of the feature you request.
45 | validations:
46 | required: true
--------------------------------------------------------------------------------
/ui/src/components/UpdateInProgressStatusCard.tsx:
--------------------------------------------------------------------------------
1 | import { cx } from "@/cva.config";
2 | import { useDeviceUiNavigation } from "@hooks/useAppNavigation";
3 | import { Button } from "@components/Button";
4 | import { GridCard } from "@components/Card";
5 | import LoadingSpinner from "@components/LoadingSpinner";
6 | import { m } from "@localizations/messages.js";
7 |
8 | export default function UpdateInProgressStatusCard() {
9 | const { navigateTo } = useDeviceUiNavigation();
10 |
11 | return (
12 |
16 |
37 |
17 |
36 |
18 |
26 |
27 | {m.already_adopted_title()}
19 |20 | {m.already_adopted_other_user()} 21 |
22 |23 | {m.already_adopted_new_owner()} 24 |
25 |
28 |
35 |
13 |
14 |
39 |
40 | );
41 | }
42 |
--------------------------------------------------------------------------------
/ui/src/components/SettingsItem.tsx:
--------------------------------------------------------------------------------
1 | import { cx } from "@/cva.config";
2 | import LoadingSpinner from "@components/LoadingSpinner";
3 |
4 | interface SettingsItemProps {
5 | readonly title: string;
6 | readonly description: string | React.ReactNode;
7 | readonly badge?: string;
8 | readonly badgeTheme?: keyof typeof badgeTheme;
9 | readonly className?: string;
10 | readonly loading?: boolean;
11 | readonly children?: React.ReactNode;
12 | }
13 |
14 | const badgeTheme = {
15 | info: "bg-blue-500 text-white",
16 | success: "bg-green-500 text-white",
17 | warning: "bg-yellow-500 text-white",
18 | danger: "bg-red-500 text-white",
19 | };
20 |
21 | export function SettingsItem(props: SettingsItemProps) {
22 | const { title, description, badge, badgeTheme: badgeThemeProp = "danger", children, className, loading } = props;
23 | const badgeThemeClass = badgeTheme[badgeThemeProp];
24 |
25 | return (
26 |
48 | );
49 | }
50 |
--------------------------------------------------------------------------------
/internal/logging/pion.go:
--------------------------------------------------------------------------------
1 | package logging
2 |
3 | import (
4 | "github.com/pion/logging"
5 | "github.com/rs/zerolog"
6 | )
7 |
8 | type pionLogger struct {
9 | logger *zerolog.Logger
10 | }
11 |
12 | // Print all messages except trace.
13 | func (c pionLogger) Trace(msg string) {
14 | c.logger.Trace().Msg(msg)
15 | }
16 | func (c pionLogger) Tracef(format string, args ...any) {
17 | c.logger.Trace().Msgf(format, args...)
18 | }
19 |
20 | func (c pionLogger) Debug(msg string) {
21 | c.logger.Debug().Msg(msg)
22 | }
23 | func (c pionLogger) Debugf(format string, args ...any) {
24 | c.logger.Debug().Msgf(format, args...)
25 | }
26 | func (c pionLogger) Info(msg string) {
27 | c.logger.Info().Msg(msg)
28 | }
29 | func (c pionLogger) Infof(format string, args ...any) {
30 | c.logger.Info().Msgf(format, args...)
31 | }
32 | func (c pionLogger) Warn(msg string) {
33 | c.logger.Warn().Msg(msg)
34 | }
35 | func (c pionLogger) Warnf(format string, args ...any) {
36 | c.logger.Warn().Msgf(format, args...)
37 | }
38 | func (c pionLogger) Error(msg string) {
39 | c.logger.Error().Msg(msg)
40 | }
41 | func (c pionLogger) Errorf(format string, args ...any) {
42 | c.logger.Error().Msgf(format, args...)
43 | }
44 |
45 | // customLoggerFactory satisfies the interface logging.LoggerFactory
46 | // This allows us to create different loggers per subsystem. So we can
47 | // add custom behavior.
48 | type pionLoggerFactory struct{}
49 |
50 | func (c pionLoggerFactory) NewLogger(subsystem string) logging.LeveledLogger {
51 | logger := rootLogger.getLogger(subsystem).With().
52 | Str("scope", "pion").
53 | Str("component", subsystem).
54 | Logger()
55 |
56 | return pionLogger{logger: &logger}
57 | }
58 |
59 | var defaultLoggerFactory = &pionLoggerFactory{}
60 |
61 | func GetPionDefaultLoggerFactory() logging.LoggerFactory {
62 | return defaultLoggerFactory
63 | }
64 |
--------------------------------------------------------------------------------
/pkg/nmlite/utils.go:
--------------------------------------------------------------------------------
1 | package nmlite
2 |
3 | import (
4 | "sort"
5 | "time"
6 |
7 | "github.com/jetkvm/kvm/internal/network/types"
8 | )
9 |
10 | func lifetimeToTime(lifetime int) *time.Time {
11 | if lifetime == 0 {
12 | return nil
13 | }
14 |
15 | // Check for infinite lifetime (0xFFFFFFFF = 4294967295)
16 | // This is used for static/permanent addresses
17 | // Use uint32 to avoid int overflow on 32-bit systems
18 | const infiniteLifetime uint32 = 0xFFFFFFFF
19 | if uint32(lifetime) == infiniteLifetime || lifetime < 0 {
20 | return nil // Infinite lifetime - no expiration
21 | }
22 |
23 | // For finite lifetimes (SLAAC addresses)
24 | t := time.Now().Add(time.Duration(lifetime) * time.Second)
25 | return &t
26 | }
27 |
28 | func sortAndCompareStringSlices(a, b []string) bool {
29 | if len(a) != len(b) {
30 | return false
31 | }
32 |
33 | sort.Strings(a)
34 | sort.Strings(b)
35 |
36 | for i := range a {
37 | if a[i] != b[i] {
38 | return false
39 | }
40 | }
41 |
42 | return true
43 | }
44 |
45 | func sortIPv6AddressSlicesStable(a []types.IPv6Address) {
46 | sort.SliceStable(a, func(i, j int) bool {
47 | return a[i].Address.String() < a[j].Address.String()
48 | })
49 | }
50 |
51 | func sortAndCompareIPv6AddressSlices(a, b []types.IPv6Address) bool {
52 | if len(a) != len(b) {
53 | return false
54 | }
55 |
56 | sortIPv6AddressSlicesStable(a)
57 | sortIPv6AddressSlicesStable(b)
58 |
59 | for i := range a {
60 | if a[i].Address.String() != b[i].Address.String() {
61 | return false
62 | }
63 |
64 | if a[i].Prefix.String() != b[i].Prefix.String() {
65 | return false
66 | }
67 |
68 | if a[i].Flags != b[i].Flags {
69 | return false
70 | }
71 |
72 | // we don't compare the lifetimes because they are not always same
73 | if a[i].Scope != b[i].Scope {
74 | return false
75 | }
76 | }
77 | return true
78 | }
79 |
--------------------------------------------------------------------------------
/ui/src/components/UpdatingStatusCard.tsx:
--------------------------------------------------------------------------------
1 |
2 | import { CheckCircleIcon } from "@heroicons/react/24/solid"; // adjust import if you use a different icon set
3 |
4 | import LoadingSpinner from "@components/LoadingSpinner"; // adjust import path if needed
5 | import { m } from "@localizations/messages.js";
6 |
7 | export interface UpdatePart {
8 | pending: boolean;
9 | status: string;
10 | progress: number;
11 | complete: boolean;
12 | }
13 |
14 | export default function UpdatingStatusCard({
15 | label,
16 | part,
17 | }: {
18 | label: string;
19 | part: UpdatePart;
20 | }) {
21 | return (
22 |
15 |
38 |
16 |
30 |
18 |
29 |
19 | {m.update_in_progress()}
20 |
21 |
22 |
28 |
23 |
24 | {m.updating_leave_device_on()}
25 |
26 |
27 |
23 |
49 | );
50 | }
51 |
--------------------------------------------------------------------------------
/internal/utils/ssh.go:
--------------------------------------------------------------------------------
1 | package utils
2 |
3 | import (
4 | "fmt"
5 | "slices"
6 | "strings"
7 |
8 | "golang.org/x/crypto/ssh"
9 | )
10 |
11 | // ValidSSHKeyTypes is a list of valid SSH key types
12 | //
13 | // Please make sure that all the types in this list are supported by dropbear
14 | // https://github.com/mkj/dropbear/blob/003c5fcaabc114430d5d14142e95ffdbbd2d19b6/src/signkey.c#L37
15 | //
16 | // ssh-dss is not allowed here as it's insecure
17 | var ValidSSHKeyTypes = []string{
18 | ssh.KeyAlgoRSA,
19 | ssh.KeyAlgoED25519,
20 | ssh.KeyAlgoECDSA256,
21 | ssh.KeyAlgoECDSA384,
22 | ssh.KeyAlgoECDSA521,
23 | ssh.KeyAlgoSKED25519,
24 | ssh.KeyAlgoSKECDSA256,
25 | }
26 |
27 | // ValidateSSHKey validates authorized_keys file content
28 | func ValidateSSHKey(sshKey string) error {
29 | // validate SSH key
30 | var (
31 | hasValidPublicKey = false
32 | lastError = fmt.Errorf("no valid SSH key found")
33 | )
34 | for _, key := range strings.Split(sshKey, "\n") {
35 | key = strings.TrimSpace(key)
36 |
37 | // skip empty lines and comments
38 | if key == "" || strings.HasPrefix(key, "#") {
39 | continue
40 | }
41 |
42 | parsedPublicKey, _, _, _, err := ssh.ParseAuthorizedKey([]byte(key))
43 | if err != nil {
44 | lastError = err
45 | continue
46 | }
47 |
48 | if parsedPublicKey == nil {
49 | continue
50 | }
51 |
52 | parsedType := parsedPublicKey.Type()
53 | textType := strings.Fields(key)[0]
54 |
55 | if parsedType != textType {
56 | lastError = fmt.Errorf("parsed SSH key type %s does not match type in text %s", parsedType, textType)
57 | continue
58 | }
59 |
60 | if !slices.Contains(ValidSSHKeyTypes, parsedType) {
61 | lastError = fmt.Errorf("invalid SSH key type: %s", parsedType)
62 | continue
63 | }
64 |
65 | hasValidPublicKey = true
66 | }
67 |
68 | if !hasValidPublicKey {
69 | return lastError
70 | }
71 |
72 | return nil
73 | }
74 |
--------------------------------------------------------------------------------
/wol.go:
--------------------------------------------------------------------------------
1 | package kvm
2 |
3 | import (
4 | "bytes"
5 | "encoding/binary"
6 | "net"
7 |
8 | "github.com/prometheus/client_golang/prometheus"
9 | "github.com/prometheus/client_golang/prometheus/promauto"
10 | )
11 |
12 | var (
13 | wolPackets = promauto.NewCounter(
14 | prometheus.CounterOpts{
15 | Name: "jetkvm_wol_sent_packets_total",
16 | Help: "Total number of Wake-on-LAN magic packets sent.",
17 | },
18 | )
19 | wolErrors = promauto.NewCounter(
20 | prometheus.CounterOpts{
21 | Name: "jetkvm_wol_sent_packet_errors_total",
22 | Help: "Total number of Wake-on-LAN magic packets errors.",
23 | },
24 | )
25 | )
26 |
27 | // SendWOLMagicPacket sends a Wake-on-LAN magic packet to the specified MAC address
28 | func rpcSendWOLMagicPacket(macAddress string) error {
29 | // Parse the MAC address
30 | mac, err := net.ParseMAC(macAddress)
31 | if err != nil {
32 | wolErrors.Inc()
33 | return ErrorfL(wolLogger, "invalid MAC address", err)
34 | }
35 |
36 | // Create the magic packet
37 | packet := createMagicPacket(mac)
38 |
39 | // Set up UDP connection
40 | conn, err := net.Dial("udp", "255.255.255.255:9")
41 | if err != nil {
42 | wolErrors.Inc()
43 | return ErrorfL(wolLogger, "failed to establish UDP connection", err)
44 | }
45 | defer conn.Close()
46 |
47 | // Send the packet
48 | _, err = conn.Write(packet)
49 | if err != nil {
50 | wolErrors.Inc()
51 | return ErrorfL(wolLogger, "failed to send WOL packet", err)
52 | }
53 |
54 | wolLogger.Info().Str("mac", macAddress).Msg("WOL packet sent")
55 | wolPackets.Inc()
56 |
57 | return nil
58 | }
59 |
60 | // createMagicPacket creates a Wake-on-LAN magic packet
61 | func createMagicPacket(mac net.HardwareAddr) []byte {
62 | var buf bytes.Buffer
63 |
64 | // Write 6 bytes of 0xFF
65 | buf.Write(bytes.Repeat([]byte{0xFF}, 6))
66 |
67 | // Write the target MAC address 16 times
68 | for range 16 {
69 | _ = binary.Write(&buf, binary.BigEndian, mac)
70 | }
71 |
72 | return buf.Bytes()
73 | }
74 |
--------------------------------------------------------------------------------
/ui/src/routes/devices.$id.other-session.tsx:
--------------------------------------------------------------------------------
1 | import { useNavigate, useOutletContext } from "react-router";
2 |
3 | import { Button } from "@components/Button";
4 | import { GridCard } from "@components/Card";
5 | import LogoBlue from "@assets/logo-blue.svg";
6 | import LogoWhite from "@assets/logo-white.svg";
7 | import { m } from "@localizations/messages";
8 |
9 | interface ContextType {
10 | setupPeerConnection: () => Promise
24 |
31 | {label}
25 | {part.progress < 100 ? ( 26 |
39 |
43 |
44 |
45 | {part.status}
46 | {part.progress < 100 ? {`${Math.round(part.progress)}%`} : null}
47 |
48 |
26 |
45 |
27 |
44 |
28 | 
29 | 
30 |
31 |
32 |
33 |
43 | 34 | {m.other_session_detected()} 35 |
36 |37 | {m.other_session_take_over()} 38 |
39 |
40 |
41 |
42 |
39 |
44 | {
50 | setCurrentTheme(e.target.value);
51 | handleThemeChange(e.target.value);
52 | }}
53 | />
54 |
55 |
56 | );
57 | }
58 |
--------------------------------------------------------------------------------
/pkg/nmlite/udhcpc/parser_test.go:
--------------------------------------------------------------------------------
1 | package udhcpc
2 |
3 | import (
4 | "testing"
5 | "time"
6 | )
7 |
8 | func TestUnmarshalDHCPCLease(t *testing.T) {
9 | lease := &Lease{}
10 | err := UnmarshalDHCPCLease(lease, `
11 | # generated @ Mon Jan 4 19:31:53 UTC 2021
12 | # 19:31:53 up 0 min, 0 users, load average: 0.72, 0.14, 0.04
13 | # the date might be inaccurate if the clock is not set
14 | ip=192.168.0.240
15 | siaddr=192.168.0.1
16 | sname=
17 | boot_file=
18 | subnet=255.255.255.0
19 | timezone=
20 | router=192.168.0.1
21 | timesvr=
22 | namesvr=
23 | dns=172.19.53.2
24 | logsvr=
25 | cookiesvr=
26 | lprsvr=
27 | hostname=
28 | bootsize=
29 | domain=
30 | swapsvr=
31 | rootpath=
32 | ipttl=
33 | mtu=
34 | broadcast=
35 | ntpsrv=162.159.200.123
36 | wins=
37 | lease=172800
38 | dhcptype=
39 | serverid=192.168.0.1
40 | message=
41 | tftp=
42 | bootfile=
43 | `)
44 | if lease.IPAddress.String() != "192.168.0.240" {
45 | t.Fatalf("expected ip to be 192.168.0.240, got %s", lease.IPAddress.String())
46 | }
47 | if lease.Netmask.String() != "255.255.255.0" {
48 | t.Fatalf("expected netmask to be 255.255.255.0, got %s", lease.Netmask.String())
49 | }
50 | if len(lease.Routers) != 1 {
51 | t.Fatalf("expected 1 router, got %d", len(lease.Routers))
52 | }
53 | if lease.Routers[0].String() != "192.168.0.1" {
54 | t.Fatalf("expected router to be 192.168.0.1, got %s", lease.Routers[0].String())
55 | }
56 | if len(lease.NTPServers) != 1 {
57 | t.Fatalf("expected 1 timeserver, got %d", len(lease.NTPServers))
58 | }
59 | if lease.NTPServers[0].String() != "162.159.200.123" {
60 | t.Fatalf("expected timeserver to be 162.159.200.123, got %s", lease.NTPServers[0].String())
61 | }
62 | if len(lease.DNS) != 1 {
63 | t.Fatalf("expected 1 dns, got %d", len(lease.DNS))
64 | }
65 | if lease.DNS[0].String() != "172.19.53.2" {
66 | t.Fatalf("expected dns to be 172.19.53.2, got %s", lease.DNS[0].String())
67 | }
68 | if lease.LeaseTime != 172800*time.Second {
69 | t.Fatalf("expected lease time to be 172800 seconds, got %d", lease.LeaseTime)
70 | }
71 | if err != nil {
72 | t.Fatal(err)
73 | }
74 | }
75 |
--------------------------------------------------------------------------------
/pkg/nmlite/jetdhcpc/logging.go:
--------------------------------------------------------------------------------
1 | package jetdhcpc
2 |
3 | import (
4 | "github.com/insomniacslk/dhcp/dhcpv4"
5 | "github.com/insomniacslk/dhcp/dhcpv4/nclient4"
6 | "github.com/insomniacslk/dhcp/dhcpv6/nclient6"
7 | "github.com/rs/zerolog"
8 | )
9 |
10 | type dhcpLogger struct {
11 | // Printfer is used for actual output of the logger
12 | nclient4.Printfer
13 |
14 | l *zerolog.Logger
15 | }
16 |
17 | // Printf prints a log message as-is via predefined Printfer
18 | func (s dhcpLogger) Printf(format string, v ...interface{}) {
19 | s.l.Info().Msgf(format, v...)
20 | }
21 |
22 | // PrintMessage prints a DHCP message in the short format via predefined Printfer
23 | func (s dhcpLogger) PrintMessage(prefix string, message *dhcpv4.DHCPv4) {
24 | s.l.Info().Msgf("%s: %s", prefix, message.String())
25 | }
26 |
27 | func summaryStructured(d *dhcpv4.DHCPv4, l *zerolog.Logger) *zerolog.Logger {
28 | logger := l.With().
29 | Str("opCode", d.OpCode.String()).
30 | Str("hwType", d.HWType.String()).
31 | Int("hopCount", int(d.HopCount)).
32 | Str("transactionID", d.TransactionID.String()).
33 | Int("numSeconds", int(d.NumSeconds)).
34 | Str("flagsString", d.FlagsToString()).
35 | Int("flags", int(d.Flags)).
36 | Str("clientIP", d.ClientIPAddr.String()).
37 | Str("yourIP", d.YourIPAddr.String()).
38 | Str("serverIP", d.ServerIPAddr.String()).
39 | Str("gatewayIP", d.GatewayIPAddr.String()).
40 | Str("clientMAC", d.ClientHWAddr.String()).
41 | Str("serverHostname", d.ServerHostName).
42 | Str("bootFileName", d.BootFileName).
43 | Str("options", d.Options.Summary(nil)).
44 | Logger()
45 | return &logger
46 | }
47 |
48 | func (c *Client) getDHCP4Logger(ifname string) nclient4.ClientOpt {
49 | logger := c.l.With().
50 | Str("interface", ifname).
51 | Str("source", "dhcp4").
52 | Logger()
53 |
54 | return nclient4.WithLogger(dhcpLogger{
55 | l: &logger,
56 | })
57 | }
58 |
59 | // TODO: nclient6 doesn't implement the WithLogger option,
60 | // we might need to open a PR to add it
61 |
62 | func (c *Client) getDHCP6Logger() nclient6.ClientOpt {
63 | return nclient6.WithSummaryLogger()
64 | }
65 |
--------------------------------------------------------------------------------
/ui/src/components/TextArea.tsx:
--------------------------------------------------------------------------------
1 | import React, { JSX } from "react";
2 | import clsx from "clsx";
3 |
4 | import FieldLabel from "@components/FieldLabel";
5 | import { FieldError } from "@components/InputField";
6 | import Card from "@components/Card";
7 | import { cx } from "@/cva.config";
8 |
9 | type TextAreaProps = JSX.IntrinsicElements["textarea"] & {
10 | error?: string | null;
11 | };
12 |
13 | const TextArea = React.forwardRef
50 |
54 | );
55 | });
56 |
57 | export default TextArea;
58 |
--------------------------------------------------------------------------------
/ui/src/routes/devices.$id.settings.macros.add.tsx:
--------------------------------------------------------------------------------
1 | import { useState } from "react";
2 | import { useNavigate } from "react-router";
3 |
4 | import { KeySequence, useMacrosStore, generateMacroId } from "@hooks/stores";
5 | import { MacroForm } from "@components/MacroForm";
6 | import { SettingsPageHeader } from "@components/SettingsPageheader";
7 | import { DEFAULT_DELAY } from "@/constants/macros";
8 | import notifications from "@/notifications";
9 | import { normalizeSortOrders } from "@/utils";
10 | import { m } from "@localizations/messages.js";
11 |
12 | export default function SettingsMacrosAddRoute() {
13 | const { macros, saveMacros } = useMacrosStore();
14 | const [isSaving, setIsSaving] = useState(false);
15 | const navigate = useNavigate();
16 |
17 | const handleAddMacro = async (macro: Partial
43 | navigate("../")}
54 | isSubmitting={isSaving}
55 | />
56 |
57 | );
58 | }
--------------------------------------------------------------------------------
/internal/websecure/utils.go:
--------------------------------------------------------------------------------
1 | package websecure
2 |
3 | import (
4 | "crypto/ecdsa"
5 | "crypto/ed25519"
6 | "crypto/rand"
7 | "crypto/rsa"
8 | "crypto/tls"
9 | "crypto/x509"
10 | "encoding/pem"
11 | "fmt"
12 | "math/big"
13 | "os"
14 | )
15 |
16 | var serialNumberLimit = new(big.Int).Lsh(big.NewInt(1), 4096)
17 |
18 | func withSecretFile(filename string, f func(*os.File) error) error {
19 | file, err := os.OpenFile(filename, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0600)
20 | if err != nil {
21 | return err
22 | }
23 | defer file.Close()
24 |
25 | return f(file)
26 | }
27 |
28 | func keyToFile(cert *tls.Certificate, filename string) error {
29 | var keyBlock pem.Block
30 | switch k := cert.PrivateKey.(type) {
31 | case *rsa.PrivateKey:
32 | keyBlock = pem.Block{
33 | Type: "RSA PRIVATE KEY",
34 | Bytes: x509.MarshalPKCS1PrivateKey(k),
35 | }
36 | case *ecdsa.PrivateKey:
37 | b, e := x509.MarshalECPrivateKey(k)
38 | if e != nil {
39 | return fmt.Errorf("failed to marshal EC private key: %v", e)
40 | }
41 | keyBlock = pem.Block{
42 | Type: "EC PRIVATE KEY",
43 | Bytes: b,
44 | }
45 | case ed25519.PrivateKey:
46 | keyBlock = pem.Block{
47 | Type: "ED25519 PRIVATE KEY",
48 | Bytes: k,
49 | }
50 | default:
51 | return fmt.Errorf("unknown private key type: %T", k)
52 | }
53 |
54 | err := withSecretFile(filename, func(file *os.File) error {
55 | return pem.Encode(file, &keyBlock)
56 | })
57 |
58 | if err != nil {
59 | return fmt.Errorf("failed to save private key: %w", err)
60 | }
61 |
62 | return nil
63 | }
64 |
65 | func certToFile(cert *tls.Certificate, filename string) error {
66 | return withSecretFile(filename, func(file *os.File) error {
67 | for _, c := range cert.Certificate {
68 | block := pem.Block{
69 | Type: "CERTIFICATE",
70 | Bytes: c,
71 | }
72 |
73 | err := pem.Encode(file, &block)
74 | if err != nil {
75 | return fmt.Errorf("failed to save certificate: %w", err)
76 | }
77 | }
78 |
79 | return nil
80 | })
81 | }
82 |
83 | func generateSerialNumber() (*big.Int, error) {
84 | return rand.Int(rand.Reader, serialNumberLimit)
85 | }
86 |
--------------------------------------------------------------------------------
/ui/src/components/PeerConnectionStatusCard.tsx:
--------------------------------------------------------------------------------
1 | import StatusCard from "@components/StatusCards";
2 | import { m } from "@localizations/messages.js";
3 |
4 | const PeerConnectionStatusMap = {
5 | connected: m.peer_connection_connected(),
6 | connecting: m.peer_connection_connecting(),
7 | disconnected: m.peer_connection_disconnected(),
8 | error: m.peer_connection_error(),
9 | closing: m.peer_connection_closing(),
10 | failed: m.peer_connection_failed(),
11 | closed: m.peer_connection_closed(),
12 | new: m.peer_connection_new(),
13 | } as Record
17 |
18 |
38 |
55 | );
56 | }
57 |
--------------------------------------------------------------------------------
/ui/tailwind.config.js:
--------------------------------------------------------------------------------
1 | import flattenColorPalette from "tailwindcss/lib/util/flattenColorPalette";
2 | import svgToDataUri from "mini-svg-data-uri";
3 | import plugin from "tailwindcss/plugin";
4 |
5 | /** @type {import("tailwindcss").Config} */
6 | export default {
7 | darkMode: "selector",
8 | plugins: [
9 | require("@tailwindcss/forms"),
10 | plugin(function ({ addVariant }) {
11 | addVariant("disabled-within", `&:has(input:is(:disabled),button:is(:disabled))`);
12 | }),
13 | plugin(function ({ addVariant }) {
14 | addVariant("invalid-within", `&:has(input:is(:invalid))`);
15 | }),
16 | function ({ matchUtilities, theme }) {
17 | matchUtilities(
18 | {
19 | "bg-grid-sm": value => ({
20 | backgroundImage: `url("${svgToDataUri(
21 | ``,
22 | )}")`,
23 | }),
24 | },
25 | { values: flattenColorPalette(theme("backgroundColor")), type: "color" },
26 | );
27 | },
28 | function ({ matchUtilities, theme }) {
29 | matchUtilities(
30 | {
31 | "bg-grid": value => ({
32 | backgroundImage: `url("${svgToDataUri(
33 | ``,
34 | )}")`,
35 | }),
36 | },
37 | { values: flattenColorPalette(theme("backgroundColor")), type: "color" },
38 | );
39 | },
40 | function ({ matchUtilities, theme }) {
41 | matchUtilities(
42 | {
43 | "bg-grid-lg": value => ({
44 | backgroundImage: `url("${svgToDataUri(
45 | ``,
46 | )}")`,
47 | }),
48 | },
49 | {
50 | values: flattenColorPalette(theme("backgroundColor")),
51 | type: "color",
52 | },
53 | );
54 | },
55 | ],
56 | };
57 |
--------------------------------------------------------------------------------
/ui/e2e/led-roundtrip.spec.ts:
--------------------------------------------------------------------------------
1 | import { test, expect } from "@playwright/test";
2 |
3 | import {
4 | waitForWebRTCReady,
5 | waitForVideoStream,
6 | getLedState,
7 | tapKey,
8 | waitForLedState,
9 | HID_KEY,
10 | KeyboardLedState,
11 | } from "./helpers";
12 |
13 | // Parameterized test data for LED round-trip tests
14 | const LED_TESTS = [
15 | { name: "CAPS_LOCK", key: HID_KEY.CAPS_LOCK, led: "caps_lock" as keyof KeyboardLedState },
16 | { name: "NUM_LOCK", key: HID_KEY.NUM_LOCK, led: "num_lock" as keyof KeyboardLedState },
17 | ] as const;
18 |
19 | test.describe("LED Round-Trip Tests", () => {
20 | test.beforeEach(async ({ page }) => {
21 | // Navigate to the device page (on-device mode uses "/" as the device route)
22 | await page.goto("/");
23 |
24 | // Wait for WebRTC connection to be established
25 | await waitForWebRTCReady(page);
26 | });
27 |
28 | for (const { name, key, led } of LED_TESTS) {
29 | test(`${name} round-trip toggles LED state`, async ({ page }) => {
30 | // Get initial state
31 | const initialState = await getLedState(page);
32 | expect(initialState).not.toBeNull();
33 | const initialValue = initialState![led];
34 | console.log(`Initial ${name} state: ${initialValue}`);
35 |
36 | // Toggle and verify
37 | await tapKey(page, key);
38 | await waitForLedState(page, led, !initialValue);
39 | expect((await getLedState(page))![led]).toBe(!initialValue);
40 | console.log(`New ${name} state: ${!initialValue}`);
41 |
42 | // Restore and verify
43 | await tapKey(page, key);
44 | await waitForLedState(page, led, initialValue);
45 | expect((await getLedState(page))![led]).toBe(initialValue);
46 | });
47 | }
48 |
49 | test("video stream is active", async ({ page }) => {
50 | // Send a few SPACE keys to wake display if screensaver/sleep is active
51 | for (let i = 0; i < 3; i++) {
52 | await tapKey(page, HID_KEY.SPACE);
53 | await page.waitForTimeout(200);
54 | }
55 |
56 | await waitForVideoStream(page);
57 | const isActive = await page.evaluate(() => window.__kvmTestHooks?.isVideoStreamActive());
58 | expect(isActive).toBe(true);
59 | });
60 | });
61 |
--------------------------------------------------------------------------------
/ui/src/hooks/useAppNavigation.ts:
--------------------------------------------------------------------------------
1 | import { useNavigate, useParams } from "react-router";
2 | import type { NavigateOptions } from "react-router";
3 | import { useCallback, useMemo } from "react";
4 |
5 | import { isOnDevice } from "../main";
6 |
7 | /**
8 | * Generates the correct path based on whether the app is running on device or in cloud mode
9 | *
10 | */
11 | export function getDeviceUiPath(path: string, deviceId?: string): string {
12 | // Check if it's a relative path (starts with . or ..)
13 | const isRelativePath = path.startsWith(".") || path === "";
14 |
15 | // If it's a relative path, don't modify it
16 | if (isRelativePath) return path;
17 |
18 | // Ensure absolute path starts with a slash
19 | const normalizedPath = path.startsWith("/") ? path : `/${path}`;
20 |
21 | if (isOnDevice) {
22 | return normalizedPath;
23 | } else {
24 | if (!deviceId) {
25 | console.error("No device ID provided when generating path in cloud mode");
26 | throw new Error("Device ID is required for cloud mode path generation");
27 | }
28 | return `/devices/${deviceId}${normalizedPath}`;
29 | }
30 | }
31 |
32 | /**
33 | * Hook that provides context-aware navigation and path generation
34 | * that works in both cloud and device modes.
35 | *
36 | * In cloud mode, paths are prefixed with /devices/:id
37 | * In device mode, paths start from the root
38 | * Relative paths (starting with . or ..) are preserved in both modes
39 | * Supports all React Router navigation options
40 | */
41 | export function useDeviceUiNavigation() {
42 | const navigate = useNavigate();
43 | const params = useParams();
44 |
45 | // Get the device ID from params
46 | const deviceId = useMemo(() => params.id, [params.id]);
47 |
48 | // Use the standalone getPath function with the current deviceId
49 | const getPath = useCallback(
50 | (path: string): string => {
51 | return getDeviceUiPath(path, deviceId);
52 | },
53 | [deviceId],
54 | );
55 |
56 | // Function to navigate to the correct path with all options
57 | const navigateTo = useCallback(
58 | (path: string, options?: NavigateOptions) => {
59 | navigate(getPath(path), options);
60 | },
61 | [getPath, navigate],
62 | );
63 |
64 | return {
65 | navigateTo,
66 | getPath,
67 | };
68 | }
69 |
--------------------------------------------------------------------------------
/ui/src/hooks/useVersion.tsx:
--------------------------------------------------------------------------------
1 | import { useCallback } from "react";
2 |
3 | import { useDeviceStore } from "@/hooks/stores";
4 | import { JsonRpcError, RpcMethodNotFound } from "@/hooks/useJsonRpc";
5 | import { getUpdateStatus, getLocalVersion as getLocalVersionRpc } from "@/utils/jsonrpc";
6 | import notifications from "@/notifications";
7 | import { m } from "@localizations/messages.js";
8 |
9 | export interface VersionInfo {
10 | appVersion: string;
11 | systemVersion: string;
12 | }
13 |
14 | export interface SystemVersionInfo {
15 | local: VersionInfo;
16 | remote?: VersionInfo;
17 | systemUpdateAvailable: boolean;
18 | appUpdateAvailable: boolean;
19 | error?: string;
20 | }
21 |
22 | export function useVersion() {
23 | const {
24 | appVersion,
25 | systemVersion,
26 | setAppVersion,
27 | setSystemVersion,
28 | } = useDeviceStore();
29 |
30 | const getVersionInfo = useCallback(async () => {
31 | try {
32 | const result = await getUpdateStatus();
33 | setAppVersion(result.local.appVersion);
34 | setSystemVersion(result.local.systemVersion);
35 | return result;
36 | } catch (error) {
37 | const jsonRpcError = error as JsonRpcError;
38 | notifications.error(m.updates_failed_check({ error: jsonRpcError.message }));
39 | throw jsonRpcError;
40 | }
41 | }, [setAppVersion, setSystemVersion]);
42 |
43 | const getLocalVersion = useCallback(async () => {
44 | try {
45 | const result = await getLocalVersionRpc();
46 | setAppVersion(result.appVersion);
47 | setSystemVersion(result.systemVersion);
48 | return result;
49 | } catch (error: unknown) {
50 | const jsonRpcError = error as JsonRpcError;
51 |
52 | if (jsonRpcError.code === RpcMethodNotFound) {
53 | console.error("Failed to get local version, using legacy remote version");
54 | const result = await getVersionInfo();
55 | return result.local;
56 | }
57 |
58 | console.error("Failed to get device version", jsonRpcError);
59 | notifications.error(m.updates_failed_get_device_version({ error: jsonRpcError.message }));
60 | throw jsonRpcError;
61 | }
62 | }, [setAppVersion, setSystemVersion, getVersionInfo]);
63 |
64 | return {
65 | getVersionInfo,
66 | getLocalVersion,
67 | appVersion,
68 | systemVersion,
69 | };
70 | }
71 |
--------------------------------------------------------------------------------
/pkg/nmlite/jetdhcpc/legacy.go:
--------------------------------------------------------------------------------
1 | package jetdhcpc
2 |
3 | import (
4 | "bytes"
5 | "io"
6 | "os"
7 | "path/filepath"
8 | "strconv"
9 | "strings"
10 | "syscall"
11 |
12 | "github.com/rs/zerolog"
13 | )
14 |
15 | func readFileNoStat(filename string) ([]byte, error) {
16 | const maxBufferSize = 1024 * 1024
17 |
18 | f, err := os.Open(filename)
19 | if err != nil {
20 | return nil, err
21 | }
22 | defer f.Close()
23 |
24 | reader := io.LimitReader(f, maxBufferSize)
25 | return io.ReadAll(reader)
26 | }
27 |
28 | func toCmdline(path string) ([]string, error) {
29 | data, err := readFileNoStat(path)
30 | if err != nil {
31 | return nil, err
32 | }
33 |
34 | if len(data) < 1 {
35 | return []string{}, nil
36 | }
37 |
38 | return strings.Split(string(bytes.TrimRight(data, "\x00")), "\x00"), nil
39 | }
40 |
41 | // KillUdhcpC kills all udhcpc processes
42 | func KillUdhcpC(l *zerolog.Logger) error {
43 | // read procfs for udhcpc processes
44 | // we do not use procfs.AllProcs() because we want to avoid the overhead of reading the entire procfs
45 | processes, err := os.ReadDir("/proc")
46 | if err != nil {
47 | return err
48 | }
49 |
50 | matchedPids := make([]int, 0)
51 |
52 | // iterate over the processes
53 | for _, d := range processes {
54 | // check if file is numeric
55 | pid, err := strconv.Atoi(d.Name())
56 | if err != nil {
57 | continue
58 | }
59 |
60 | // check if it's a directory
61 | if !d.IsDir() {
62 | continue
63 | }
64 |
65 | cmdline, err := toCmdline(filepath.Join("/proc", d.Name(), "cmdline"))
66 | if err != nil {
67 | continue
68 | }
69 |
70 | if len(cmdline) < 1 {
71 | continue
72 | }
73 |
74 | if cmdline[0] != "udhcpc" {
75 | continue
76 | }
77 |
78 | matchedPids = append(matchedPids, pid)
79 | }
80 |
81 | if len(matchedPids) == 0 {
82 | l.Info().Msg("no udhcpc processes found")
83 | return nil
84 | }
85 |
86 | l.Info().Ints("pids", matchedPids).Msg("found udhcpc processes, terminating")
87 |
88 | for _, pid := range matchedPids {
89 | err := syscall.Kill(pid, syscall.SIGTERM)
90 | if err != nil {
91 | return err
92 | }
93 |
94 | l.Info().Int("pid", pid).Msg("terminated udhcpc process")
95 | }
96 |
97 | return nil
98 | }
99 |
100 | func (c *Client) killUdhcpc() error {
101 | return KillUdhcpC(c.l)
102 | }
103 |
--------------------------------------------------------------------------------
/ui/src/components/StepCounter.tsx:
--------------------------------------------------------------------------------
1 | import { CheckIcon } from "@heroicons/react/16/solid";
2 |
3 | import Card from "@components/Card";
4 | import { m } from "@localizations/messages.js";
5 | import { cva, cx } from "@/cva.config";
6 |
7 | interface Props {
8 | nSteps: number;
9 | currStepIdx: number;
10 | size?: keyof typeof sizes;
11 | }
12 |
13 | const sizes = {
14 | SM: "text-xs leading-[12px]",
15 | MD: "text-sm leading-[14px]",
16 | };
17 |
18 | const variants = cva({
19 | variants: {
20 | size: sizes,
21 | },
22 | });
23 |
24 | export default function StepCounter({ nSteps, currStepIdx, size = "MD" }: Props) {
25 | const textStyle = variants({ size });
26 | return (
27 |
19 |
37 |
20 |
36 |
21 |
35 |
22 |
23 |
27 |
28 |
24 |
26 | 29 | {m.wake_on_lan_empty_no_devices_added()} 30 |
31 |32 | {m.wake_on_lan_empty_add_device_to_start()} 33 |
34 |
45 |
46 |
54 |
39 |
41 | );
42 | }
43 |
44 | if (i === currStepIdx) {
45 | return (
46 |
53 | {m.step_counter_step({ step: i + 1 })}
54 |
55 | );
56 | }
57 | if (i > currStepIdx) {
58 | return (
59 |