create server

2026-09-11 09:02:05 -05:00 · 2024-10-08 17:00:18 +08:00
parent 2f7cdf78c5
commit 3b2e142657
64 changed files with 3751 additions and 1 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -14,4 +14,6 @@ web/web
 *.sw?

 .idea
-.vscode
+.vscode
+
+NanoKVM-Server
--- a/server/README.md
+++ b/server/README.md
@@ -0,0 +1,38 @@
+# NanoKVM Server
+
+The code of NanoKVM backend server. For more documentation, please refer to [Wiki](https://wiki.sipeed.com/nanokvm).
+
+## Structure
+
+```shell
+server
+├── config       // server config
+├── logger       // server log
+├── main.go
+├── middleware   // server middleware
+├── proto        // api request and response arguments
+├── router       // api routes
+├── service      // api handlers
+└── utils        // utils functions
+```
+
+## Development
+
+The configuration file path is `/etc/kvm/server.yaml`. There are two configurable options:
+
+- `log: error`: log level, default is `error`. Too many logs may affect service performance, it is recommended to use the `error` level in production environment.
+
+- `authentication: enable`: Whether to enable authentication, default is `enable`. Logging in is required after each service restart, use `disable` will skip the authentication check and don't need to log in again. Please delete this configuration for production environments!
+
+## Deployment
+
+```shell
+# Build
+cd server
+go mod tidy
+GOARCH=riscv64 GOOS=linux go build
+```
+
+1. After the compilation is complete, the executable file `NanoKVM-Server` will be generated;
+2. Upload the `NanoKVM-Server` file to the `/kvmapp/server/` directory of NanoKVM;
+3. Execute `/etc/init.d/S95nanokvm restart` in NanoKVM to restart the service.
--- a/server/README_ZH.md
+++ b/server/README_ZH.md
@@ -0,0 +1,37 @@
+# NanoKVM Server
+
+NanoKVM 后端服务的代码。更多文档请参考 [Wiki](https://wiki.sipeed.com/nanokvm) 。
+
+## 目录结构
+
+```shell
+server
+├── config       // 服务配置
+├── logger       // 服务日志
+├── main.go
+├── middleware   // 中间件
+├── proto        // api 请求响应参数
+├── router       // api 路由
+├── service      // api 处理逻辑
+└── utils        // 工具函数
+```
+
+## 开发
+
+配置文件路径为 `/etc/kvm/server.yaml`。有两个可配置的选项：
+
+- `log: error`：日志等级，默认为 `error`。日志过多可能会影响服务性能，生产环境中建议使用 `error` 等级。
+- `authentication: enable`：是否启用鉴权，默认开启。服务每次重启后都需要重新登录，将该选项设为 `disable` 会跳过鉴权检查，可以不用重复登录。生产环境请删除该条配置！
+
+## 部署
+
+```shell
+# 编译
+cd server
+go mod tidy
+GOARCH=riscv64 GOOS=linux go build
+```
+
+1. 编译完成后会生成可执行文件 `NanoKVM-Server`；
+2. 将 `NanoKVM-Server` 文件上传到 NanoKVM 的 `/kvmapp/server/` 目录下；
+3. 在 NanoKVM 中执行 `/etc/init.d/S95nanokvm restart` 重启服务。
--- a/server/config/config.go
+++ b/server/config/config.go
@@ -0,0 +1,116 @@
+package config
+
+import (
+	"bytes"
+	"crypto/rand"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"github.com/spf13/viper"
+	"os"
+	"sync"
+	"time"
+)
+
+var (
+	config Config
+	once   sync.Once
+)
+
+var defaultConfig = []byte(`proto: http
+port:
+  http: 80 
+  https: 443
+cert:
+  crt: server.crt
+  key: server.key
+`)
+
+func GetInstance() *Config {
+	once.Do(read)
+
+	return &config
+}
+
+func read() {
+	viper.SetConfigName("server")
+	viper.SetConfigType("yaml")
+	viper.AddConfigPath("/etc/kvm/")
+
+	if err := viper.ReadInConfig(); err != nil {
+		if errors.As(err, &viper.ConfigFileNotFoundError{}) {
+			create()
+			fmt.Printf("File /etc/kvm/server.yaml not exists. Use default configuration.\n")
+		} else {
+			fmt.Printf("Read file /etc/kvm/server.yaml failed. Use default configuration.\n")
+		}
+	}
+
+	if err := viper.Unmarshal(&config); err != nil {
+		panic(fmt.Sprintf("Can't read configuration file /etc/kvm/nanokvm.yaml.\n%s", err))
+	}
+
+	validate()
+
+	if config.SecretKey == "" {
+		config.SecretKey = generateRandomString()
+	}
+
+	if config.Authentication == "disable" {
+		fmt.Println("NOTICE: Authentication is disabled! Please ensure your service is secure!")
+	}
+
+	fmt.Printf("load config success\n")
+}
+
+func create() {
+	_ = os.MkdirAll("/etc/kvm", 0644)
+
+	file, err := os.OpenFile("/etc/kvm/server.yaml", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
+	if err != nil {
+		fmt.Printf("open config failed: %s\n", err)
+		return
+	}
+	defer file.Close()
+
+	_, err = file.Write(defaultConfig)
+	if err != nil {
+		fmt.Printf("save config failed: %s\n", err)
+		return
+	}
+
+	err = file.Sync()
+	if err != nil {
+		fmt.Printf("sync config failed: %s\n", err)
+		return
+	}
+}
+
+func validate() {
+	if config.Port.Http > 0 && config.Port.Https > 0 {
+		return
+	}
+
+	_ = os.Remove("/etc/kvm/server.yaml")
+
+	if err := viper.ReadConfig(bytes.NewBuffer(defaultConfig)); err != nil {
+		panic("load default config failed")
+	}
+
+	if err := viper.Unmarshal(&config); err != nil {
+		panic("Can't read configuration file /etc/kvm/server.yaml.")
+	}
+}
+
+func generateRandomString() string {
+	b := make([]byte, 64)
+	_, err := rand.Read(b)
+
+	if err != nil {
+		currentTime := time.Now().UnixNano()
+		timeString := fmt.Sprintf("%d", currentTime)
+		return fmt.Sprintf("%064s", timeString)
+	}
+
+	return base64.URLEncoding.EncodeToString(b)
+}
--- a/server/config/types.go
+++ b/server/config/types.go
@@ -0,0 +1,20 @@
+package config
+
+type Config struct {
+	Protocol       string `yaml:"proto"`
+	Port           Port   `yaml:"port"`
+	Cert           Cert   `yaml:"cert"`
+	Log            string `yaml:"logger"`
+	Authentication string `yaml:"authentication"`
+	SecretKey      string `yaml:"secretKey"`
+}
+
+type Port struct {
+	Http  int `yaml:"http"`
+	Https int `yaml:"https"`
+}
+
+type Cert struct {
+	Crt string `yaml:"crt"`
+	Key string `yaml:"key"`
+}
--- a/server/go.mod
+++ b/server/go.mod
@@ -0,0 +1,60 @@
+module NanoKVM-Server
+
+go 1.22.1
+
+require (
+	github.com/gin-gonic/contrib v0.0.0-20240508051311-c1c6bf0061b0
+	github.com/gin-gonic/gin v1.10.0
+	github.com/go-playground/validator/v10 v10.20.0
+	github.com/golang-jwt/jwt/v5 v5.2.1
+	github.com/gorilla/websocket v1.5.3
+	github.com/mervick/aes-everywhere/go/aes256 v0.0.0-20240803013625-6759956693c0
+	github.com/rs/cors/wrapper/gin v0.0.0-20240830163046-1084d89a1692
+	github.com/sirupsen/logrus v1.9.3
+	github.com/spf13/viper v1.19.0
+	github.com/unrolled/secure v1.15.0
+	golang.org/x/crypto v0.23.0
+)
+
+require (
+	github.com/bytedance/sonic v1.11.6 // indirect
+	github.com/bytedance/sonic/loader v0.1.1 // indirect
+	github.com/cloudwego/base64x v0.1.4 // indirect
+	github.com/cloudwego/iasm v0.2.0 // indirect
+	github.com/fsnotify/fsnotify v1.7.0 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.3 // indirect
+	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/go-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/goccy/go-json v0.10.2 // indirect
+	github.com/hashicorp/hcl v1.0.0 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
+	github.com/leodido/go-urn v1.4.0 // indirect
+	github.com/magiconair/properties v1.8.7 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mitchellh/mapstructure v1.5.0 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/pelletier/go-toml/v2 v2.2.2 // indirect
+	github.com/rs/cors v1.11.0 // indirect
+	github.com/sagikazarmark/locafero v0.4.0 // indirect
+	github.com/sagikazarmark/slog-shim v0.1.0 // indirect
+	github.com/sourcegraph/conc v0.3.0 // indirect
+	github.com/spf13/afero v1.11.0 // indirect
+	github.com/spf13/cast v1.6.0 // indirect
+	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/subosito/gotenv v1.6.0 // indirect
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	github.com/ugorji/go/codec v1.2.12 // indirect
+	go.uber.org/atomic v1.9.0 // indirect
+	go.uber.org/multierr v1.9.0 // indirect
+	golang.org/x/arch v0.8.0 // indirect
+	golang.org/x/exp v0.0.0-20230905200255-921286631fa9 // indirect
+	golang.org/x/net v0.25.0 // indirect
+	golang.org/x/sys v0.20.0 // indirect
+	golang.org/x/text v0.15.0 // indirect
+	google.golang.org/protobuf v1.34.1 // indirect
+	gopkg.in/ini.v1 v1.67.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)
--- a/server/go.sum
+++ b/server/go.sum
@@ -0,0 +1,149 @@
+github.com/bytedance/sonic v1.11.6 h1:oUp34TzMlL+OY1OUWxHqsdkgC/Zfc85zGqw9siXjrc0=
+github.com/bytedance/sonic v1.11.6/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4=
+github.com/bytedance/sonic/loader v0.1.1 h1:c+e5Pt1k/cy5wMveRDyk2X4B9hF4g7an8N3zCYjJFNM=
+github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
+github.com/cloudwego/base64x v0.1.4 h1:jwCgWpFanWmN8xoIUHa2rtzmkd5J2plF/dnLS6Xd/0Y=
+github.com/cloudwego/base64x v0.1.4/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
+github.com/cloudwego/iasm v0.2.0 h1:1KNIy1I1H9hNNFEEH3DVnI4UujN+1zjpuk6gwHLTssg=
+github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
+github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
+github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=
+github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
+github.com/gabriel-vasile/mimetype v1.4.3 h1:in2uUcidCuFcDKtdcBxlR0rJ1+fsokWf+uqxgUFjbI0=
+github.com/gabriel-vasile/mimetype v1.4.3/go.mod h1:d8uq/6HKRL6CGdk+aubisF/M5GcPfT7nKyLpA0lbSSk=
+github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
+github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
+github.com/gin-gonic/contrib v0.0.0-20240508051311-c1c6bf0061b0 h1:EUFmvQ8ffefnSAmaUZd9HZYZSw9w/bFjp3FiNaJ5WmE=
+github.com/gin-gonic/contrib v0.0.0-20240508051311-c1c6bf0061b0/go.mod h1:iqneQ2Df3omzIVTkIfn7c1acsVnMGiSLn4XF5Blh3Yg=
+github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU=
+github.com/gin-gonic/gin v1.10.0/go.mod h1:4PMNQiOhvDRa013RKVbsiNwoyezlm2rm0uX/T7kzp5Y=
+github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
+github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
+github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
+github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
+github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
+github.com/go-playground/validator/v10 v10.20.0 h1:K9ISHbSaI0lyB2eWMPJo+kOS/FBExVwjEviJTixqxL8=
+github.com/go-playground/validator/v10 v10.20.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
+github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
+github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/golang-jwt/jwt/v5 v5.2.1 h1:OuVbFODueb089Lh128TAcimifWaLhJwVflnrgM17wHk=
+github.com/golang-jwt/jwt/v5 v5.2.1/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
+github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
+github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
+github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
+github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
+github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM=
+github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
+github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
+github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
+github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY=
+github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mervick/aes-everywhere/go/aes256 v0.0.0-20240803013625-6759956693c0 h1:IfWxTv9SQWw2Vw48Y2CZvVam1WeDBASWnlvNL8QwyQs=
+github.com/mervick/aes-everywhere/go/aes256 v0.0.0-20240803013625-6759956693c0/go.mod h1:Eb5RMoo9kOQra/2uRiUTGP+LfNuM13Vqm7y7P34+KKo=
+github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
+github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
+github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
+github.com/rs/cors v1.11.0 h1:0B9GE/r9Bc2UxRMMtymBkHTenPkHDv0CW4Y98GBY+po=
+github.com/rs/cors v1.11.0/go.mod h1:XyqrcTp5zjWr1wsJ8PIRZssZ8b/WMcMf71DJnit4EMU=
+github.com/rs/cors/wrapper/gin v0.0.0-20240830163046-1084d89a1692 h1:lwzJgPw5Y6pvC8mwbedX9HfdywUKcpNdcviftZsb1uY=
+github.com/rs/cors/wrapper/gin v0.0.0-20240830163046-1084d89a1692/go.mod h1:742Ialb8SOs5yB2PqRDzFcyND3280PoaS5/wcKQUQKE=
+github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6keLGt6kNQ=
+github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4=
+github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE=
+github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ=
+github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
+github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
+github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo=
+github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0=
+github.com/spf13/afero v1.11.0 h1:WJQKhtpdm3v2IzqG8VMqrr6Rf3UYpEF239Jy9wNepM8=
+github.com/spf13/afero v1.11.0/go.mod h1:GH9Y3pIexgf1MTIWtNGyogA5MwRIDXGUr+hbWNoBjkY=
+github.com/spf13/cast v1.6.0 h1:GEiTHELF+vaR5dhz3VqZfFSzZjYbgeKDpBxQVS4GYJ0=
+github.com/spf13/cast v1.6.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/viper v1.19.0 h1:RWq5SEjt8o25SROyN3z2OrDB9l7RPd3lwTWU8EcEdcI=
+github.com/spf13/viper v1.19.0/go.mod h1:GQUN9bilAbhU/jgc1bKs99f/suXKeUMct8Adx5+Ntkg=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
+github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
+github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
+github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
+github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=
+github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+github.com/unrolled/secure v1.15.0 h1:q7x+pdp8jAHnbzxu6UheP8fRlG/rwYTb8TPuQ3rn9Og=
+github.com/unrolled/secure v1.15.0/go.mod h1:BmF5hyM6tXczk3MpQkFf1hpKSRqCyhqcbiQtiAF7+40=
+go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE=
+go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
+go.uber.org/multierr v1.9.0 h1:7fIwc/ZtS0q++VgcfqFDxSBZVv/Xo49/SYnDFupUwlI=
+go.uber.org/multierr v1.9.0/go.mod h1:X2jQV1h+kxSjClGpnseKVIxpmcjrj7MNnI0bnlfKTVQ=
+golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/arch v0.8.0 h1:3wRIsP3pM4yUptoR96otTUOXI367OS0+c9eeRi9doIc=
+golang.org/x/arch v0.8.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
+golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI=
+golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
+golang.org/x/exp v0.0.0-20230905200255-921286631fa9 h1:GoHiUyI/Tp2nVkLI2mCxVkOjsbSXD66ic0XW0js0R9g=
+golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k=
+golang.org/x/net v0.25.0 h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac=
+golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
+golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.20.0 h1:VnkxpohqXaOBYJtBmEppKUG6mXpi+4O6purfc2+sMhw=
+golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
+golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
+golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+google.golang.org/protobuf v1.34.1 h1:9ddQBjfCyZPOHPUiPxpYESBLc+T8P3E+Vo4IbKZgFWg=
+google.golang.org/protobuf v1.34.1/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
+gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=
+rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=
--- a/server/logger/formatter.go
+++ b/server/logger/formatter.go
@@ -0,0 +1,41 @@
+package logger
+
+import (
+	"bytes"
+	"fmt"
+	"github.com/sirupsen/logrus"
+	"path/filepath"
+)
+
+type formatter struct{}
+
+func (f *formatter) Format(entry *logrus.Entry) ([]byte, error) {
+	var (
+		text   string
+		buffer *bytes.Buffer
+	)
+
+	if entry.Buffer != nil {
+		buffer = entry.Buffer
+	} else {
+		buffer = &bytes.Buffer{}
+	}
+
+	now := entry.Time.Format("2006-01-02 15:04:05")
+
+	if entry.HasCaller() {
+		fileName := filepath.Base(entry.Caller.File)
+		text = fmt.Sprintf(
+			"[%s] [%s] [%s:%d] %s\n",
+			now, entry.Level, fileName, entry.Caller.Line, entry.Message,
+		)
+	} else {
+		text = fmt.Sprintf(
+			"[%s] [%s] %s \n",
+			now, entry.Level, entry.Message,
+		)
+	}
+
+	buffer.WriteString(text)
+	return buffer.Bytes(), nil
+}
--- a/server/logger/logger.go
+++ b/server/logger/logger.go
@@ -0,0 +1,24 @@
+package logger
+
+import (
+	"NanoKVM-Server/config"
+	"github.com/sirupsen/logrus"
+	"os"
+)
+
+func Init() {
+	conf := config.GetInstance()
+
+	level, err := logrus.ParseLevel(conf.Log)
+	if err != nil {
+		level = logrus.ErrorLevel
+	}
+
+	logrus.SetLevel(level)
+	logrus.SetOutput(os.Stdout)
+
+	logrus.SetReportCaller(true)
+	logrus.SetFormatter(&formatter{})
+
+	logrus.Info("logger set success")
+}
--- a/server/main.go
+++ b/server/main.go
@@ -0,0 +1,49 @@
+package main
+
+import (
+	"NanoKVM-Server/config"
+	"NanoKVM-Server/logger"
+	"NanoKVM-Server/middleware"
+	"NanoKVM-Server/router"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	cors "github.com/rs/cors/wrapper/gin"
+)
+
+func main() {
+	logger.Init()
+
+	gin.SetMode(gin.ReleaseMode)
+	r := gin.New()
+	r.Use(gin.Recovery())
+	r.Use(cors.AllowAll())
+
+	router.Init(r)
+
+	run(r)
+}
+
+func run(r *gin.Engine) {
+	conf := config.GetInstance()
+
+	httpAddr := fmt.Sprintf(":%d", conf.Port.Http)
+	httpsAddr := fmt.Sprintf(":%d", conf.Port.Https)
+
+	if conf.Protocol == "https" {
+		r.Use(middleware.Tls())
+
+		go func() {
+			if err := r.Run(httpAddr); err != nil {
+				panic("start http server failed")
+			}
+		}()
+
+		if err := r.RunTLS(httpsAddr, conf.Cert.Crt, conf.Cert.Key); err != nil {
+			panic("start https server failed")
+		}
+	} else {
+		if err := r.Run(httpAddr); err != nil {
+			panic("start http server failed")
+		}
+	}
+}
--- a/server/middleware/jwt.go
+++ b/server/middleware/jwt.go
@@ -0,0 +1,78 @@
+package middleware
+
+import (
+	"NanoKVM-Server/config"
+	"github.com/gin-gonic/gin"
+	"github.com/golang-jwt/jwt/v5"
+	log "github.com/sirupsen/logrus"
+	"net/http"
+	"time"
+)
+
+type Token struct {
+	Username string `json:"username"`
+	jwt.RegisteredClaims
+}
+
+const (
+	ExpireDuration = 31 * 24 * time.Hour
+)
+
+func CheckToken() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		conf := config.GetInstance()
+
+		if conf.Authentication == "disable" {
+			c.Next()
+			return
+		}
+
+		cookie, err := c.Cookie("nano-kvm-token")
+		if err == nil {
+			_, err = ParseJWT(cookie)
+			if err == nil {
+				c.Next()
+				return
+			}
+		}
+
+		c.JSON(http.StatusUnauthorized, "unauthorized")
+		c.Abort()
+		return
+	}
+}
+
+func GenerateJWT(username string) (string, error) {
+	conf := config.GetInstance()
+
+	claims := Token{
+		Username: username,
+		RegisteredClaims: jwt.RegisteredClaims{
+			ExpiresAt: jwt.NewNumericDate(time.Now().Add(ExpireDuration)),
+		},
+	}
+
+	t := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+
+	return t.SignedString([]byte(conf.SecretKey))
+}
+
+func ParseJWT(jwtToken string) (*Token, error) {
+	conf := config.GetInstance()
+
+	t, err := jwt.ParseWithClaims(jwtToken, &Token{}, func(token *jwt.Token) (interface{}, error) {
+		secretKey := conf.SecretKey
+		return []byte(secretKey), nil
+	})
+
+	if err != nil {
+		log.Debugf("parse jwt error: %s", err)
+		return nil, err
+	}
+
+	if claims, ok := t.Claims.(*Token); ok && t.Valid {
+		return claims, nil
+	} else {
+		return nil, err
+	}
+}
--- a/server/middleware/tls.go
+++ b/server/middleware/tls.go
@@ -0,0 +1,26 @@
+package middleware
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/unrolled/secure"
+)
+
+func Tls() gin.HandlerFunc {
+	secureMiddleware := secure.New(secure.Options{
+		SSLRedirect: true,
+	})
+
+	secureFunc := func(c *gin.Context) {
+		err := secureMiddleware.Process(c.Writer, c.Request)
+		if err != nil {
+			c.Abort()
+			return
+		}
+
+		if status := c.Writer.Status(); status > 300 && status < 399 {
+			c.Abort()
+		}
+	}
+
+	return secureFunc
+}
--- a/server/proto/application.go
+++ b/server/proto/application.go
@@ -0,0 +1,10 @@
+package proto
+
+type GetVersionRsp struct {
+	Current string `json:"current"`
+	Latest  string `json:"latest"`
+}
+
+type GetLibRsp struct {
+	Exist bool `json:"exist"`
+}
--- a/server/proto/auth.go
+++ b/server/proto/auth.go
@@ -0,0 +1,15 @@
+package proto
+
+type LoginReq struct {
+	Username string `validate:"required"`
+	Password string `validate:"required"`
+}
+
+type LoginRsp struct {
+	Token string `json:"token"`
+}
+
+type ChangePasswordReq struct {
+	Username string `json:"username" validate:"required"`
+	Password string `json:"password" validate:"required"`
+}
--- a/server/proto/network.go
+++ b/server/proto/network.go
@@ -0,0 +1,33 @@
+package proto
+
+type WakeOnLANReq struct {
+	Mac string `form:"mac" validate:"required"`
+}
+
+type GetMacRsp struct {
+	Macs []string `json:"macs"`
+}
+
+type DeleteMacReq struct {
+	Mac string `form:"mac" validate:"required"`
+}
+
+type GetTailscaleStatusRsp struct {
+	Status  string `json:"status"` // notInstall | notLogin | stopped | running
+	Name    string `json:"name"`
+	IP      string `json:"ip"`
+	Account string `json:"account"`
+}
+
+type UpdateTailscaleStatusReq struct {
+	Command string // up | down
+}
+
+type UpdateTailscaleStatusRsp struct {
+	Status string `json:"status"` // stopped | running
+}
+
+type LoginTailscaleRsp struct {
+	Status string `json:"status"`
+	Url    string `json:"url"`
+}
--- a/server/proto/request.go
+++ b/server/proto/request.go
@@ -0,0 +1,54 @@
+package proto
+
+import (
+	"github.com/gin-gonic/gin"
+	"github.com/go-playground/validator/v10"
+	log "github.com/sirupsen/logrus"
+	"os"
+)
+
+var env = os.Getenv(gin.EnvGinMode)
+
+// ValidateRequest Verification request parameters
+func ValidateRequest(req interface{}) (err error) {
+	validate := validator.New()
+
+	if err = validate.Struct(req); err != nil {
+		log.Errorf("validate request failed, err: %s", err)
+		return
+	}
+
+	if env == "" || env == "debug" {
+		log.Debugf("request: %+v\n", req)
+	}
+
+	return
+}
+
+// ParseQueryRequest Parsing GET requests
+func ParseQueryRequest(c *gin.Context, req interface{}) (err error) {
+	if err = c.ShouldBindQuery(req); err != nil {
+		log.Errorf("parse request failed, err: %s", err)
+		return
+	}
+
+	if err = ValidateRequest(req); err != nil {
+		return
+	}
+
+	return
+}
+
+// ParseFormRequest Parsing POST Requests
+func ParseFormRequest(c *gin.Context, req interface{}) (err error) {
+	if err = c.ShouldBind(req); err != nil {
+		log.Errorf("parse request failed, err: %s", err)
+		return
+	}
+
+	if err = ValidateRequest(req); err != nil {
+		return
+	}
+
+	return
+}
--- a/server/proto/response.go
+++ b/server/proto/response.go
@@ -0,0 +1,49 @@
+package proto
+
+import (
+	"github.com/gin-gonic/gin"
+	"net/http"
+)
+
+type Response struct {
+	Code int         `json:"code"` // Status code. 0-success, others-failure
+	Msg  string      `json:"msg"`  // Status details
+	Data interface{} `json:"data"` // Returned data
+}
+
+func (r *Response) Ok() {
+	r.Code = 0
+	r.Msg = "success"
+}
+
+func (r *Response) OkWithData(data interface{}) {
+	r.Ok()
+	r.Data = data
+}
+
+func (r *Response) Err(code int, msg string) {
+	r.Code = code
+	r.Msg = msg
+}
+
+// OkRsp Successful response without data
+func (r *Response) OkRsp(c *gin.Context) {
+	r.Ok()
+
+	c.JSON(http.StatusOK, r)
+}
+
+// OkRspWithData Successful response with data
+func (r *Response) OkRspWithData(c *gin.Context, data interface{}) {
+	r.Ok()
+	r.Data = data
+
+	c.JSON(http.StatusOK, r)
+}
+
+// ErrRsp Failed response
+func (r *Response) ErrRsp(c *gin.Context, code int, msg string) {
+	r.Err(code, msg)
+
+	c.JSON(http.StatusOK, r)
+}
--- a/server/proto/storage.go
+++ b/server/proto/storage.go
@@ -0,0 +1,13 @@
+package proto
+
+type GetImagesRsp struct {
+	Files []string `json:"files"`
+}
+
+type MountImageReq struct {
+	File string `json:"file" validate:"omitempty"`
+}
+
+type GetMountedImageRsp struct {
+	File string `json:"file"`
+}
--- a/server/proto/stream.go
+++ b/server/proto/stream.go
@@ -0,0 +1,9 @@
+package proto
+
+type GetFrameDetectRsp struct {
+	Enabled bool `json:"enabled"`
+}
+
+type UpdateFrameDetectRsp struct {
+	Enabled bool `json:"enabled"`
+}
--- a/server/proto/vm.go
+++ b/server/proto/vm.go
@@ -0,0 +1,58 @@
+package proto
+
+type GetInfoRsp struct {
+	Ip          string `json:"ip"`
+	Mdns        string `json:"mdns"`
+	Image       string `json:"image"`
+	Application string `json:"application"`
+	DeviceKey   string `json:"deviceKey"`
+}
+
+type SetGpioReq struct {
+	Type     string `validate:"required"`  // reset / power
+	Duration uint   `validate:"omitempty"` // press time (unit: milliseconds)
+}
+
+type GetGpioRsp struct {
+	PWR bool `json:"pwr"` // power led
+	HDD bool `json:"hdd"` // hdd led
+}
+
+type SetScreenReq struct {
+	Type  string `validate:"required"` // resolution / fps / quality
+	Value int    `validate:"number"`   // value
+}
+
+type GetScriptsRsp struct {
+	Files []string `json:"files"`
+}
+
+type UploadScriptRsp struct {
+	File string `json:"file"`
+}
+
+type RunScriptReq struct {
+	Name string `validate:"required"`
+	Type string `validate:"required"` // foreground | background
+}
+
+type RunScriptRsp struct {
+	Log string `json:"log"`
+}
+
+type DeleteScriptReq struct {
+	Name string `validate:"required"`
+}
+
+type GetVirtualDeviceRsp struct {
+	Network bool `json:"network"`
+	Disk    bool `json:"disk"`
+}
+
+type UpdateVirtualDeviceReq struct {
+	Device string `validate:"required"`
+}
+
+type UpdateVirtualDeviceRsp struct {
+	On bool `json:"on"`
+}
--- a/server/router/application.go
+++ b/server/router/application.go
@@ -0,0 +1,17 @@
+package router
+
+import (
+	"NanoKVM-Server/middleware"
+	"NanoKVM-Server/service/application"
+	"github.com/gin-gonic/gin"
+)
+
+func applicationRouter(r *gin.Engine) {
+	service := application.NewService()
+	api := r.Group("/api").Use(middleware.CheckToken())
+
+	api.GET("/application/version", service.GetVersion) // get application version
+	api.POST("/application/update", service.Update)     // update application
+	api.GET("/application/lib", service.GetLib)         // check if lib exists
+	api.POST("/application/lib", service.UpdateLib)     // update lib
+}
--- a/server/router/auth.go
+++ b/server/router/auth.go
@@ -0,0 +1,17 @@
+package router
+
+import (
+	"NanoKVM-Server/middleware"
+	"NanoKVM-Server/service/auth"
+	"github.com/gin-gonic/gin"
+)
+
+func authRouter(r *gin.Engine) {
+	service := auth.NewService()
+
+	r.POST("/api/auth/login", service.Login) // login
+
+	api := r.Group("/api").Use(middleware.CheckToken())
+
+	api.POST("/auth/password", service.ChangePassword) // change password
+}
--- a/server/router/hid.go
+++ b/server/router/hid.go
@@ -0,0 +1,15 @@
+package router
+
+import (
+	"NanoKVM-Server/middleware"
+	"NanoKVM-Server/service/hid"
+	"github.com/gin-gonic/gin"
+)
+
+func hidRouter(r *gin.Engine) {
+	service := hid.NewService()
+	api := r.Group("/api").Use(middleware.CheckToken())
+
+	api.POST("/hid/reset", service.Reset) // reset hid
+	api.POST("/hid/paste", service.Paste) // paste
+}
--- a/server/router/network.go
+++ b/server/router/network.go
@@ -0,0 +1,22 @@
+package router
+
+import (
+	"NanoKVM-Server/middleware"
+	"NanoKVM-Server/service/network"
+	"github.com/gin-gonic/gin"
+)
+
+func networkRouter(r *gin.Engine) {
+	service := network.NewService()
+	api := r.Group("/api").Use(middleware.CheckToken())
+
+	api.POST("/network/wol", service.WakeOnLAN)       // wake on lan
+	api.GET("/network/wol/mac", service.GetMac)       // get mac list
+	api.DELETE("/network/wol/mac", service.DeleteMac) // delete mac
+
+	api.POST("/network/tailscale/install", service.InstallTailscale)     // install tailscale
+	api.GET("/network/tailscale/status", service.GetTailscaleStatus)     // get tailscale status
+	api.POST("/network/tailscale/status", service.UpdateTailscaleStatus) // update tailscale status
+	api.POST("/network/tailscale/login", service.LoginTailscale)         // tailscale login
+	api.POST("/network/tailscale/logout", service.LogoutTailscale)       // tailscale logout
+}
--- a/server/router/router.go
+++ b/server/router/router.go
@@ -0,0 +1,37 @@
+package router
+
+import (
+	"fmt"
+	"github.com/gin-gonic/contrib/static"
+	"github.com/gin-gonic/gin"
+	"os"
+	"path/filepath"
+)
+
+func Init(r *gin.Engine) {
+	web(r)
+	server(r)
+}
+
+func web(r *gin.Engine) {
+	execPath, err := os.Executable()
+	if err != nil {
+		panic("invalid executable path")
+	}
+
+	execDir := filepath.Dir(execPath)
+	webPath := fmt.Sprintf("%s/web", execDir)
+
+	r.Use(static.Serve("/", static.LocalFile(webPath, true)))
+}
+
+func server(r *gin.Engine) {
+	authRouter(r)
+	applicationRouter(r)
+	vmRouter(r)
+	streamRouter(r)
+	storageRouter(r)
+	networkRouter(r)
+	hidRouter(r)
+	wsRouter(r)
+}
--- a/server/router/storage.go
+++ b/server/router/storage.go
@@ -0,0 +1,16 @@
+package router
+
+import (
+	"NanoKVM-Server/middleware"
+	"NanoKVM-Server/service/storage"
+	"github.com/gin-gonic/gin"
+)
+
+func storageRouter(r *gin.Engine) {
+	service := storage.NewService()
+	api := r.Group("/api").Use(middleware.CheckToken())
+
+	api.GET("/storage/image", service.GetImages)               // get image list
+	api.GET("/storage/image/mounted", service.GetMountedImage) // get mounted image
+	api.POST("/storage/image/mount", service.MountImage)       // mount image
+}
--- a/server/router/stream.go
+++ b/server/router/stream.go
@@ -0,0 +1,18 @@
+package router
+
+import (
+	"NanoKVM-Server/middleware"
+	"NanoKVM-Server/service/stream"
+	"github.com/gin-gonic/gin"
+)
+
+func streamRouter(r *gin.Engine) {
+	service := stream.NewService()
+	api := r.Group("/api").Use(middleware.CheckToken())
+
+	api.GET("/stream/mjpeg", service.Mjpeg) // mjpeg stream
+
+	api.GET("/stream/mjpeg/detect", service.GetFrameDetect)        // get frame detect state
+	api.POST("/stream/mjpeg/detect", service.UpdateFrameDetect)    // update frame detect state
+	api.POST("/stream/mjpeg/detect/stop", service.StopFrameDetect) // temporary stop frame detect
+}
--- a/server/router/vm.go
+++ b/server/router/vm.go
@@ -0,0 +1,29 @@
+package router
+
+import (
+	"NanoKVM-Server/middleware"
+	"NanoKVM-Server/service/vm"
+	"github.com/gin-gonic/gin"
+)
+
+func vmRouter(r *gin.Engine) {
+	service := vm.NewService()
+	api := r.Group("/api").Use(middleware.CheckToken())
+
+	api.GET("/vm/info", service.GetInfo) // get device information
+
+	api.POST("/vm/gpio", service.SetGpio) // update gpio
+	api.GET("/vm/gpio", service.GetGpio)  // get gpio
+
+	api.POST("/vm/screen", service.SetScreen) // update screen
+
+	api.GET("/vm/terminal", service.Terminal) // web terminal
+
+	api.GET("/vm/script", service.GetScripts)           // get script
+	api.POST("/vm/script/upload", service.UploadScript) // upload script
+	api.POST("/vm/script/run", service.RunScript)       // run script
+	api.DELETE("/vm/script", service.DeleteScript)      // delete script
+
+	api.GET("/vm/device/virtual", service.GetVirtualDevice)     // get virtual device
+	api.POST("/vm/device/virtual", service.UpdateVirtualDevice) // update virtual device
+}
--- a/server/router/ws.go
+++ b/server/router/ws.go
@@ -0,0 +1,14 @@
+package router
+
+import (
+	"NanoKVM-Server/middleware"
+	"NanoKVM-Server/service/ws"
+	"github.com/gin-gonic/gin"
+)
+
+func wsRouter(r *gin.Engine) {
+	service := ws.NewService()
+	api := r.Group("/api").Use(middleware.CheckToken())
+
+	api.GET("/ws", service.Connect)
+}
--- a/server/service/application/application.go
+++ b/server/service/application/application.go
@@ -0,0 +1,117 @@
+package application
+
+import (
+	"NanoKVM-Server/proto"
+	"NanoKVM-Server/utils"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	"strings"
+	"time"
+)
+
+func (s *Service) GetVersion(c *gin.Context) {
+	var rsp proto.Response
+
+	// current version
+	currentVersion := "1.0.0"
+	content, err := os.ReadFile(VersionFile)
+	if err == nil {
+		currentVersion = strings.ReplaceAll(string(content), "\n", "")
+	}
+
+	// latest version
+	url := fmt.Sprintf("%s?now=%d", VersionURL, time.Now().Unix())
+	resp, err := http.Get(url)
+	if err != nil {
+		rsp.ErrRsp(c, -2, "Unable to access sipeed.com. Please check your network.")
+		return
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		rsp.ErrRsp(c, -3, "get version failed")
+		return
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	latestVersion := strings.Replace(string(body), "\n", "", -1)
+
+	rsp.OkRspWithData(c, &proto.GetVersionRsp{
+		Current: currentVersion,
+		Latest:  latestVersion,
+	})
+}
+
+func (s *Service) Update(c *gin.Context) {
+	var rsp proto.Response
+
+	if err := updateApp(); err != nil {
+		rsp.ErrRsp(c, -1, "update failed")
+		return
+	}
+
+	rsp.OkRsp(c)
+	log.Debugf("update application success")
+
+	_ = exec.Command("sh", "-c", "/etc/init.d/S95nanokvm restart").Run()
+}
+
+func updateApp() error {
+	cleanCmd := exec.Command("sh", "-c", fmt.Sprintf("rm -rf %s", Temporary))
+	_ = cleanCmd.Run()
+	_ = os.MkdirAll(Temporary, 0755)
+	defer cleanCmd.Run()
+
+	if err := downloadLib(); err != nil {
+		return err
+	}
+
+	if err := downloadApp(); err != nil {
+		return err
+	}
+
+	commands := []string{
+		fmt.Sprintf("mv -f %s/%s %s/latest/kvm_system/dl_lib/", Temporary, LibName, Temporary), // move lib
+		fmt.Sprintf("rm -rf %s && mv %s %s", Backup, Workspace, Backup),                        // backup old version
+		fmt.Sprintf("rm -rf %s && mv %s/latest %s", Workspace, Temporary, Workspace),           // update
+		fmt.Sprintf("chmod -R 755 %s", Workspace),                                              // modify permission
+	}
+
+	for _, command := range commands {
+		err := exec.Command("sh", "-c", command).Run()
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func downloadApp() error {
+	url := fmt.Sprintf("%s?now=%d", ApplicationURL, time.Now().Unix())
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		log.Errorf("new request err: %s", err)
+		return err
+	}
+
+	zipFile := fmt.Sprintf("%s/latest.zip", Temporary)
+	err = utils.Download(req, zipFile)
+	if err != nil {
+		return err
+	}
+
+	command := fmt.Sprintf("unzip %s -d %s", zipFile, Temporary)
+	err = exec.Command("sh", "-c", command).Run()
+	if err != nil {
+		log.Errorf("unzip app failed: %s", err)
+		return err
+	}
+
+	return nil
+}
--- a/server/service/application/lib.go
+++ b/server/service/application/lib.go
@@ -0,0 +1,99 @@
+package application
+
+import (
+	"NanoKVM-Server/proto"
+	"NanoKVM-Server/utils"
+	"errors"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+	"net/http"
+	"os"
+	"os/exec"
+	"strings"
+)
+
+func (s *Service) GetLib(c *gin.Context) {
+	var rsp proto.Response
+
+	exist, err := isLibExist()
+	if err != nil {
+		rsp.ErrRsp(c, -1, "check lib error")
+		return
+	}
+
+	data := &proto.GetLibRsp{
+		Exist: exist,
+	}
+
+	rsp.OkRspWithData(c, data)
+	log.Debugf("get lib success, exist: %t", exist)
+}
+
+func (s *Service) UpdateLib(c *gin.Context) {
+	var rsp proto.Response
+
+	exist, _ := isLibExist()
+	if exist {
+		rsp.OkRsp(c)
+		return
+	}
+
+	cleanCmd := exec.Command("sh", "-c", fmt.Sprintf("rm -rf %s", Temporary))
+	_ = cleanCmd.Run()
+	_ = os.MkdirAll(Temporary, 0755)
+	defer cleanCmd.Run()
+
+	if err := downloadLib(); err != nil {
+		rsp.ErrRsp(c, -1, "download lib failed")
+		return
+	}
+
+	command := fmt.Sprintf("mv -f %s/%s %s/", Temporary, LibName, LibDir) // update lib
+	err := exec.Command("sh", "-c", command).Run()
+	if err != nil {
+		rsp.ErrRsp(c, -2, "update lib failed")
+		return
+	}
+
+	rsp.OkRsp(c)
+	log.Debugf("update lib success")
+
+	_ = exec.Command("sh", "-c", "/etc/init.d/S95nanokvm restart").Run()
+}
+
+func isLibExist() (bool, error) {
+	libPath := fmt.Sprintf("%s/%s", LibDir, LibName)
+	_, err := os.Stat(libPath)
+
+	if err == nil {
+		return true, nil
+	}
+
+	if errors.Is(err, os.ErrNotExist) {
+		return false, nil
+	}
+
+	return false, err
+}
+
+func downloadLib() error {
+	content, err := os.ReadFile("/device_key")
+	if err != nil {
+		log.Errorf("read devcie key err: %s", err)
+		return err
+	}
+	deviceKey := strings.ReplaceAll(string(content), "\n", "")
+
+	url := fmt.Sprintf("%s?uid=%s", LibURL, deviceKey)
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		log.Errorf("new request err: %s", err)
+		return err
+	}
+	req.Header.Set("token", "MaixVision2024")
+
+	target := fmt.Sprintf("%s/%s", Temporary, LibName)
+
+	return utils.Download(req, target)
+}
--- a/server/service/application/service.go
+++ b/server/service/application/service.go
@@ -0,0 +1,20 @@
+package application
+
+const (
+	VersionURL     = "https://cdn.sipeed.com/nanokvm/latest"
+	ApplicationURL = "https://cdn.sipeed.com/nanokvm/latest.zip"
+	LibURL         = "https://maixvision.sipeed.com/api/v1/nanokvm/encryption"
+
+	Temporary   = "/tmp/kvmcache"
+	Workspace   = "/kvmapp"
+	Backup      = "/root/old"
+	LibDir      = "/kvmapp/kvm_system/dl_lib"
+	LibName     = "libmaixcam_lib.so"
+	VersionFile = "/kvmapp/version"
+)
+
+type Service struct{}
+
+func NewService() *Service {
+	return &Service{}
+}
--- a/server/service/auth/account.go
+++ b/server/service/auth/account.go
@@ -0,0 +1,73 @@
+package auth
+
+import (
+	"NanoKVM-Server/utils"
+	"encoding/json"
+	"errors"
+	log "github.com/sirupsen/logrus"
+	"os"
+	"path/filepath"
+)
+
+const AccountFile = "/etc/kvm/pwd"
+
+type Account struct {
+	Username string `json:"username"`
+	Password string `json:"password"`
+}
+
+func getAccount() (*Account, error) {
+	// use default account
+	if _, err := os.Stat(AccountFile); err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return &Account{
+				Username: "admin",
+				Password: "admin",
+			}, nil
+		}
+
+		return nil, err
+	}
+
+	content, err := os.ReadFile(AccountFile)
+	if err != nil {
+		return nil, err
+	}
+
+	var account Account
+	err = json.Unmarshal(content, &account)
+	if err != nil {
+		log.Errorf("unmarshal account failed: %s", err)
+		return nil, err
+	}
+
+	password, err := utils.DecodeDecrypt(account.Password)
+	if err != nil {
+		return nil, err
+	}
+
+	account.Password = password
+
+	return &account, nil
+}
+
+func setAccount(username string, password string) error {
+	account, err := json.Marshal(&Account{
+		Username: username,
+		Password: password,
+	})
+
+	err = os.MkdirAll(filepath.Dir(AccountFile), 0644)
+	if err != nil {
+		log.Errorf("create directory %s failed: %s", AccountFile, err)
+		return err
+	}
+
+	err = os.WriteFile(AccountFile, account, 0644)
+	if err != nil {
+		log.Errorf("write password failed: %s", err)
+		return err
+	}
+
+	return nil
+}
--- a/server/service/auth/auth.go
+++ b/server/service/auth/auth.go
@@ -0,0 +1,76 @@
+package auth
+
+import (
+	"NanoKVM-Server/config"
+	"NanoKVM-Server/middleware"
+	"NanoKVM-Server/proto"
+	"NanoKVM-Server/utils"
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+)
+
+func (s *Service) Login(c *gin.Context) {
+	var req proto.LoginReq
+	var rsp proto.Response
+
+	// authentication disabled
+	conf := config.GetInstance()
+	if conf.Authentication == "disable" {
+		rsp.OkRspWithData(c, &proto.LoginRsp{
+			Token: "disabled",
+		})
+		return
+	}
+
+	if err := proto.ParseFormRequest(c, &req); err != nil {
+		rsp.ErrRsp(c, -1, "invalid parameters")
+		return
+	}
+
+	passwordDecrypt, err := utils.DecodeDecrypt(req.Password)
+	if err != nil {
+		rsp.ErrRsp(c, -2, "decrypt password failed")
+		return
+	}
+
+	account, err := getAccount()
+	if err != nil {
+		rsp.ErrRsp(c, -3, "get account failed")
+		return
+	}
+
+	if req.Username != account.Username || passwordDecrypt != account.Password {
+		rsp.ErrRsp(c, -4, "invalid username or password")
+		return
+	}
+
+	token, err := middleware.GenerateJWT(req.Username)
+	if err != nil {
+		rsp.ErrRsp(c, -5, "generate token failed")
+		return
+	}
+
+	rsp.OkRspWithData(c, &proto.LoginRsp{
+		Token: token,
+	})
+
+	log.Debugf("login success, username: %s", req.Username)
+}
+
+func (s *Service) ChangePassword(c *gin.Context) {
+	var req proto.ChangePasswordReq
+	var rsp proto.Response
+
+	if err := proto.ParseFormRequest(c, &req); err != nil {
+		rsp.ErrRsp(c, -1, "invalid parameters")
+		return
+	}
+
+	if err := setAccount(req.Username, req.Password); err != nil {
+		rsp.ErrRsp(c, -2, "change password failed")
+		return
+	}
+
+	rsp.OkRsp(c)
+	log.Debugf("change password success, username: %s", req.Username)
+}
--- a/server/service/auth/service.go
+++ b/server/service/auth/service.go
@@ -0,0 +1,7 @@
+package auth
+
+type Service struct{}
+
+func NewService() *Service {
+	return &Service{}
+}
--- a/server/service/hid/constant.go
+++ b/server/service/hid/constant.go
@@ -0,0 +1,29 @@
+package hid
+
+const (
+	MouseUp = iota
+	MouseDown
+	MouseMoveAbsolute
+	MouseMoveRelative
+	MouseScroll
+)
+
+const (
+	MouseLeft  = 1
+	MouseRight = 2
+	MouseWheel = 3
+)
+
+const (
+	HidMouseLeft  byte = 0x01
+	HidMouseRight byte = 0x02
+	HidMouseWheel byte = 0x04
+)
+
+const (
+	ModifierLCtrl  byte = 0x01
+	ModifierLShift byte = 0x02
+	ModifierLAlt   byte = 0x04
+	ModifierLGUI   byte = 0x08
+	ModifierRAlt   byte = 0x40
+)
--- a/server/service/hid/keyboard.go
+++ b/server/service/hid/keyboard.go
@@ -0,0 +1,45 @@
+package hid
+
+func Keyboard(queue <-chan []int) {
+	for event := range queue {
+		writeKeyboard(event)
+	}
+}
+
+func writeKeyboard(event []int) {
+	var data []byte
+
+	if event[0] > 0 {
+		code := byte(event[0])
+		modifier := getModifier(event)
+		data = []byte{modifier, 0x00, code, 0x00, 0x00, 0x00, 0x00, 0x00}
+	} else {
+		data = []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
+	}
+
+	Write(Hidg0, data)
+}
+
+func getModifier(event []int) byte {
+	var modifier byte = 0x00
+
+	if event[1] == 1 {
+		modifier = modifier | ModifierLCtrl
+	}
+
+	if event[2] == 1 {
+		modifier = modifier | ModifierLShift
+	}
+
+	if event[3] == 1 {
+		modifier = modifier | ModifierLAlt
+	} else if event[3] == 2 {
+		modifier = modifier | ModifierRAlt
+	}
+
+	if event[4] == 1 {
+		modifier = modifier | ModifierLGUI
+	}
+
+	return modifier
+}
--- a/server/service/hid/mouse.go
+++ b/server/service/hid/mouse.go
@@ -0,0 +1,99 @@
+package hid
+
+import (
+	"encoding/binary"
+	"errors"
+	log "github.com/sirupsen/logrus"
+	"os"
+	"time"
+)
+
+func Mouse(queue <-chan []int) {
+	for event := range queue {
+		switch event[0] {
+		case MouseDown:
+			mouseDown(event)
+		case MouseUp:
+			mouseUp()
+		case MouseMoveAbsolute:
+			mouseMoveAbsolute(event)
+		case MouseMoveRelative:
+			mouseMoveRelative(event)
+		case MouseScroll:
+			scroll(event)
+		default:
+			log.Debugf("invalid mouse event: %+v", event)
+		}
+	}
+}
+
+func mouseDown(event []int) {
+	var button byte
+
+	switch event[1] {
+	case MouseLeft:
+		button = HidMouseLeft
+	case MouseRight:
+		button = HidMouseRight
+	case MouseWheel:
+		button = HidMouseWheel
+	default:
+		log.Debugf("invalid mouse button: %+v", event)
+		return
+	}
+
+	data := []byte{button, 0, 0, 0}
+	writeWithTimeout(Hidg1, data)
+}
+
+func mouseUp() {
+	data := []byte{0, 0, 0, 0}
+	writeWithTimeout(Hidg1, data)
+}
+
+func scroll(event []int) {
+	direction := 0x01
+	if event[3] > 0 {
+		direction = -0x1
+	}
+
+	data := []byte{0, 0, 0, byte(direction)}
+	writeWithTimeout(Hidg1, data)
+}
+
+func mouseMoveAbsolute(event []int) {
+	x := make([]byte, 2)
+	y := make([]byte, 2)
+	binary.LittleEndian.PutUint16(x, uint16(event[2]))
+	binary.LittleEndian.PutUint16(y, uint16(event[3]))
+
+	data := []byte{0, x[0], x[1], y[0], y[1], 0}
+	writeWithTimeout(Hidg2, data)
+
+}
+
+func mouseMoveRelative(event []int) {
+	data := []byte{byte(event[1]), byte(event[2]), byte(event[3]), 0}
+	writeWithTimeout(Hidg1, data)
+}
+
+func writeWithTimeout(file *os.File, data []byte) {
+	deadline := time.Now().Add(9 * time.Millisecond)
+	_ = file.SetWriteDeadline(deadline)
+
+	_, err := file.Write(data)
+	if err != nil {
+		if errors.Is(err, os.ErrClosed) {
+			Open()
+			log.Debugf("hid already closed, reopen it...")
+		} else if errors.Is(err, os.ErrDeadlineExceeded) {
+			log.Debugf("write to hid timeout")
+		} else {
+			log.Errorf("write to hid failed: %s", err)
+		}
+
+		return
+	}
+
+	log.Debugf("write to hid: %+v", data)
+}
--- a/server/service/hid/operation.go
+++ b/server/service/hid/operation.go
@@ -0,0 +1,59 @@
+package hid
+
+import (
+	"errors"
+	log "github.com/sirupsen/logrus"
+	"os"
+)
+
+var (
+	Hidg0 *os.File
+	Hidg1 *os.File
+	Hidg2 *os.File
+)
+
+func Open() {
+	Close()
+
+	var err error
+
+	Hidg0, err = os.OpenFile("/dev/hidg0", os.O_WRONLY, 0666)
+	if err != nil {
+		log.Errorf("open /dev/hidg0 failed: %s", err)
+	}
+
+	Hidg1, err = os.OpenFile("/dev/hidg1", os.O_WRONLY, 0666)
+	if err != nil {
+		log.Errorf("open /dev/hidg1 failed: %s", err)
+	}
+
+	Hidg2, err = os.OpenFile("/dev/hidg2", os.O_WRONLY, 0666)
+	if err != nil {
+		log.Errorf("open /dev/hidg2 failed: %s", err)
+	}
+}
+
+func Close() {
+	for _, file := range []*os.File{Hidg0, Hidg1, Hidg2} {
+		if file != nil {
+			_ = file.Sync()
+			_ = file.Close()
+		}
+	}
+}
+
+func Write(file *os.File, data []byte) {
+	_, err := file.Write(data)
+	if err != nil {
+		if errors.Is(err, os.ErrClosed) {
+			Open()
+			log.Debugf("hid already closed, reopen it...")
+		} else {
+			log.Errorf("write to hid failed: %s", err)
+		}
+
+		return
+	}
+
+	log.Debugf("write to hid: %+v", data)
+}
--- a/server/service/hid/paste.go
+++ b/server/service/hid/paste.go
@@ -0,0 +1,168 @@
+package hid
+
+import (
+	"NanoKVM-Server/proto"
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+	"time"
+)
+
+type Char struct {
+	Modifiers int
+	Code      int
+}
+
+type PasteReq struct {
+	Content string `form:"content" validate:"required"`
+}
+
+func (s *Service) Paste(c *gin.Context) {
+	var req PasteReq
+	var rsp proto.Response
+
+	if err := proto.ParseFormRequest(c, &req); err != nil {
+		rsp.ErrRsp(c, -1, "invalid arguments")
+		return
+	}
+
+	if len(req.Content) > 1024 {
+		rsp.ErrRsp(c, -2, "")
+		return
+	}
+
+	for _, char := range req.Content {
+		key, ok := charMap[char]
+		if !ok {
+			log.Debugf("unknown key %c", char)
+			continue
+		}
+
+		keyDown := []byte{byte(key.Modifiers), 0x00, byte(key.Code), 0x00, 0x00, 0x00, 0x00, 0x00}
+		keyUp := []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
+
+		// only handle shift. Need to handle all modifiers?
+		if key.Modifiers > 0 {
+			keyShift := []byte{0x00, 0x00, byte(225), 0x00, 0x00, 0x00, 0x00, 0x00}
+			Write(Hidg0, keyShift)
+		}
+
+		Write(Hidg0, keyDown)
+		Write(Hidg0, keyUp)
+
+		if key.Modifiers > 0 {
+			Write(Hidg0, keyUp)
+		}
+
+		time.Sleep(50 * time.Millisecond)
+	}
+
+	rsp.OkRsp(c)
+	log.Debugf("hid paste success, total %d", len(req.Content))
+}
+
+var charMap = map[rune]Char{
+	97:  {0, 4},  // a
+	98:  {0, 5},  // b
+	99:  {0, 6},  // c
+	100: {0, 7},  // d
+	101: {0, 8},  // e
+	102: {0, 9},  // f
+	103: {0, 10}, // g
+	104: {0, 11}, // h
+	105: {0, 12}, // i
+	106: {0, 13}, // j
+	107: {0, 14}, // k
+	108: {0, 15}, // l
+	109: {0, 16}, // m
+	110: {0, 17}, // n
+	111: {0, 18}, // o
+	112: {0, 19}, // p
+	113: {0, 20}, // q
+	114: {0, 21}, // r
+	115: {0, 22}, // s
+	116: {0, 23}, // t
+	117: {0, 24}, // u
+	118: {0, 25}, // v
+	119: {0, 26}, // w
+	120: {0, 27}, // x
+	121: {0, 28}, // y
+	122: {0, 29}, // z
+
+	49: {0, 30}, // 1
+	50: {0, 31}, // 2
+	51: {0, 32}, // 3
+	52: {0, 33}, // 4
+	53: {0, 34}, // 5
+	54: {0, 35}, // 6
+	55: {0, 36}, // 7
+	56: {0, 37}, // 8
+	57: {0, 38}, // 9
+	48: {0, 39}, // 0
+
+	10: {0, 40}, // Enter
+	9:  {0, 43}, // Tab
+	32: {0, 44}, // Space
+	45: {0, 45}, // -
+	61: {0, 46}, // =
+	91: {0, 47}, // [
+	93: {0, 48}, // ]
+	92: {0, 49}, // \
+
+	59: {0, 51}, // ;
+	39: {0, 52}, // '
+	96: {0, 53}, // `
+	44: {0, 54}, // ,
+	46: {0, 55}, // .
+	47: {0, 56}, // /
+
+	65: {2, 4},  // A
+	66: {2, 5},  // B
+	67: {2, 6},  // C
+	68: {2, 7},  // D
+	69: {2, 8},  // E
+	70: {2, 9},  // F
+	71: {2, 10}, // G
+	72: {2, 11}, // H
+	73: {2, 12}, // I
+	74: {2, 13}, // J
+	75: {2, 14}, // K
+	76: {2, 15}, // L
+	77: {2, 16}, // M
+	78: {2, 17}, // N
+	79: {2, 18}, // O
+	80: {2, 19}, // P
+	81: {2, 20}, // Q
+	82: {2, 21}, // R
+	83: {2, 22}, // S
+	84: {2, 23}, // T
+	85: {2, 24}, // U
+	86: {2, 25}, // V
+	87: {2, 26}, // W
+	88: {2, 27}, // X
+	89: {2, 28}, // Y
+	90: {2, 29}, // Z
+
+	33: {2, 30}, // !
+	64: {2, 31}, // @
+	35: {2, 32}, // #
+	36: {2, 33}, // $
+	37: {2, 34}, // %
+	94: {2, 35}, // ^
+	38: {2, 36}, // &
+	42: {2, 37}, // *
+	40: {2, 38}, // (
+	41: {2, 39}, // )
+
+	95:  {2, 45}, // _
+	43:  {2, 46}, // +
+	123: {2, 47}, // {
+	125: {2, 48}, // }
+	124: {2, 49}, // |
+
+	58:  {2, 51}, // :
+	34:  {2, 52}, // "
+	126: {2, 53}, // ~
+	60:  {2, 54}, // <
+	62:  {2, 55}, // >
+	63:  {2, 56}, // ?
+}
--- a/server/service/hid/reset.go
+++ b/server/service/hid/reset.go
@@ -0,0 +1,29 @@
+package hid
+
+import (
+	"NanoKVM-Server/proto"
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+	"os/exec"
+)
+
+func (s *Service) Reset(c *gin.Context) {
+	var rsp proto.Response
+
+	// reset USB
+	commands := []string{
+		"echo > /sys/kernel/config/usb_gadget/g0/UDC",
+		"ls /sys/class/udc/ | cat > /sys/kernel/config/usb_gadget/g0/UDC",
+	}
+
+	for _, command := range commands {
+		err := exec.Command("sh", "-c", command).Run()
+		if err != nil {
+			rsp.ErrRsp(c, -2, "execute command failed")
+			return
+		}
+	}
+
+	rsp.OkRsp(c)
+	log.Debugf("reset hid success")
+}
--- a/server/service/hid/service.go
+++ b/server/service/hid/service.go
@@ -0,0 +1,7 @@
+package hid
+
+type Service struct{}
+
+func NewService() *Service {
+	return &Service{}
+}
--- a/server/service/network/service.go
+++ b/server/service/network/service.go
@@ -0,0 +1,7 @@
+package network
+
+type Service struct{}
+
+func NewService() *Service {
+	return &Service{}
+}
--- a/server/service/network/tailscale.go
+++ b/server/service/network/tailscale.go
@@ -0,0 +1,295 @@
+package network
+
+import (
+	"NanoKVM-Server/proto"
+	"NanoKVM-Server/utils"
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+	"io"
+	"net"
+	"net/http"
+	"os"
+	"os/exec"
+	"regexp"
+	"strings"
+)
+
+const (
+	TailscalePath  = "/usr/bin/tailscale"
+	TailscaledPath = "/usr/sbin/tailscaled"
+)
+
+type TailscaleStatus struct {
+	BackendState string `json:"BackendState"`
+
+	Self struct {
+		HostName     string   `json:"HostName"`
+		TailscaleIPs []string `json:"TailscaleIPs"`
+	} `json:"Self"`
+
+	CurrentTailnet struct {
+		Name string `json:"Name"`
+	} `json:"CurrentTailnet"`
+}
+
+func (s *Service) InstallTailscale(c *gin.Context) {
+	var rsp proto.Response
+
+	if exist := isTailscaleExist(); exist {
+		rsp.OkRsp(c)
+		return
+	}
+
+	var (
+		downloadUrl = "http://cdn.sipeed.com/nanokvm/resources/tailscale_riscv64.zip"
+		workspace   = "/root/.tailscale"
+
+		zipFile    = fmt.Sprintf("%s/tailscale_riscv64.zip", workspace)
+		tailscale  = fmt.Sprintf("%s/tailscale_riscv64/tailscale", workspace)
+		tailscaled = fmt.Sprintf("%s/tailscale_riscv64/tailscaled", workspace)
+	)
+
+	// download
+	_ = os.MkdirAll(workspace, 0755)
+	defer exec.Command("sh", "-c", fmt.Sprintf("rm -rf %s", workspace)).Run()
+
+	req, err := http.NewRequest("GET", downloadUrl, nil)
+	if err != nil {
+		log.Errorf("new request err: %s", err)
+		rsp.ErrRsp(c, -1, "request failed")
+		return
+	}
+
+	err = utils.Download(req, zipFile)
+	if err != nil {
+		rsp.ErrRsp(c, -2, "download failed")
+		return
+	}
+
+	// install
+	command := fmt.Sprintf("unzip %s -d %s", zipFile, workspace)
+	err = exec.Command("sh", "-c", command).Run()
+	if err != nil {
+		log.Errorf("unzip failed: %s", err)
+		rsp.ErrRsp(c, -3, "unzip failed")
+		return
+	}
+
+	err = os.Rename(tailscale, TailscalePath)
+	if err != nil {
+		log.Debugf("rename %s failed: %s", tailscale, err)
+	}
+	err = os.Rename(tailscaled, TailscaledPath)
+	if err != nil {
+		log.Debugf("rename %s failed: %s", tailscaled, err)
+	}
+
+	_ = runTailscale()
+
+	rsp.OkRsp(c)
+	log.Debugf("install tailscaled success")
+}
+
+func (s *Service) LoginTailscale(c *gin.Context) {
+	var rsp proto.Response
+
+	status, err := getTailscaleStatus()
+	if err != nil {
+		_ = runTailscale()
+		status, err = getTailscaleStatus()
+	}
+
+	if err != nil {
+		rsp.ErrRsp(c, -1, "tailscale unknown status")
+		return
+	}
+
+	if status.BackendState == "Running" {
+		rsp.OkRspWithData(c, &proto.LoginTailscaleRsp{
+			Status: "running",
+		})
+		return
+	}
+
+	cmd := exec.Command("sh", "-c", "tailscale login --timeout=10m")
+	stderr, err := cmd.StderrPipe()
+	if err != nil {
+		rsp.ErrRsp(c, -2, "tailscale login failed")
+		return
+	}
+
+	defer stderr.Close()
+
+	go cmd.Run()
+
+	url := parseLoginUrl(stderr)
+	rsp.OkRspWithData(c, &proto.LoginTailscaleRsp{
+		Status: "notLogin",
+		Url:    url,
+	})
+	log.Debugf("tailscale login url: %s", url)
+}
+
+func (s *Service) LogoutTailscale(c *gin.Context) {
+	var rsp proto.Response
+
+	cmd := exec.Command("sh", "-c", "tailscale logout")
+	err := cmd.Run()
+	if err != nil {
+		rsp.ErrRsp(c, -2, "tailscale logout failed")
+		return
+	}
+
+	rsp.OkRsp(c)
+	log.Debugf("tailscale logout success")
+}
+
+func (s *Service) GetTailscaleStatus(c *gin.Context) {
+	var rsp proto.Response
+	var data proto.GetTailscaleStatusRsp
+
+	if exist := isTailscaleExist(); !exist {
+		data.Status = "notInstall"
+		rsp.OkRspWithData(c, data)
+		return
+	}
+
+	status, err := getTailscaleStatus()
+	if err != nil {
+		data.Status = "notLogin"
+		rsp.OkRspWithData(c, data)
+		return
+	}
+
+	switch status.BackendState {
+	case "NeedsLogin":
+		data.Status = "notLogin"
+	case "Running":
+		data.Status = "running"
+	case "Stopped":
+		data.Status = "stopped"
+	default:
+		rsp.ErrRsp(c, -1, "unknown state")
+		return
+	}
+
+	for _, tailscaleIp := range status.Self.TailscaleIPs {
+		ip := net.ParseIP(tailscaleIp)
+		if ip != nil && ip.To4() != nil {
+			data.IP = ip.String()
+		}
+	}
+
+	data.Name = status.Self.HostName
+	data.Account = status.CurrentTailnet.Name
+
+	rsp.OkRspWithData(c, data)
+	log.Debugf("tailscale status: %s", data.Status)
+}
+
+func (s *Service) UpdateTailscaleStatus(c *gin.Context) {
+	var req proto.UpdateTailscaleStatusReq
+	var rsp proto.Response
+
+	if err := proto.ParseFormRequest(c, &req); err != nil {
+		rsp.ErrRsp(c, -1, "invalid arguments")
+		return
+	}
+
+	command := fmt.Sprintf("tailscale %s", req.Command)
+	err := exec.Command("sh", "-c", command).Run()
+	if err != nil {
+		msg := fmt.Sprintf("tailscale %s failed", req.Command)
+		rsp.ErrRsp(c, -2, msg)
+		return
+	}
+
+	status, err := getTailscaleStatus()
+	if err != nil {
+		rsp.ErrRsp(c, -3, "get tailscale status failed")
+		return
+	}
+
+	data := &proto.UpdateTailscaleStatusRsp{}
+
+	if status.BackendState == "Running" {
+		data.Status = "running"
+	} else if status.BackendState == "Stopped" {
+		data.Status = "stopped"
+	} else {
+		rsp.ErrRsp(c, -4, "unknown tailscale status")
+		return
+	}
+
+	rsp.OkRspWithData(c, data)
+	log.Debugf("tailscale %s success", req.Command)
+}
+
+func isTailscaleExist() bool {
+	_, err1 := os.Stat(TailscalePath)
+	_, err2 := os.Stat(TailscaledPath)
+
+	return err1 == nil && err2 == nil
+}
+
+func runTailscale() error {
+	for _, filePath := range []string{TailscalePath, TailscaledPath} {
+		if err := utils.EnsurePermission(filePath, 0100); err != nil {
+			return err
+		}
+	}
+
+	err := exec.Command("sh", "-c", "/etc/init.d/S98tailscaled start").Run()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func getTailscaleStatus() (TailscaleStatus, error) {
+	var status TailscaleStatus
+
+	command := "tailscale status --json"
+	cmd := exec.Command("sh", "-c", command)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		log.Debugf("get tailscale status failed: %s", err)
+		return status, err
+	}
+
+	// delete warning message
+	if str := string(output); !strings.HasPrefix(str, "{") {
+		index := strings.Index(str, "{")
+		if index != -1 {
+			output = []byte(str[index:])
+		}
+	}
+
+	err = json.Unmarshal(output, &status)
+	if err != nil {
+		log.Debugf("unmarshal tailscale status failed: %s", err)
+		return status, err
+	}
+
+	return status, nil
+}
+
+func parseLoginUrl(r io.Reader) string {
+	reader := bufio.NewReader(r)
+	for {
+		line, err := reader.ReadString('\n')
+		if err != nil {
+			log.Errorf("reading line failed: %s", err)
+			return ""
+		}
+
+		if strings.Contains(line, "https") {
+			reg := regexp.MustCompile("\\s+")
+			return reg.ReplaceAllString(line, "")
+		}
+	}
+}
--- a/server/service/network/wol.go
+++ b/server/service/network/wol.go
@@ -0,0 +1,137 @@
+package network
+
+import (
+	"NanoKVM-Server/proto"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+)
+
+const (
+	WolHistory = "/etc/kvm/cache/wol"
+)
+
+func (s *Service) WakeOnLAN(c *gin.Context) {
+	var req proto.WakeOnLANReq
+	var rsp proto.Response
+
+	if err := proto.ParseFormRequest(c, &req); err != nil {
+		rsp.ErrRsp(c, -1, "invalid arguments")
+		return
+	}
+
+	command := fmt.Sprintf("ether-wake %s", req.Mac)
+	cmd := exec.Command("sh", "-c", command)
+
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		log.Errorf("wake on lan failed: %s", err)
+		rsp.ErrRsp(c, -2, string(output))
+		return
+	}
+
+	go saveMac(req.Mac)
+
+	rsp.OkRsp(c)
+	log.Debugf("wake on lan %s success", req.Mac)
+}
+
+func (s *Service) GetMac(c *gin.Context) {
+	var rsp proto.Response
+
+	content, err := os.ReadFile(WolHistory)
+	if err != nil {
+		rsp.ErrRsp(c, -2, "open file error")
+		return
+	}
+
+	macs := strings.Split(string(content), "\n")
+	data := &proto.GetMacRsp{
+		Macs: macs,
+	}
+
+	rsp.OkRspWithData(c, data)
+}
+
+func (s *Service) DeleteMac(c *gin.Context) {
+	var req proto.DeleteMacReq
+	var rsp proto.Response
+
+	if err := proto.ParseFormRequest(c, &req); err != nil {
+		rsp.ErrRsp(c, -1, "invalid arguments")
+		return
+	}
+
+	content, err := os.ReadFile(WolHistory)
+	if err != nil {
+		log.Errorf("open %s failed: %s", WolHistory, err)
+		rsp.ErrRsp(c, -2, "read failed")
+		return
+	}
+
+	macs := strings.Split(string(content), "\n")
+	var newMacs []string
+
+	for _, mac := range macs {
+		if req.Mac != mac {
+			newMacs = append(newMacs, mac)
+		}
+	}
+
+	data := strings.Join(newMacs, "\n")
+	err = os.WriteFile(WolHistory, []byte(data), 0644)
+	if err != nil {
+		log.Errorf("write %s failed: %s", WolHistory, err)
+		rsp.ErrRsp(c, -3, "write failed")
+		return
+	}
+
+	rsp.OkRsp(c)
+	log.Debugf("delete mac %s success", req.Mac)
+}
+
+func saveMac(mac string) {
+	if isMacExist(mac) {
+		return
+	}
+
+	err := os.MkdirAll(filepath.Dir(WolHistory), 0644)
+	if err != nil {
+		log.Errorf("create dir failed: %s", err)
+		return
+	}
+
+	file, err := os.OpenFile(WolHistory, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		log.Errorf("open %s failed: %s", WolHistory, err)
+		return
+	}
+	defer file.Close()
+
+	content := fmt.Sprintf("%s\n", mac)
+	_, err = file.WriteString(content)
+	if err != nil {
+		log.Errorf("write %s failed: %s", WolHistory, err)
+		return
+	}
+}
+
+func isMacExist(mac string) bool {
+	content, err := os.ReadFile(WolHistory)
+	if err != nil {
+		return false
+	}
+
+	macs := strings.Split(string(content), "\n")
+	for _, item := range macs {
+		if mac == item {
+			return true
+		}
+	}
+
+	return false
+}
--- a/server/service/storage/image.go
+++ b/server/service/storage/image.go
@@ -0,0 +1,107 @@
+package storage
+
+import (
+	"NanoKVM-Server/proto"
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+)
+
+const (
+	ImageDirectory = "/data"
+	ImageNone      = "/dev/mmcblk0p3"
+	MountDevice    = "/sys/kernel/config/usb_gadget/g0/functions/mass_storage.disk0/lun.0/file"
+)
+
+func (s *Service) GetImages(c *gin.Context) {
+	var rsp proto.Response
+	var images []string
+
+	err := filepath.Walk(ImageDirectory, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if !info.IsDir() {
+			name := strings.ToLower(info.Name())
+			if strings.HasSuffix(name, ".iso") || strings.HasSuffix(name, ".img") {
+				images = append(images, path)
+			}
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		rsp.ErrRsp(c, -2, "get images failed")
+		return
+	}
+
+	rsp.OkRspWithData(c, &proto.GetImagesRsp{
+		Files: images,
+	})
+	log.Debugf("get images success, total %d", len(images))
+}
+
+func (s *Service) MountImage(c *gin.Context) {
+	var req proto.MountImageReq
+	var rsp proto.Response
+
+	if err := proto.ParseFormRequest(c, &req); err != nil {
+		rsp.ErrRsp(c, -1, "invalid arguments")
+		return
+	}
+
+	image := req.File
+	if image == "" {
+		image = ImageNone
+	}
+
+	// mount
+	if err := os.WriteFile(MountDevice, []byte(image), 0666); err != nil {
+		log.Errorf("mount file %s failed: %s", image, err)
+		rsp.ErrRsp(c, -2, "mount image failed")
+		return
+	}
+
+	// reset usb
+	commands := []string{
+		"echo > /sys/kernel/config/usb_gadget/g0/UDC",
+		"ls /sys/class/udc/ | cat > /sys/kernel/config/usb_gadget/g0/UDC",
+	}
+
+	for _, command := range commands {
+		err := exec.Command("sh", "-c", command).Run()
+		if err != nil {
+			rsp.ErrRsp(c, -2, "execute command failed")
+			return
+		}
+	}
+
+	rsp.OkRsp(c)
+	log.Debugf("mount image %s success", req.File)
+}
+
+func (s *Service) GetMountedImage(c *gin.Context) {
+	var rsp proto.Response
+
+	content, err := os.ReadFile(MountDevice)
+	if err != nil {
+		rsp.ErrRsp(c, -2, "read failed")
+		return
+	}
+
+	image := strings.ReplaceAll(string(content), "\n", "")
+	if image == ImageNone {
+		image = ""
+	}
+
+	data := &proto.GetMountedImageRsp{
+		File: image,
+	}
+
+	rsp.OkRspWithData(c, data)
+}
--- a/server/service/storage/service.go
+++ b/server/service/storage/service.go
@@ -0,0 +1,7 @@
+package storage
+
+type Service struct{}
+
+func NewService() *Service {
+	return &Service{}
+}
--- a/server/service/stream/frame-detect.go
+++ b/server/service/stream/frame-detect.go
@@ -0,0 +1,128 @@
+package stream
+
+import (
+	"NanoKVM-Server/proto"
+	"errors"
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+	"os"
+	"time"
+)
+
+const (
+	FrameDetect    = "/etc/kvm/frame_detact"
+	FrameDetectTmp = "/etc/kvm/frame_detact_tmp"
+)
+
+type UpdateFrameDetectRsp struct {
+	Enabled bool `json:"enabled"`
+}
+
+func (s *Service) GetFrameDetect(c *gin.Context) {
+	var rsp proto.Response
+
+	isEnabled, err := isFrameDetectEnabled()
+	if err != nil {
+		rsp.ErrRsp(c, -1, "unknown frame detect status")
+		return
+	}
+
+	rsp.OkRspWithData(c, &proto.GetFrameDetectRsp{
+		Enabled: isEnabled,
+	})
+	log.Debugf("get frame detect success, enabled: %t", isEnabled)
+}
+
+func (s *Service) UpdateFrameDetect(c *gin.Context) {
+	var rsp proto.Response
+
+	isEnabled, err := isFrameDetectEnabled()
+	if err != nil {
+		rsp.ErrRsp(c, -1, "unknown frame status")
+		return
+	}
+
+	if isEnabled {
+		_ = os.Remove(FrameDetect)
+		_ = os.Remove(FrameDetectTmp)
+	} else {
+		file, err2 := os.OpenFile(FrameDetect, os.O_CREATE|os.O_TRUNC, 0644)
+		if err2 != nil {
+			rsp.ErrRsp(c, -3, "enable frame detect failed")
+			return
+		}
+		defer file.Close()
+	}
+
+	isEnabled, err = isFrameDetectEnabled()
+	if err != nil {
+		rsp.ErrRsp(c, -4, "unknown frame status")
+		return
+	}
+
+	rsp.OkRspWithData(c, &UpdateFrameDetectRsp{
+		Enabled: isEnabled,
+	})
+	log.Debugf("update frame detect success, enabled: %t", isEnabled)
+}
+
+func (s *Service) StopFrameDetect(c *gin.Context) {
+	var rsp proto.Response
+
+	exist, err := isFileExist(FrameDetect)
+	if err != nil {
+		rsp.ErrRsp(c, -1, "unknown frame status")
+		return
+	}
+
+	if !exist {
+		rsp.OkRsp(c)
+		return
+	}
+
+	err = os.Rename(FrameDetect, FrameDetectTmp)
+	if err != nil {
+		rsp.ErrRsp(c, -2, "stop operation failed")
+		return
+	}
+
+	go func() {
+		time.Sleep(20 * time.Second)
+		_ = os.Rename(FrameDetectTmp, FrameDetect)
+		log.Debugf("frame detect started")
+	}()
+
+	rsp.OkRsp(c)
+	log.Debugf("frame detect stoped")
+}
+
+func isFrameDetectEnabled() (bool, error) {
+	exist, err := isFileExist(FrameDetect)
+	if err != nil {
+		return false, err
+	}
+
+	if exist {
+		return true, nil
+	}
+
+	exist, err = isFileExist(FrameDetectTmp)
+	if err != nil {
+		return false, err
+	}
+
+	return exist, nil
+}
+
+func isFileExist(name string) (bool, error) {
+	_, err := os.Stat(name)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			return false, nil
+		}
+
+		return false, nil
+	}
+
+	return true, nil
+}
--- a/server/service/stream/mjpeg.go
+++ b/server/service/stream/mjpeg.go
@@ -0,0 +1,27 @@
+package stream
+
+import (
+	"github.com/gin-gonic/gin"
+	"io"
+	"net/http"
+)
+
+func (s *Service) Mjpeg(c *gin.Context) {
+	mjpegURL := "http://127.0.0.1:8000/stream"
+
+	resp, err := http.Get(mjpegURL)
+	if err != nil {
+		c.String(http.StatusInternalServerError, "Failed to connect to MJPEG server")
+		return
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		c.String(resp.StatusCode, "MJPEG server returned an error")
+		return
+	}
+
+	c.Header("Content-Type", resp.Header.Get("Content-Type"))
+
+	_, _ = io.Copy(c.Writer, resp.Body)
+}
--- a/server/service/stream/service.go
+++ b/server/service/stream/service.go
@@ -0,0 +1,7 @@
+package stream
+
+type Service struct{}
+
+func NewService() *Service {
+	return &Service{}
+}
--- a/server/service/vm/gpio.go
+++ b/server/service/vm/gpio.go
@@ -0,0 +1,136 @@
+package vm
+
+import (
+	"NanoKVM-Server/proto"
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+)
+
+const (
+	HW_VERSION_FILE = "/etc/kvm/hw"
+
+	GPIO_PWR     = "/sys/class/gpio/gpio503/value"
+	GPIO_PWR_LED = "/sys/class/gpio/gpio504/value"
+
+	GPIO_RST_ALPHA     = "/sys/class/gpio/gpio507/value"
+	GPIO_HDD_LED_ALPHA = "/sys/class/gpio/gpio505/value"
+
+	GPIO_RST_BETA = "/sys/class/gpio/gpio505/value"
+)
+
+func (s *Service) SetGpio(c *gin.Context) {
+	var req proto.SetGpioReq
+	var rsp proto.Response
+
+	if err := proto.ParseFormRequest(c, &req); err != nil {
+		rsp.ErrRsp(c, -1, "invalid arguments")
+		return
+	}
+
+	version := getHwVersion()
+	device := ""
+
+	if req.Type == "power" {
+		device = GPIO_PWR
+	} else if req.Type == "reset" {
+		if version == "alpha" {
+			device = GPIO_RST_ALPHA
+		} else {
+			device = GPIO_RST_BETA
+		}
+	} else {
+		rsp.ErrRsp(c, -2, "invalid power event")
+		return
+	}
+
+	var duration time.Duration
+	if req.Duration > 0 {
+		duration = time.Duration(req.Duration) * time.Millisecond
+	} else {
+		duration = 800 * time.Millisecond
+	}
+
+	if err := writeGpio(device, duration); err != nil {
+		rsp.ErrRsp(c, -3, "operation failed")
+		return
+	}
+
+	log.Debugf("set gpio %s success", device)
+	rsp.OkRsp(c)
+}
+
+func (s *Service) GetGpio(c *gin.Context) {
+	var rsp proto.Response
+
+	pwr, err := readGpio(GPIO_PWR_LED)
+	if err != nil {
+		rsp.ErrRsp(c, -2, "read led failed")
+		return
+	}
+
+	hdd := false
+	version := getHwVersion()
+	if version == "alpha" {
+		hdd, err = readGpio(GPIO_HDD_LED_ALPHA)
+	}
+
+	data := &proto.GetGpioRsp{
+		PWR: pwr,
+		HDD: hdd,
+	}
+	rsp.OkRspWithData(c, data)
+}
+
+// get hardware version: alpha or beta
+func getHwVersion() string {
+	content, err := os.ReadFile(HW_VERSION_FILE)
+	if err == nil {
+		version := strings.ReplaceAll(string(content), "\n", "")
+		if version == "beta" {
+			return "beta"
+		}
+	}
+
+	return "alpha"
+}
+
+func writeGpio(device string, duration time.Duration) error {
+	if err := os.WriteFile(device, []byte("1"), 0666); err != nil {
+		log.Errorf("write gpio %s failed: %s", device, err)
+		return err
+	}
+
+	time.Sleep(duration)
+
+	if err := os.WriteFile(device, []byte("0"), 0666); err != nil {
+		log.Errorf("write gpio %s failed: %s", device, err)
+		return err
+	}
+
+	return nil
+}
+
+func readGpio(device string) (bool, error) {
+	content, err := os.ReadFile(device)
+	if err != nil {
+		log.Errorf("read gpio %s failed: %s", device, err)
+		return false, err
+	}
+
+	contentStr := string(content)
+	if len(contentStr) > 1 {
+		contentStr = contentStr[:len(contentStr)-1]
+	}
+
+	value, err := strconv.Atoi(contentStr)
+	if err != nil {
+		log.Errorf("invalid gpio content: %s", content)
+		return false, nil
+	}
+
+	return value == 0, nil
+}
--- a/server/service/vm/info.go
+++ b/server/service/vm/info.go
@@ -0,0 +1,91 @@
+package vm
+
+import (
+	"NanoKVM-Server/proto"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+	"net"
+	"os"
+	"strings"
+)
+
+var imageVersionMap = map[string]string{
+	"2024-06-23-20-59-2d2bfb.img": "v1.0.0",
+	"2024-07-23-20-18-587710.img": "v1.1.0",
+	"2024-08-08-19-44-bef2ca.img": "v1.2.0",
+}
+
+func (s *Service) GetInfo(c *gin.Context) {
+	var rsp proto.Response
+
+	data := &proto.GetInfoRsp{
+		Ip:          getIp(),
+		Mdns:        getMdns(),
+		Image:       getImageVersion(),
+		Application: getApplicationVersion(),
+		DeviceKey:   getDeviceKey(),
+	}
+
+	rsp.OkRspWithData(c, data)
+	log.Debug("get vm information success")
+}
+
+func getIp() string {
+	addressList, err := net.InterfaceAddrs()
+	if err != nil {
+		return ""
+	}
+
+	for _, address := range addressList {
+		if ipnet, ok := address.(*net.IPNet); ok && !ipnet.IP.IsLoopback() && ipnet.IP.To4() != nil {
+			ip := ipnet.IP.String()
+			return ip
+		}
+	}
+
+	return ""
+}
+
+func getMdns() string {
+	content, err := os.ReadFile("/etc/hostname")
+	if err != nil {
+		return ""
+	}
+
+	mdns := strings.ReplaceAll(string(content), "\n", "")
+	return fmt.Sprintf("%s.local", mdns)
+}
+
+func getImageVersion() string {
+	content, err := os.ReadFile("/boot/ver")
+	if err != nil {
+		return ""
+	}
+
+	image := strings.ReplaceAll(string(content), "\n", "")
+
+	if version, ok := imageVersionMap[image]; ok {
+		return version
+	}
+
+	return image
+}
+
+func getApplicationVersion() string {
+	content, err := os.ReadFile("/kvmapp/version")
+	if err != nil {
+		return "1.0.0"
+	}
+
+	return strings.ReplaceAll(string(content), "\n", "")
+}
+
+func getDeviceKey() string {
+	content, err := os.ReadFile("/device_key")
+	if err != nil {
+		return ""
+	}
+
+	return strings.ReplaceAll(string(content), "\n", "")
+}
--- a/server/service/vm/screen.go
+++ b/server/service/vm/screen.go
@@ -0,0 +1,42 @@
+package vm
+
+import (
+	"NanoKVM-Server/proto"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+	"os"
+)
+
+var screenFileMap = map[string]string{
+	"fps":        "/kvmapp/kvm/fps",
+	"quality":    "/kvmapp/kvm/qlty",
+	"resolution": "/kvmapp/kvm/res",
+}
+
+func (s *Service) SetScreen(c *gin.Context) {
+	var req proto.SetScreenReq
+	var rsp proto.Response
+
+	if err := proto.ParseFormRequest(c, &req); err != nil {
+		rsp.ErrRsp(c, -1, "invalid arguments")
+		return
+	}
+
+	file, ok := screenFileMap[req.Type]
+	if !ok {
+		rsp.ErrRsp(c, -2, "invalid arguments")
+		return
+	}
+
+	data := fmt.Sprintf("%d", req.Value)
+	err := os.WriteFile(file, []byte(data), 0666)
+	if err != nil {
+		log.Errorf("write kvm %s failed: %s", file, err)
+		rsp.ErrRsp(c, -3, "update screen failed")
+		return
+	}
+
+	log.Debugf("update screen: %+v", req)
+	rsp.OkRsp(c)
+}
--- a/server/service/vm/script.go
+++ b/server/service/vm/script.go
@@ -0,0 +1,150 @@
+package vm
+
+import (
+	"NanoKVM-Server/proto"
+	"NanoKVM-Server/utils"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+)
+
+const ScriptDirectory = "/etc/kvm/scripts"
+
+func (s *Service) GetScripts(c *gin.Context) {
+	var rsp proto.Response
+
+	var files []string
+	err := filepath.Walk(ScriptDirectory, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if !info.IsDir() && isScript(info.Name()) {
+			files = append(files, info.Name())
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		log.Errorf("get scripts failed: %s", err)
+		rsp.ErrRsp(c, -1, "get scripts failed")
+		return
+	}
+
+	rsp.OkRspWithData(c, &proto.GetScriptsRsp{
+		Files: files,
+	})
+
+	log.Debugf("get scripts success")
+}
+
+func (s *Service) UploadScript(c *gin.Context) {
+	var rsp proto.Response
+
+	_, header, err := c.Request.FormFile("file")
+	if err != nil {
+		rsp.ErrRsp(c, -1, "bad request")
+		return
+	}
+
+	if !isScript(header.Filename) {
+		rsp.ErrRsp(c, -2, "invalid arguments")
+		return
+	}
+
+	if _, err = os.Stat(ScriptDirectory); err != nil {
+		_ = os.MkdirAll(ScriptDirectory, 0755)
+	}
+
+	target := fmt.Sprintf("%s/%s", ScriptDirectory, header.Filename)
+	err = c.SaveUploadedFile(header, target)
+	if err != nil {
+		rsp.ErrRsp(c, -2, "save failed")
+		return
+	}
+
+	_ = utils.EnsurePermission(target, 0100)
+
+	data := &proto.UploadScriptRsp{
+		File: header.Filename,
+	}
+	rsp.OkRspWithData(c, data)
+
+	log.Debugf("upload script %s success", header.Filename)
+}
+
+func (s *Service) RunScript(c *gin.Context) {
+	var req proto.RunScriptReq
+	var rsp proto.Response
+
+	if err := proto.ParseFormRequest(c, &req); err != nil {
+		rsp.ErrRsp(c, -1, "invalid arguments")
+		return
+	}
+
+	command := fmt.Sprintf("%s/%s", ScriptDirectory, req.Name)
+
+	name := strings.ToLower(req.Name)
+	if strings.HasSuffix(name, ".py") {
+		command = fmt.Sprintf("python %s", command)
+	}
+
+	var output []byte
+	var err error
+	cmd := exec.Command("sh", "-c", command)
+
+	if req.Type == "foreground" {
+		output, err = cmd.CombinedOutput()
+	} else {
+		cmd.Stdout = nil
+		cmd.Stderr = nil
+		go cmd.Run()
+	}
+
+	if err != nil {
+		log.Errorf("run script %s faile: %s", req.Name, err)
+		rsp.ErrRsp(c, -2, "run script failed")
+		return
+	}
+
+	rsp.OkRspWithData(c, &proto.RunScriptRsp{
+		Log: string(output),
+	})
+
+	log.Debugf("run script %s success", req.Name)
+}
+
+func (s *Service) DeleteScript(c *gin.Context) {
+	var req proto.DeleteScriptReq
+	var rsp proto.Response
+
+	if err := proto.ParseFormRequest(c, &req); err != nil {
+		rsp.ErrRsp(c, -1, "invalid arguments")
+		return
+	}
+
+	file := fmt.Sprintf("%s/%s", ScriptDirectory, req.Name)
+
+	if err := os.Remove(file); err != nil {
+		log.Errorf("delete script %s failed: %s", file, err)
+		rsp.ErrRsp(c, -3, "delete failed")
+		return
+	}
+
+	rsp.OkRsp(c)
+	log.Debugf("delete script %s success", file)
+}
+
+func isScript(name string) bool {
+	nameLower := strings.ToLower(name)
+	if strings.HasSuffix(nameLower, ".sh") || strings.HasSuffix(nameLower, ".py") {
+		return true
+	}
+
+	return false
+}
--- a/server/service/vm/service.go
+++ b/server/service/vm/service.go
@@ -0,0 +1,7 @@
+package vm
+
+type Service struct{}
+
+func NewService() *Service {
+	return &Service{}
+}
--- a/server/service/vm/terminal.go
+++ b/server/service/vm/terminal.go
@@ -0,0 +1,240 @@
+package vm
+
+import (
+	"NanoKVM-Server/utils"
+	"encoding/json"
+	"github.com/gin-gonic/gin"
+	"github.com/gorilla/websocket"
+	log "github.com/sirupsen/logrus"
+	"golang.org/x/crypto/ssh"
+	"io"
+	"net/http"
+	"os"
+	"time"
+)
+
+const (
+	messageWait    = 10 * time.Second
+	maxMessageSize = 1024
+)
+
+type WindowSize struct {
+	Height int `json:"height"`
+	Width  int `json:"width"`
+}
+
+type SshClient struct {
+	conn       *websocket.Conn
+	addr       string
+	user       string
+	password   string
+	client     *ssh.Client
+	session    *ssh.Session
+	sessionIn  io.WriteCloser
+	sessionOut io.Reader
+	closeSig   chan struct{}
+}
+
+var upgrader = websocket.Upgrader{
+	ReadBufferSize:  maxMessageSize,
+	WriteBufferSize: maxMessageSize,
+}
+
+var terminalModes = ssh.TerminalModes{
+	ssh.ECHO:          1,
+	ssh.TTY_OP_ISPEED: 14400,
+	ssh.TTY_OP_OSPEED: 14400,
+}
+
+func (s *SshClient) getWindowSize() (size *WindowSize, err error) {
+	_ = s.conn.SetReadDeadline(time.Now().Add(messageWait))
+
+	msgType, msg, err := s.conn.ReadMessage()
+	if err != nil {
+		log.Errorf("ws read message failed: %s", err)
+		return
+	}
+	if msgType != websocket.BinaryMessage {
+		log.Errorf("ws message type is not binary")
+		return
+	}
+
+	size = new(WindowSize)
+	if err = json.Unmarshal(msg, size); err != nil {
+		log.Errorf("unmarshal ws message failed: %s", err)
+		return
+	}
+
+	return
+}
+
+func (s *SshClient) wsWrite() error {
+	defer func() {
+		s.closeSig <- struct{}{}
+	}()
+
+	data := make([]byte, maxMessageSize)
+
+	for {
+		time.Sleep(10 * time.Millisecond)
+
+		n, err := s.sessionOut.Read(data)
+		if err != nil {
+			return err
+		}
+
+		if n > 0 {
+			_ = s.conn.SetWriteDeadline(time.Now().Add(messageWait))
+
+			err = s.conn.WriteMessage(websocket.BinaryMessage, data[:n])
+			if err != nil {
+				log.Errorf("write ws message failed: %s", err)
+				return err
+			}
+		}
+	}
+}
+
+func (s *SshClient) wsRead() error {
+	defer func() {
+		s.closeSig <- struct{}{}
+	}()
+
+	var zeroTime time.Time
+	_ = s.conn.SetReadDeadline(zeroTime)
+
+	for {
+		msgType, connReader, err := s.conn.NextReader()
+		if err != nil {
+			return err
+		}
+		if msgType != websocket.BinaryMessage {
+			_, err = io.Copy(s.sessionIn, connReader)
+			if err != nil {
+				log.Errorf("copy ws message failed: %s", err)
+				return err
+			}
+			continue
+		}
+
+		data := make([]byte, maxMessageSize)
+		n, err := connReader.Read(data)
+		if err != nil {
+			log.Errorf("read ws message failed: %s", err)
+			return err
+		}
+
+		var size WindowSize
+		err = json.Unmarshal(data[:n], &size)
+		if err != nil {
+			log.Errorf("unmarshal ws message failed: %s", err)
+			return err
+		}
+
+		err = s.session.WindowChange(size.Height, size.Width)
+		if err != nil {
+			log.Errorf("ws window change failed: %s", err)
+			return err
+		}
+	}
+}
+
+func (s *SshClient) bridgeWSAndSSH() {
+	defer func() {
+		_ = s.conn.Close()
+		if r := recover(); r != nil {
+			log.Debugf("terminal recover: %s", r)
+		}
+	}()
+
+	size, err := s.getWindowSize()
+	if err != nil {
+		return
+	}
+
+	auth := ssh.Password(s.password)
+	config := &ssh.ClientConfig{
+		User:            s.user,
+		Auth:            []ssh.AuthMethod{auth},
+		HostKeyCallback: ssh.InsecureIgnoreHostKey(),
+	}
+
+	s.client, err = ssh.Dial("tcp", s.addr, config)
+	if err != nil {
+		//log.Errorf("init ssh failed: %s", err)
+		return
+	}
+	defer s.client.Close()
+
+	s.session, err = s.client.NewSession()
+	if err != nil {
+		log.Errorf("open ssh session failed: %s", err)
+		return
+	}
+	defer s.session.Close()
+
+	s.session.Stderr = os.Stderr
+	s.sessionOut, err = s.session.StdoutPipe()
+	if err != nil {
+		log.Errorf("open ssh session out failed: %s", err)
+		return
+	}
+
+	s.sessionIn, err = s.session.StdinPipe()
+	if err != nil {
+		log.Errorf("open ssh session in failed: %s", err)
+		return
+	}
+	defer s.sessionIn.Close()
+
+	if err = s.session.RequestPty("xterm", size.Height, size.Width, terminalModes); err != nil {
+		log.Errorf("oen session request pty failed: %s", err)
+		return
+	}
+	if err = s.session.Shell(); err != nil {
+		log.Errorf("open ssh shell failed: %s", err)
+		return
+	}
+
+	go func() {
+		_ = s.wsRead()
+	}()
+
+	go func() {
+		_ = s.wsWrite()
+	}()
+
+	<-s.closeSig
+}
+
+func (s *Service) Terminal(c *gin.Context) {
+	user := c.Query("u")
+	if user == "" {
+		user = "root"
+	}
+
+	password, _ := utils.Decrypt(c.Query("t"))
+	if password == "" {
+		password = "root"
+	}
+
+	upgrader.CheckOrigin = func(r *http.Request) bool {
+		return true
+	}
+
+	conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
+	if err != nil {
+		log.Errorf("init websocket failed: %s", err)
+		return
+	}
+
+	sshClient := &SshClient{
+		conn:     conn,
+		addr:     "127.0.0.1:22",
+		user:     user,
+		password: password,
+		closeSig: make(chan struct{}, 1),
+	}
+
+	go sshClient.bridgeWSAndSSH()
+}
--- a/server/service/vm/virtual-device.go
+++ b/server/service/vm/virtual-device.go
@@ -0,0 +1,126 @@
+package vm
+
+import (
+	"NanoKVM-Server/proto"
+	"NanoKVM-Server/service/hid"
+	"errors"
+	"github.com/gin-gonic/gin"
+	log "github.com/sirupsen/logrus"
+	"os"
+	"os/exec"
+)
+
+const (
+	VirtualNetwork = "/boot/usb.rndis0"
+	VirtualDisk    = "/boot/usb.disk0"
+)
+
+var (
+	mountNetworkCommands = []string{
+		"touch /boot/usb.rndis0",
+		"/etc/init.d/S03usbdev stop",
+		"/etc/init.d/S03usbdev start",
+	}
+
+	unmountNetworkCommands = []string{
+		"/etc/init.d/S03usbdev stop",
+		"rm -rf /sys/kernel/config/usb_gadget/g0/configs/c.1/rndis.usb0",
+		"rm /boot/usb.rndis0",
+		"/etc/init.d/S03usbdev start",
+	}
+
+	mountDiskCommands = []string{
+		"touch /boot/usb.disk0",
+		"/etc/init.d/S03usbdev stop",
+		"/etc/init.d/S03usbdev start",
+	}
+
+	unmountDiskCommands = []string{
+		"/etc/init.d/S03usbdev stop",
+		"rm -rf /sys/kernel/config/usb_gadget/g0/configs/c.1/mass_storage.disk0",
+		"rm /boot/usb.disk0",
+		"/etc/init.d/S03usbdev start",
+	}
+)
+
+func (s *Service) GetVirtualDevice(c *gin.Context) {
+	var rsp proto.Response
+
+	network, _ := isDeviceExist(VirtualNetwork)
+	disk, _ := isDeviceExist(VirtualDisk)
+
+	rsp.OkRspWithData(c, &proto.GetVirtualDeviceRsp{
+		Network: network,
+		Disk:    disk,
+	})
+	log.Debugf("get virtual device success")
+}
+
+func (s *Service) UpdateVirtualDevice(c *gin.Context) {
+	var req proto.UpdateVirtualDeviceReq
+	var rsp proto.Response
+
+	if err := proto.ParseFormRequest(c, &req); err != nil {
+		rsp.ErrRsp(c, -1, "invalid argument")
+		return
+	}
+
+	var device string
+	var commands []string
+
+	if req.Device == "network" {
+		device = VirtualNetwork
+
+		exist, _ := isDeviceExist(device)
+		if !exist {
+			commands = mountNetworkCommands
+		} else {
+			commands = unmountNetworkCommands
+		}
+	} else if req.Device == "disk" {
+		device = VirtualDisk
+
+		exist, _ := isDeviceExist(device)
+		if !exist {
+			commands = mountDiskCommands
+		} else {
+			commands = unmountDiskCommands
+		}
+	} else {
+		rsp.ErrRsp(c, -2, "invalid arguments")
+		return
+	}
+
+	hid.Close()
+	defer hid.Open()
+
+	for _, command := range commands {
+		err := exec.Command("sh", "-c", command).Run()
+		if err != nil {
+			rsp.ErrRsp(c, -3, "operation failed")
+			return
+		}
+	}
+
+	on, _ := isDeviceExist(device)
+	rsp.OkRspWithData(c, &proto.UpdateVirtualDeviceRsp{
+		On: on,
+	})
+
+	log.Debugf("update virtual device %s success", req.Device)
+}
+
+func isDeviceExist(device string) (bool, error) {
+	_, err := os.Stat(device)
+
+	if err == nil {
+		return true, nil
+	}
+
+	if errors.Is(err, os.ErrNotExist) {
+		return false, nil
+	}
+
+	log.Errorf("check file %s err: %s", device, err)
+	return false, err
+}
--- a/server/service/ws/message.go
+++ b/server/service/ws/message.go
@@ -0,0 +1,6 @@
+package ws
+
+type Stream struct {
+	Type  string `json:"type"`
+	State int    `json:"state"`
+}
--- a/server/service/ws/service.go
+++ b/server/service/ws/service.go
@@ -0,0 +1,7 @@
+package ws
+
+type Service struct{}
+
+func NewService() *Service {
+	return &Service{}
+}
--- a/server/service/ws/watch.go
+++ b/server/service/ws/watch.go
@@ -0,0 +1,67 @@
+package ws
+
+import (
+	"encoding/json"
+	log "github.com/sirupsen/logrus"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+)
+
+const (
+	StreamState = "/kvmapp/kvm/state"
+)
+
+func watchStreamState(fileModMap map[string]time.Time) ([]byte, error) {
+	content, lastModTime, err := readFile(StreamState, fileModMap[StreamState])
+	fileModMap[StreamState] = lastModTime
+
+	if err != nil {
+		log.Errorf("read file %s failed: %s", StreamState, err)
+		return nil, err
+	}
+	if content == nil {
+		return nil, nil
+	}
+
+	contentStr := strings.ReplaceAll(string(content), "\n", "")
+	state, err := strconv.Atoi(contentStr)
+	if err != nil {
+		log.Errorf("parse stream state failed: %s", err)
+		return nil, err
+	}
+
+	message, err := json.Marshal(&Stream{
+		Type:  "stream",
+		State: state,
+	})
+	if err != nil {
+		log.Errorf("parse stream failed: %s", err)
+		return nil, err
+	}
+
+	return message, nil
+}
+
+func readFile(filename string, lastModTime time.Time) ([]byte, time.Time, error) {
+	file, err := os.Stat(filename)
+	if err != nil {
+		return nil, lastModTime, err
+	}
+
+	if !file.ModTime().After(lastModTime) {
+		return nil, lastModTime, nil
+	}
+
+	if lastModTime.Equal(time.Unix(0, 0)) {
+		return nil, file.ModTime(), nil
+	}
+
+	content, err := os.ReadFile(filename)
+	if err != nil {
+		return nil, file.ModTime(), err
+	}
+
+	return content, file.ModTime(), nil
+}
--- a/server/service/ws/ws.go
+++ b/server/service/ws/ws.go
@@ -0,0 +1,144 @@
+package ws
+
+import (
+	"NanoKVM-Server/service/hid"
+	"encoding/json"
+	"github.com/gin-gonic/gin"
+	"github.com/gorilla/websocket"
+	log "github.com/sirupsen/logrus"
+	"net/http"
+	"time"
+)
+
+const (
+	KeyboardEvent int = 1
+	MouseEvent    int = 2
+)
+
+type WsClient struct {
+	conn     *websocket.Conn
+	keyboard chan []int
+	mouse    chan []int
+	watcher  chan struct{}
+}
+
+var upgrader = websocket.Upgrader{
+	ReadBufferSize:  1024,
+	WriteBufferSize: 1024,
+	CheckOrigin: func(r *http.Request) bool {
+		return true
+	},
+}
+
+func (s *Service) Connect(c *gin.Context) {
+	conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
+	if err != nil {
+		log.Errorf("create websocket failed: %s", err)
+		return
+	}
+	log.Debug("websocket connected")
+
+	client := &WsClient{
+		conn:     conn,
+		keyboard: make(chan []int, 200),
+		mouse:    make(chan []int, 200),
+		watcher:  make(chan struct{}, 1),
+	}
+
+	go client.Start()
+}
+
+func (c *WsClient) Start() {
+	defer c.Clean()
+
+	hid.Open()
+
+	go hid.Keyboard(c.keyboard)
+	go hid.Mouse(c.mouse)
+
+	go c.Watch()
+
+	_ = c.Read()
+}
+
+func (c *WsClient) Read() error {
+	var zeroTime time.Time
+	_ = c.conn.SetReadDeadline(zeroTime)
+
+	for {
+		_, message, err := c.conn.ReadMessage()
+		if err != nil {
+			return err
+		}
+
+		log.Debugf("receive message: %s", message)
+
+		var event []int
+		err = json.Unmarshal(message, &event)
+		if err != nil {
+			log.Debugf("receive invalid message: %s", message)
+			continue
+		}
+
+		if event[0] == KeyboardEvent {
+			c.keyboard <- event[1:]
+		} else if event[0] == MouseEvent {
+			c.mouse <- event[1:]
+		}
+	}
+}
+
+func (c *WsClient) Write(message []byte) error {
+	_ = c.conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
+	return c.conn.WriteMessage(websocket.TextMessage, message)
+}
+
+func (c *WsClient) Watch() {
+	ticker := time.NewTicker(1 * time.Second)
+	defer ticker.Stop()
+
+	var fileModMap = map[string]time.Time{
+		StreamState: time.Unix(0, 0),
+	}
+
+	for {
+		select {
+		case <-ticker.C:
+			{
+				message, err := watchStreamState(fileModMap)
+				if err != nil || message == nil {
+					continue
+				}
+
+				err = c.Write(message)
+				if err != nil {
+					return
+				}
+			}
+
+		case <-c.watcher:
+			return
+		}
+	}
+}
+
+func (c *WsClient) Clean() {
+	_ = c.conn.Close()
+
+	go clearQueue(c.keyboard)
+	close(c.keyboard)
+
+	go clearQueue(c.mouse)
+	close(c.mouse)
+
+	close(c.watcher)
+
+	hid.Close()
+
+	log.Debug("websocket disconnected")
+}
+
+func clearQueue(queue chan []int) {
+	for range queue {
+	}
+}
--- a/server/utils/encrypt.go
+++ b/server/utils/encrypt.go
@@ -0,0 +1,35 @@
+package utils
+
+import (
+	"github.com/mervick/aes-everywhere/go/aes256"
+	log "github.com/sirupsen/logrus"
+	"net/url"
+)
+
+const EncryptSecretKey = "nanokvm-sipeed-2024"
+
+func Decrypt(ciphertext string) (string, error) {
+	defer func() {
+		if err := recover(); err != nil {
+			log.Errorf("decrypt failed: %s", err)
+		}
+	}()
+
+	if ciphertext == "" {
+		return "", nil
+	}
+
+	decrypt := aes256.Decrypt(ciphertext, EncryptSecretKey)
+
+	return decrypt, nil
+}
+
+func DecodeDecrypt(ciphertext string) (string, error) {
+	decode, err := url.QueryUnescape(ciphertext)
+	if err != nil {
+		log.Errorf("decode ciphertext failed: %s", err)
+		return "", err
+	}
+
+	return Decrypt(decode)
+}
--- a/server/utils/http.go
+++ b/server/utils/http.go
@@ -0,0 +1,42 @@
+package utils
+
+import (
+	"errors"
+	log "github.com/sirupsen/logrus"
+	"io"
+	"net/http"
+	"os"
+)
+
+func Download(req *http.Request, target string) error {
+	out, err := os.OpenFile(target, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0755)
+	if err != nil {
+		log.Errorf("create file %s err: %s", target, err)
+		return err
+	}
+	defer out.Close()
+
+	resp, err := (&http.Client{}).Do(req)
+	if err != nil {
+		log.Errorf("download file err: %s", err)
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return errors.New("request error")
+	}
+
+	contentType := resp.Header.Get("Content-Type")
+	if contentType != "application/octet-stream" && contentType != "application/zip" {
+		return errors.New("download error")
+	}
+
+	_, err = io.Copy(out, resp.Body)
+	if err != nil {
+		log.Errorf("download file to %s err: %s", target, err)
+		return err
+	}
+
+	return nil
+}
--- a/server/utils/permission.go
+++ b/server/utils/permission.go
@@ -0,0 +1,48 @@
+package utils
+
+import "os"
+
+func HasPermission(filePath string, perm os.FileMode) (bool, error) {
+	fileInfo, err := os.Stat(filePath)
+	if err != nil {
+		return false, err
+	}
+
+	mode := fileInfo.Mode().Perm()
+	if mode&perm == perm {
+		return true, nil
+	}
+
+	return false, nil
+}
+
+func AddPermission(filePath string, perm os.FileMode) error {
+	fileInfo, err := os.Stat(filePath)
+	if err != nil {
+		return err
+	}
+
+	mode := fileInfo.Mode() | perm
+	err = os.Chmod(filePath, mode)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func EnsurePermission(filePath string, perm os.FileMode) error {
+	hasPerm, err := HasPermission(filePath, perm)
+	if err != nil {
+		return err
+	}
+
+	if !hasPerm {
+		err = AddPermission(filePath, perm)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}