fix: 移除未使用的变量修复TypeScript编译错误

Merge pull request #11 from Sagit-chu/opencode/neon-rocket
feat: 简化用户隧道权限分配，支持多选隧道批量分配 (#8)
2026-09-28 23:56:36 +08:00 · 2026-02-03 15:55:30 +00:00 · 2026-02-03 23:28:55 +08:00 · 2026-02-03 15:16:43 +00:00 · 2026-02-03 14:43:34 +00:00 · 2026-02-03 13:59:05 +00:00
52 changed files with 3070 additions and 751 deletions
@@ -150,7 +150,11 @@ jobs:

      - name: Prepare build args
        run: |
-          echo "VITE_GITHUB_REPO=https://github.com/${{ github.repository }}" > ./vite-frontend/.env.production
+          VERSION="${{ needs.check-version.outputs.version }}"
+          {
+            echo "VITE_GITHUB_REPO=https://github.com/${{ github.repository }}"
+            echo "VITE_APP_VERSION=$VERSION"
+          } > ./vite-frontend/.env.production

      - name: Build and push Vite Docker images
        run: |
@@ -0,0 +1,9 @@
+---
+active: true
+iteration: 1
+max_iterations: 100
+completion_promise: "DONE"
+started_at: "2026-01-24T05:20:50.887Z"
+session_id: "ses_41192b7d7ffewFHxf1dDS7ESHO"
+---
+Complete the task as instructed
@@ -1,43 +1,66 @@
 # PROJECT KNOWLEDGE BASE

-**Generated:** Sat Jan 24 2026
-**Context:** Monorepo for Flux Panel (Traffic Forwarding)
+**Generated:** Mon Feb 02 2026
+**Commit:** 7ca01ab
+**Branch:** beta

 ## OVERVIEW
-Flux Panel is a traffic forwarding management system based on [go-gost](https://github.com/go-gost/gost). It manages tunnels, port forwarding, and user quotas.
-**Stack:** Monorepo (Java/Spring Boot Backend + React/Vite Frontend + Go/GOST Service).
+Flux Panel is a traffic forwarding management system built on a forked GOST v3 stack. It ships as Dockerized Spring Boot (admin API) + Vite/React UI + Go forwarding agent, with optional mobile WebView wrappers.

 ## STRUCTURE
 ```
-/root/flux-panel/
-├── springboot-backend/  # Java 21 + Spring Boot 2.7 Admin API
-├── vite-frontend/       # React 18 + Vite + HeroUI/NextUI
-├── go-gost/             # Go 1.23 + GOST Extensions (Core logic)
-├── docker-compose*.yml  # Deployment configs (v4/v6)
-└── *.sh                 # Install scripts (panel_install.sh, install.sh)
+./
+├── go-gost/               # Go forwarding agent (forked gost + local x/)
+│   └── x/                 # Local fork of github.com/go-gost/x (replace => ./x)
+├── springboot-backend/    # Java/Spring Boot admin API (SQLite/MyBatis)
+├── vite-frontend/         # React/Vite dashboard (HeroUI + Tailwind)
+├── android-app/           # Android WebView wrapper (optional)
+├── ios-app/               # iOS WebView wrapper (optional)
+├── docker-compose-v4.yml  # Panel deploy (IPv4-only bridge)
+├── docker-compose-v6.yml  # Panel deploy (IPv6-enabled bridge)
+├── panel_install.sh       # Panel installer/upgrader (downloads compose)
+├── install.sh             # Node installer/upgrader (downloads gost binary)
+└── .github/workflows/     # CI: build/push images + release artifacts
 ```

 ## WHERE TO LOOK
 | Task | Location | Notes |
 |------|----------|-------|
-| **Admin API** | `springboot-backend/` | Users, quotas, billing logic |
-| **UI/Dashboard** | `vite-frontend/` | Management console |
-| **Core Forwarding** | `go-gost/` | GOST implementation & extensions |
-| **Deploy** | `docker-compose-v4.yml` | Container orchestration |
+| **Deploy (Docker)** | `docker-compose-v4.yml` | Env: `JWT_SECRET`, `BACKEND_PORT`, `FRONTEND_PORT` |
+| **Deploy (IPv6)** | `docker-compose-v6.yml` | Same as v4 + IPv6-enabled bridge |
+| **Panel install** | `panel_install.sh` | Picks v4/v6, generates `JWT_SECRET`, downloads compose |
+| **Node install** | `install.sh` | Installs `/etc/flux_agent/flux_agent` + writes `config.json`/`gost.json` + systemd `flux_agent.service` |
+| **Admin API entry** | `springboot-backend/src/main/java/com/admin/AdminApplication.java` | Spring Boot app |
+| **Admin API routes** | `springboot-backend/src/main/java/com/admin/controller/` | Mostly `/api/v1/*` controllers |
+| **Admin auth** | `springboot-backend/src/main/java/com/admin/common/interceptor/JwtInterceptor.java` | Checks `Authorization` header |
+| **Web UI routing** | `vite-frontend/src/App.tsx` | React Router v6 + ProtectedRoute/H5 layouts |
+| **Web UI API client** | `vite-frontend/src/api/network.ts` | Axios `baseURL` + `Authorization` header |
+| **Go agent entry** | `go-gost/main.go` | Reads panel `config.json` + starts gost services |
+| **Go x fork** | `go-gost/x/` | Handlers/listeners/dialers + management API |

 ## CONVENTIONS
- **Monorepo**: 3 distinct languages/stacks. Treat each subdir as a separate project.
- **Docker**: Primary deployment method.
- **Scripts**: `panel_install.sh` for panel, `install.sh` for nodes.
+- `Authorization` header carries the raw JWT token (no `Bearer` prefix) between `vite-frontend/` and `springboot-backend/`.
+- `go-gost/` uses `replace github.com/go-gost/x => ./x` and `go-gost/x/` is also its own Go module.
+
+## ANTI-PATTERNS (THIS PROJECT)
+- Do not edit generated protobuf output: `go-gost/x/internal/util/grpc/proto/*.pb.go`, `go-gost/x/internal/util/grpc/proto/*_grpc.pb.go`.

 ## COMMANDS
 ```bash
-# Quick Deploy (Panel)
-./panel_install.sh
+# Panel (Docker)
+docker compose -f docker-compose-v4.yml up -d
+docker compose -f docker-compose-v6.yml up -d

-# Quick Deploy (Node)
+# Release-based install scripts
+./panel_install.sh
 ./install.sh

-# Docker
-docker-compose -f docker-compose-v4.yml up -d
+# Local dev (per subproject)
+(cd springboot-backend && mvn clean package)
+(cd vite-frontend && npm run dev)
+(cd go-gost && go run .)
 ```
+
+## NOTES
+- LSP servers are not installed in this environment (gopls/jdtls/typescript-language-server); rely on grep-based navigation.
+- `vite-frontend/vite.config.ts` sets `minify: false` and disables treeshake; expect larger bundles.
@@ -66,4 +66,14 @@ curl -L https://raw.githubusercontent.com/Sagit-chu/flux-panel/beta/install.sh -
 作者对因使用本项目所造成的任何直接或间接损失概不负责，亦不提供任何形式的担保、承诺或技术支持。  


-请务必在合法、合规、安全的前提下使用本项目。
+请务必在合法、合规、安全的前提下使用本项目。
+
+---
+## ⭐ 喝杯咖啡！（USDT）
+
+| 网络       | 地址                                                                 |
+|------------|----------------------------------------------------------------------|
+| BNB(BEP20) | `0xa608708fdc6279a2433fd4b82f0b72b8cbe97ed5`                          |
+| TRC20      | `TM8VYdU3s3gSX5PC8swjAJrAzZFCHKqG2k`                                  |
+| Aptos      | `0x49427bfcba1006a346447430689b2307ac156316bb34850d1d3029ff9d118da5`  |
+| polygon    |  `0xa608708fdc6279a2433fd4b82f0b72b8cbe97ed5`    |
@@ -1,31 +1,37 @@
 # GO-GOST SERVICE KNOWLEDGE BASE

+**Generated:** Mon Feb 02 2026
+
 ## OVERVIEW
-Core forwarding service based on GOST v3.
-**Stack:** Go 1.23, GOST Core v0.3.1, GOST x (Extensions).
+Forwarding agent built on GOST v3 with a local fork of `github.com/go-gost/x` under `x/`.
+**Stack:** Go 1.23, github.com/go-gost/core v0.3.1, local `go-gost/x` module.

 ## STRUCTURE
 ```
 go-gost/
-├── main.go           # Entry point
-├── x/                # Local extensions (REPLACES github.com/go-gost/x)
-│   ├── api/          # Management API
-│   ├── registry/     # Service registry
-│   ├── handler/      # Protocol handlers (socks, tunnel, relay)
-│   └── listener/     # Network listeners (tcp, udp, tun/tap)
-└── go.mod            # Defines local replacement
+├── main.go           # Entry; reads panel config.json; starts svc.Run(program)
+├── config.go         # Panel config.json loader (addr/secret + ports)
+├── program.go        # GOST runtime: parse config, run/reload services
+├── x/                # Local fork of github.com/go-gost/x (has its own go.mod)
+└── go.mod            # replace github.com/go-gost/x => ./x
 ```

+## WHERE TO LOOK
+| Task | Location | Notes |
+|------|----------|-------|
+| Panel integration config | `go-gost/config.go` | Expects `config.json` in cwd by default |
+| Service lifecycle/reload | `go-gost/program.go` | Parses config; handles SIGHUP reload |
+| WebSocket reporting | `go-gost/main.go` | Starts reporter + sets HTTP report URL |
+| Protocol behaviors | `go-gost/x/` | Handlers/listeners/dialers live here |
+
 ## CONVENTIONS
- **Local Replace**: `go.mod` uses `replace github.com/go-gost/x => ./x`.
- **Extensions**: Custom logic lives in `x/`. This is the primary place for modifications.
- **Handlers**: Implements SOCKS5, Tunnel, Relay, etc.
+- Two configs exist: panel integration uses `config.json`; forwarding services use GOST config (defaults to `gost.{json,yaml}` via viper search paths).
+- `go-gost/x/` is the primary extension surface; avoid editing vendored deps.

 ## COMMANDS
 ```bash
-# Run
+cd go-gost
 go run .
-
-# Build
+go test ./...
 go build .
 ```
@@ -0,0 +1,42 @@
+# GO-GOST/X KNOWLEDGE BASE
+
+## OVERVIEW
+Local fork of `github.com/go-gost/x` used by `go-gost/` via `replace github.com/go-gost/x => ./x`. Most protocol/runtime behavior changes happen here.
+
+## STRUCTURE
+```
+go-gost/x/
+├── api/        # Gin management API + embedded swagger docs
+├── config/     # Config model + parsing/load/reload
+├── connector/  # Outbound connect implementations
+├── dialer/     # Outbound dialers (tcp/tls/ws/quic/...) 
+├── handler/    # Protocol handlers (socks/http/tunnel/relay/...)
+├── listener/   # Inbound listeners (tcp/udp/tun/tap/redirect/...)
+├── limiter/    # Traffic/rate/conn limiters
+├── registry/   # Registries for services/handlers/listeners/etc
+├── service/    # Service wrappers + reporting hooks
+├── socket/     # WebSocket reporter / panel integration
+└── internal/   # Shared internals (grpc proto, net utils, sniffing, tls, ...)
+```
+
+## WHERE TO LOOK
+| Task | Location | Notes |
+|------|----------|-------|
+| Management API routes/auth | `go-gost/x/api/api.go` | `/docs`, `/config/*`; BasicAuth + interceptor |
+| Service config parsing | `go-gost/x/config/parsing/` | Converts config to running services |
+| Add a handler | `go-gost/x/handler/` | Per-protocol subdirs |
+| Add a listener/dialer | `go-gost/x/listener/`, `go-gost/x/dialer/` | Transport variants |
+| Panel reporting | `go-gost/x/socket/` | WebSocket + HTTP report URL hooks |
+
+## CONVENTIONS
+- `go-gost/x/` is a standalone Go module (`go-gost/x/go.mod`); run go tooling from this dir when debugging module resolution.
+- Generated gRPC/proto code lives under `go-gost/x/internal/util/grpc/proto/`.
+
+## ANTI-PATTERNS
+- Do not edit generated files in `go-gost/x/internal/util/grpc/proto/` (`*.pb.go`, `*_grpc.pb.go`).
+
+## COMMANDS
+```bash
+cd go-gost/x
+go test ./...
+```
@@ -0,0 +1,23 @@
+# GO-GOST/X API KNOWLEDGE BASE
+
+## OVERVIEW
+Gin-based management API for reading/writing config and controlling services at runtime.
+
+## WHERE TO LOOK
+| Task | Location | Notes |
+|------|----------|-------|
+| Route registration | `go-gost/x/api/api.go` | `Register(*gin.Engine, *Options)` |
+| Auth gating | `go-gost/x/api/middleware.go` | Drops non-BasicAuth requests; optional auther check |
+| Service CRUD + pause/resume | `go-gost/x/api/config_service.go` | Uses registry + `config.OnUpdate(...)` |
+| Swagger spec | `go-gost/x/api/swagger.yaml` | Served at `/docs` via embedded FS |
+
+## CONVENTIONS
+- CORS is `AllowAllOrigins: true` (see `go-gost/x/api/api.go`).
+- Requests without a valid Basic `Authorization` header are silently dropped (connection hijack + close) by `GlobalInterceptor()`.
+- Many operations mutate the in-memory config via `config.OnUpdate(...)` after starting/stopping services.
+
+## COMMANDS
+```bash
+cd go-gost/x
+go test ./...
+```
@@ -0,0 +1,23 @@
+# GO-GOST/X CONFIG KNOWLEDGE BASE
+
+## OVERVIEW
+Config model + parsing/loading pipeline for the `go-gost/x` runtime. This is the bridge between `gost.json`/`gost.yaml` and in-memory registries/services.
+
+## WHERE TO LOOK
+| Task | Location | Notes |
+|------|----------|-------|
+| Config structs + global state | `go-gost/x/config/config.go` | `Global()`, `Set()`, `OnUpdate()` |
+| Default config file search | `go-gost/x/config/config.go` | Viper `SetConfigName("gost")` + paths `/etc/gost/`, `$HOME/.gost/`, `.` |
+| Registry wiring | `go-gost/x/config/loader/loader.go` | Parses config sections and registers into registries |
+| Metadata keys | `go-gost/x/config/parsing/parse.go` | `MDKey*` constants used by parsers |
+| Config parser behavior | `go-gost/x/config/parsing/parser/parser.go` | CLI/env overrides; loads `gost.*` when empty |
+
+## CONVENTIONS
+- Default config file is named `gost` (e.g. `gost.json`) and is discovered via viper search paths.
+- Runtime config mutations should go through `config.OnUpdate(...)` so changes are applied under the global mutex.
+
+## COMMANDS
+```bash
+cd go-gost/x
+go test ./...
+```
@@ -0,0 +1,35 @@
+# GO-GOST/X DIALERS KNOWLEDGE BASE
+
+## OVERVIEW
+Outbound dialers (client-side connection establishment) used by connectors/handlers.
+
+## STRUCTURE
+```
+go-gost/x/dialer/
+├── direct/   # Baseline dialer
+├── tcp/
+├── udp/
+├── tls/
+├── ws/
+├── quic/
+├── http2/
+├── http3/
+├── ssh/
+├── wg/       # WireGuard dialer
+└── ...
+```
+
+## WHERE TO LOOK
+| Task | Location | Notes |
+|------|----------|-------|
+| Pick a dialer | `go-gost/x/dialer/` | One subdir per transport |
+| TCP baseline | `go-gost/x/dialer/tcp/dialer.go` | Reference implementation |
+
+## CONVENTIONS
+- Dialer implementations typically live in `dialer.go` with a paired `metadata.go` (e.g. `go-gost/x/dialer/tcp/`).
+
+## COMMANDS
+```bash
+cd go-gost/x
+go test ./...
+```
@@ -0,0 +1,32 @@
+# GO-GOST/X HANDLERS KNOWLEDGE BASE
+
+## OVERVIEW
+Protocol handlers (server-side request handling) used by services defined in the GOST config.
+
+## STRUCTURE
+```
+go-gost/x/handler/
+├── http/     # handler.go + metadata.go (+ udp.go)
+├── socks/    # SOCKS variants
+├── tunnel/   # Tunnel forwarding
+├── relay/    # Relay forwarding
+├── redirect/ # TCP/UDP redirect handlers
+├── router/   # Routing/association entrypoints
+└── ...
+```
+
+## WHERE TO LOOK
+| Task | Location | Notes |
+|------|----------|-------|
+| Find a protocol handler | `go-gost/x/handler/` | Subdir per protocol (`http`, `socks`, `tunnel`, ...) |
+| HTTP specifics | `go-gost/x/handler/http/handler.go` | Implements HTTP proxy behavior |
+| SOCKS specifics | `go-gost/x/handler/socks/` | v4/v5 implementations |
+
+## CONVENTIONS
+- Handler implementations typically live in `handler.go` with a paired `metadata.go` (e.g. `go-gost/x/handler/http/`).
+
+## COMMANDS
+```bash
+cd go-gost/x
+go test ./...
+```
@@ -0,0 +1,35 @@
+# GO-GOST/X LISTENERS KNOWLEDGE BASE
+
+## OVERVIEW
+Inbound listeners (transport-level accept loops) used by services defined in the GOST config.
+
+## STRUCTURE
+```
+go-gost/x/listener/
+├── tcp/      # listener.go + metadata.go
+├── udp/
+├── tls/
+├── ws/
+├── quic/
+├── redirect/ # tcp/ + udp/
+├── tun/      # TUN device listener
+├── tap/      # TAP device listener
+└── ...
+```
+
+## WHERE TO LOOK
+| Task | Location | Notes |
+|------|----------|-------|
+| Listener registry | `go-gost/x/listener/` | One subdir per transport |
+| TCP baseline | `go-gost/x/listener/tcp/listener.go` | Reference for other transports |
+| Redirect listeners | `go-gost/x/listener/redirect/` | Per-protocol accept + redirect |
+| TUN/TAP | `go-gost/x/listener/tun/`, `go-gost/x/listener/tap/` | Virtual interface listeners |
+
+## CONVENTIONS
+- Listener implementations typically live in `listener.go` with a paired `metadata.go` (e.g. `go-gost/x/listener/tcp/`).
+
+## COMMANDS
+```bash
+cd go-gost/x
+go test ./...
+```
@@ -1,5 +1,8 @@
 #!/bin/bash

+# GitHub repo used for release downloads
+REPO="Sagit-chu/flux-panel"
+
 # 获取系统架构
 get_architecture() {
    ARCH=$(uname -m)
@@ -16,20 +19,90 @@ get_architecture() {
    esac
 }

+# 安装目录
+INSTALL_DIR="/etc/flux_agent"
+
+# 识别国家（用于镜像加速）
+COUNTRY=$(curl -s https://ipinfo.io/country)
+
+maybe_proxy_url() {
+  local url="$1"
+  if [ "$COUNTRY" = "CN" ]; then
+    echo "https://ghfast.top/${url}"
+  else
+    echo "$url"
+  fi
+}
+
+resolve_latest_release_tag() {
+  local effective_url tag api_tag latest_url api_url
+
+  latest_url="https://github.com/${REPO}/releases/latest"
+  api_url="https://api.github.com/repos/${REPO}/releases/latest"
+
+  # 方式1：跟随重定向，取最终 URL 的最后一段作为 tag
+  effective_url=$(curl -fsSL -o /dev/null -w '%{url_effective}' -L "$latest_url" 2>/dev/null || true)
+  tag="${effective_url##*/}"
+  if [[ -n "$tag" && "$tag" != "latest" ]]; then
+    echo "$tag"
+    return 0
+  fi
+
+  # CN 环境下可尝试通过镜像访问（不影响非 CN）
+  if [ "$COUNTRY" = "CN" ]; then
+    effective_url=$(curl -fsSL -o /dev/null -w '%{url_effective}' -L "$(maybe_proxy_url "$latest_url")" 2>/dev/null || true)
+    tag="${effective_url##*/}"
+    if [[ -n "$tag" && "$tag" != "latest" ]]; then
+      echo "$tag"
+      return 0
+    fi
+  fi
+
+  # 方式2：GitHub API（无需 jq）
+  api_tag=$(curl -fsSL "$api_url" 2>/dev/null | grep -m1 '"tag_name"' | sed -E 's/.*"tag_name"[[:space:]]*:[[:space:]]*"([^"]+)".*/\1/' || true)
+  if [[ -n "$api_tag" ]]; then
+    echo "$api_tag"
+    return 0
+  fi
+
+  if [ "$COUNTRY" = "CN" ]; then
+    api_tag=$(curl -fsSL "$(maybe_proxy_url "$api_url")" 2>/dev/null | grep -m1 '"tag_name"' | sed -E 's/.*"tag_name"[[:space:]]*:[[:space:]]*"([^"]+)".*/\1/' || true)
+    if [[ -n "$api_tag" ]]; then
+      echo "$api_tag"
+      return 0
+    fi
+  fi
+
+  return 1
+}
+
+resolve_version() {
+  if [[ -n "${VERSION:-}" ]]; then
+    echo "$VERSION"
+    return 0
+  fi
+  if [[ -n "${FLUX_VERSION:-}" ]]; then
+    echo "$FLUX_VERSION"
+    return 0
+  fi
+
+  if resolve_latest_release_tag; then
+    return 0
+  fi
+
+  echo "❌ 无法获取最新版本号。你可以手动指定版本，例如：VERSION=<版本号> ./install.sh" >&2
+  return 1
+}
+
 # 构建下载地址
 build_download_url() {
    local ARCH=$(get_architecture)
-    echo "https://github.com/bqlpfy/flux-panel/releases/download/2.0.7-beta/gost-${ARCH}"
+    echo "https://github.com/${REPO}/releases/download/${RESOLVED_VERSION}/gost-${ARCH}"
 }

-# 下载地址
-DOWNLOAD_URL=$(build_download_url)
-INSTALL_DIR="/etc/flux_agent"
-COUNTRY=$(curl -s https://ipinfo.io/country)
-if [ "$COUNTRY" = "CN" ]; then
-    # 拼接 URL
-    DOWNLOAD_URL="https://ghfast.top/${DOWNLOAD_URL}"
-fi
+# 解析版本并构建下载地址
+RESOLVED_VERSION=$(resolve_version) || exit 1
+DOWNLOAD_URL=$(maybe_proxy_url "$(build_download_url)")



@@ -365,4 +438,4 @@ main() {
 }

 # 执行主函数
-main
+main
@@ -7,16 +7,82 @@ export LC_ALL=C



-# 全局下载地址配置
-DOCKER_COMPOSEV4_URL="https://github.com/bqlpfy/flux-panel/releases/download/2.0.7-beta/docker-compose-v4.yml"
-DOCKER_COMPOSEV6_URL="https://github.com/bqlpfy/flux-panel/releases/download/2.0.7-beta/docker-compose-v6.yml"
+# GitHub repo used for release downloads
+REPO="Sagit-chu/flux-panel"

 COUNTRY=$(curl -s https://ipinfo.io/country)
-if [ "$COUNTRY" = "CN" ]; then
-    # 拼接 URL
-    DOCKER_COMPOSEV4_URL="https://ghfast.top/${DOCKER_COMPOSEV4_URL}"
-    DOCKER_COMPOSEV6_URL="https://ghfast.top/${DOCKER_COMPOSEV6_URL}"
-fi
+
+maybe_proxy_url() {
+  local url="$1"
+  if [ "$COUNTRY" = "CN" ]; then
+    echo "https://ghfast.top/${url}"
+  else
+    echo "$url"
+  fi
+}
+
+resolve_latest_release_tag() {
+  local effective_url tag api_tag latest_url api_url
+
+  latest_url="https://github.com/${REPO}/releases/latest"
+  api_url="https://api.github.com/repos/${REPO}/releases/latest"
+
+  effective_url=$(curl -fsSL -o /dev/null -w '%{url_effective}' -L "$latest_url" 2>/dev/null || true)
+  tag="${effective_url##*/}"
+  if [[ -n "$tag" && "$tag" != "latest" ]]; then
+    echo "$tag"
+    return 0
+  fi
+
+  if [ "$COUNTRY" = "CN" ]; then
+    effective_url=$(curl -fsSL -o /dev/null -w '%{url_effective}' -L "$(maybe_proxy_url "$latest_url")" 2>/dev/null || true)
+    tag="${effective_url##*/}"
+    if [[ -n "$tag" && "$tag" != "latest" ]]; then
+      echo "$tag"
+      return 0
+    fi
+  fi
+
+  api_tag=$(curl -fsSL "$api_url" 2>/dev/null | grep -m1 '"tag_name"' | sed -E 's/.*"tag_name"[[:space:]]*:[[:space:]]*"([^"]+)".*/\1/' || true)
+  if [[ -n "$api_tag" ]]; then
+    echo "$api_tag"
+    return 0
+  fi
+
+  if [ "$COUNTRY" = "CN" ]; then
+    api_tag=$(curl -fsSL "$(maybe_proxy_url "$api_url")" 2>/dev/null | grep -m1 '"tag_name"' | sed -E 's/.*"tag_name"[[:space:]]*:[[:space:]]*"([^"]+)".*/\1/' || true)
+    if [[ -n "$api_tag" ]]; then
+      echo "$api_tag"
+      return 0
+    fi
+  fi
+
+  return 1
+}
+
+resolve_version() {
+  if [[ -n "${VERSION:-}" ]]; then
+    echo "$VERSION"
+    return 0
+  fi
+  if [[ -n "${FLUX_VERSION:-}" ]]; then
+    echo "$FLUX_VERSION"
+    return 0
+  fi
+
+  if resolve_latest_release_tag; then
+    return 0
+  fi
+
+  echo "❌ 无法获取最新版本号。你可以手动指定版本，例如：VERSION=<版本号> ./panel_install.sh" >&2
+  return 1
+}
+
+# 全局下载地址配置（默认获取最新版本；也可用 VERSION=... 覆盖）
+RESOLVED_VERSION=$(resolve_version) || exit 1
+
+DOCKER_COMPOSEV4_URL=$(maybe_proxy_url "https://github.com/${REPO}/releases/download/${RESOLVED_VERSION}/docker-compose-v4.yml")
+DOCKER_COMPOSEV6_URL=$(maybe_proxy_url "https://github.com/${REPO}/releases/download/${RESOLVED_VERSION}/docker-compose-v6.yml")



@@ -0,0 +1,3 @@
+<factorypath>
+    <factorypathentry kind="VARJAR" id="M2_REPO/org/projectlombok/lombok/1.18.30/lombok-1.18.30.jar" enabled="true" runInBatchMode="false"/>
+</factorypath>
@@ -1,37 +1,39 @@
 # SPRINGBOOT BACKEND KNOWLEDGE BASE

+**Generated:** Mon Feb 02 2026
+
 ## OVERVIEW
-Admin API for Flux Panel. Manages users, licenses, and traffic rules.
-**Stack:** Java 21, Spring Boot 2.7.18, SQLite, MyBatis Plus.
+Admin API for Flux Panel. Manages users, tunnels, nodes, forwards, quotas, and speed limits.
+**Stack:** Java 21, Spring Boot 2.7.18, SQLite, MyBatis Plus (+ join), FastJSON2.

 ## STRUCTURE
 ```
 springboot-backend/
 ├── src/main/java/com/admin/
-│   ├── controller/      # API Endpoints
-│   ├── entity/          # DB Models (MyBatis Plus)
-│   ├── mapper/          # Data Access
-│   ├── service/         # Business Logic
-│   └── common/          # Utils, DTOs
+│   ├── controller/      # /api/v1/* endpoints
+│   ├── entity/          # DB models
+│   ├── mapper/          # MyBatis Plus mappers
+│   ├── service/         # Business logic
+│   ├── config/          # WebMvc/JWT/CORS/WebSocket config
+│   └── common/          # DTOs, auth, exception handling, utilities
 └── src/main/resources/
-    ├── application.yml  # Config
-    ├── mapper/          # XML Mappers
-    ├── data.sql         # Init data
-    └── bgimages/        # Static resources
+    ├── application.yml  # Config (DB_PATH/JWT_SECRET/LOG_DIR)
+    ├── mapper/          # XML mappers
+    ├── schema.sql       # Schema
+    └── data.sql         # Seed data
 ```

 ## CONVENTIONS
- **DB**: SQLite used via `sqlite-jdbc`.
- **ORM**: MyBatis Plus + MyBatis Plus Join.
- **JSON**: FastJSON2 used for serialization.
- **Utils**: Hutool used extensively.
- **Auth**: Likely custom or token-based (see `controller` logic).
+- **DB**: SQLite URL is `jdbc:sqlite:${DB_PATH:/app/data/gost.db}` (`springboot-backend/src/main/resources/application.yml`).
+- **Auth**: JWT in `Authorization` header; enforced by `com.admin.common.interceptor.JwtInterceptor` for `/api/**` (with explicit excludes in `com.admin.config.WebMvcConfig`).
+- **Roles**: `@RequireRole` means admin-only (`role_id == 0`) via `com.admin.common.aop.RoleAspect`.
+- **Responses**: Controllers return `com.admin.common.lang.R` (`code == 0` success).
+- **CORS**: Allow-all origins; `Authorization` is exposed (`com.admin.config.WebMvcConfig`).

 ## COMMANDS
 ```bash
-# Build
+cd springboot-backend
 mvn clean package
-
-# Run
+mvn test
 java -jar target/admin-0.0.1-SNAPSHOT.jar
 ```
@@ -0,0 +1,32 @@
+# SPRINGBOOT BACKEND (com.admin) KNOWLEDGE BASE
+
+## OVERVIEW
+Primary Java code for the admin API. Controllers expose `/api/v1/*` endpoints and return `R` response envelopes.
+
+## STRUCTURE
+```
+springboot-backend/src/main/java/com/admin/
+├── controller/  # REST controllers (e.g., /api/v1/user)
+├── service/     # Business logic interfaces + impl/
+├── mapper/      # MyBatis Plus mappers
+├── entity/      # DB entities
+├── config/      # WebMvc/JWT/CORS/WebSocket config
+└── common/      # DTOs, auth, exception handling, utilities
+```
+
+## WHERE TO LOOK
+| Task | Location | Notes |
+|------|----------|-------|
+| User/login endpoints | `springboot-backend/src/main/java/com/admin/controller/UserController.java` | `/api/v1/user/*` |
+| Auth enforcement | `springboot-backend/src/main/java/com/admin/config/WebMvcConfig.java` | Intercepts `/api/**`, excludes login/config/captcha |
+| JWT validation | `springboot-backend/src/main/java/com/admin/common/interceptor/JwtInterceptor.java` | Requires `Authorization` header |
+| Admin-only ops | `springboot-backend/src/main/java/com/admin/common/annotation/RequireRole.java` | Enforced by `RoleAspect` |
+| Response envelope | `springboot-backend/src/main/java/com/admin/common/lang/R.java` | `code == 0` success |
+| Global error handling | `springboot-backend/src/main/java/com/admin/common/exception/GlobalExceptionHandler.java` | Maps exceptions -> `R.err(...)` |
+
+## CONVENTIONS
+- Controllers are mostly `@PostMapping` (even for list/get/delete) and use `/api/v1/*` prefixes.
+- JWT is custom (no 3p lib) and includes `role_id` in payload (`springboot-backend/src/main/java/com/admin/common/utils/JwtUtil.java`).
+
+## ANTI-PATTERNS
+- Do not change auth header format lightly: frontend expects `Authorization: <token>` (no `Bearer`).
@@ -20,6 +20,8 @@ public class ForwardUpdateDto {
    @NotBlank(message = "转发名称不能为空")
    private String name;

+    private Integer tunnelId;
+
    @NotBlank(message = "远程地址不能为空")
    private String remoteAddr;

@@ -16,6 +16,10 @@ public class NodeDto {
    @NotBlank(message = "服务器ip不能为空")
    private String serverIp;

+    private String serverIpV4;
+
+    private String serverIpV6;
+
    @NotBlank(message = "可用端口不能为空")
    private String port;

@@ -25,4 +29,4 @@ public class NodeDto {

    private String udpListenAddr = "0.0.0.0";

-} 
+} 
@@ -17,6 +17,10 @@ public class NodeUpdateDto {
    @NotBlank(message = "服务器ip不能为空")
    private String serverIp;

+    private String serverIpV4;
+
+    private String serverIpV6;
+
    @NotBlank(message = "可用port不能为空")
    private String port;

@@ -28,4 +32,4 @@ public class NodeUpdateDto {
    private String tcpListenAddr = "0.0.0.0";

    private String udpListenAddr = "0.0.0.0";
-} 
+} 
@@ -14,6 +14,12 @@ import java.util.List;
 public class TunnelDetailDto {
    
    private Long id;
+
+    /**
+     * Display/order index for drag-sorting in admin UI.
+     * Lower value appears first.
+     */
+    private Integer inx;
    
    private String name;
    
@@ -40,4 +46,3 @@ public class TunnelDetailDto {
    // 出口节点列表
    private List<ChainTunnel> outNodeId = new ArrayList<>();
 }
-
@@ -0,0 +1,26 @@
+package com.admin.common.dto;
+
+import lombok.Data;
+import javax.validation.Valid;
+import javax.validation.constraints.NotNull;
+import javax.validation.constraints.NotEmpty;
+import java.util.List;
+
+@Data
+public class UserTunnelBatchAssignDto {
+    
+    @NotNull(message = "用户ID不能为空")
+    private Integer userId;
+    
+    @Valid
+    @NotEmpty(message = "隧道列表不能为空")
+    private List<TunnelAssignItem> tunnels;
+    
+    @Data
+    public static class TunnelAssignItem {
+        @NotNull(message = "隧道ID不能为空")
+        private Integer tunnelId;
+        
+        private Integer speedId;
+    }
+}
@@ -13,28 +13,15 @@ public class UserTunnelDto {
    @NotNull(message = "隧道ID不能为空")
    private Integer tunnelId;
    
-    @NotNull(message = "流量限制不能为空")
    @Min(value = 0, message = "流量限制不能小于0")
    private Long flow;
    
-    @NotNull(message = "转发数量不能为空")
    @Min(value = 0, message = "转发数量不能小于0")
    private Integer num;
    
-    /**
-     * 流量重置时间（时间戳）
-     */
-    @NotNull(message = "流量重置时间不能为空")
    private Long flowResetTime;
    
-    /**
-     * 到期时间（时间戳）
-     */
-    @NotNull(message = "到期时间不能为空")
    private Long expTime;
    
-    /**
-     * 限速规则ID（可选，null表示不限速）
-     */
    private Integer speedId;
-} 
+}
@@ -0,0 +1,54 @@
+package com.admin.common.migration;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.boot.ApplicationArguments;
+import org.springframework.boot.ApplicationRunner;
+import org.springframework.core.Ordered;
+import org.springframework.core.annotation.Order;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Component;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Lightweight SQLite schema migration.
+ *
+ * Spring Boot SQL init uses CREATE TABLE IF NOT EXISTS, so existing installations
+ * won't automatically receive new columns. This runner adds missing columns in-place.
+ */
+@Slf4j
+@Component
+@Order(Ordered.HIGHEST_PRECEDENCE)
+public class SqliteSchemaMigration implements ApplicationRunner {
+
+    private final JdbcTemplate jdbcTemplate;
+
+    public SqliteSchemaMigration(JdbcTemplate jdbcTemplate) {
+        this.jdbcTemplate = jdbcTemplate;
+    }
+
+    @Override
+    public void run(ApplicationArguments args) {
+        ensureColumn("node", "inx", "INTEGER NOT NULL DEFAULT 0");
+        ensureColumn("tunnel", "inx", "INTEGER NOT NULL DEFAULT 0");
+    }
+
+    private void ensureColumn(String table, String column, String columnDefinition) {
+        Set<String> columns = new HashSet<>(
+                jdbcTemplate.query(
+                        "PRAGMA table_info(" + table + ")",
+                        (rs, rowNum) -> rs.getString("name")
+                )
+        );
+
+        if (columns.contains(column)) {
+            return;
+        }
+
+        log.info("Adding missing column {}.{}", table, column);
+        jdbcTemplate.execute(
+                "ALTER TABLE " + table + " ADD COLUMN " + column + " " + columnDefinition
+        );
+    }
+}
@@ -7,6 +7,7 @@ import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONObject;
 import org.apache.commons.lang3.StringUtils;

+import java.util.regex.Pattern;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -43,6 +44,7 @@ public class GostUtil {

    public static GostDto AddChains(Long node_id, List<ChainTunnel> chainTunnels, Map<Long, Node> node_s) {
        JSONArray nodes = new JSONArray();
+        Node fromNode = node_s.get(node_id);
        for (ChainTunnel chainTunnel : chainTunnels) {
            JSONObject dialer = new JSONObject();
            dialer.put("type", chainTunnel.getProtocol());
@@ -53,7 +55,11 @@ public class GostUtil {
            Node node_info = node_s.get(chainTunnel.getNodeId());
            JSONObject node = new JSONObject();
            node.put("name", "node_" + chainTunnel.getInx());
-            node.put("addr", processServerAddress(node_info.getServerIp() + ":" + chainTunnel.getPort()));
+
+            String dialHost = (fromNode != null && node_info != null)
+                    ? selectDialHost(fromNode, node_info)
+                    : (node_info != null ? node_info.getServerIp() : null);
+            node.put("addr", processServerAddress(dialHost + ":" + chainTunnel.getPort()));
            node.put("connector", connector);
            node.put("dialer", dialer);

@@ -291,4 +297,115 @@ public class GostUtil {
        long colonCount = address.chars().filter(ch -> ch == ':').count();
        return colonCount >= 2;
    }
+
+    /**
+     * v4 优先：当两端都有 v4 时选择 v4，否则尝试 v6。
+     * 用于节点之间建立链路（A -> B 需要选择 B 的地址族，且 A 需要支持该地址族）。
+     */
+    public static String selectDialHost(Node fromNode, Node toNode) {
+        if (fromNode == null || toNode == null) {
+            throw new IllegalArgumentException("node is null");
+        }
+
+        boolean fromV4 = supportsV4(fromNode);
+        boolean fromV6 = supportsV6(fromNode);
+        boolean toV4 = supportsV4(toNode);
+        boolean toV6 = supportsV6(toNode);
+
+        if (fromV4 && toV4) {
+            return pickToAddressV4(toNode);
+        }
+        if (fromV6 && toV6) {
+            return pickToAddressV6(toNode);
+        }
+
+        throw new RuntimeException(
+                "节点链路不兼容：" + safeName(fromNode) + "(v4=" + fromV4 + ",v6=" + fromV6 + ") -> "
+                        + safeName(toNode) + "(v4=" + toV4 + ",v6=" + toV6 + ")"
+        );
+    }
+
+    private static String safeName(Node node) {
+        if (node.getName() == null || node.getName().isBlank()) {
+            return "node_" + node.getId();
+        }
+        return node.getName();
+    }
+
+    private static boolean supportsV4(Node node) {
+        // New dual-stack fields take precedence over legacy serverIp.
+        // If user explicitly provided only v6, treat as v6-only.
+        if (StrUtil.isNotBlank(node.getServerIpV4())) {
+            return true;
+        }
+
+        if (StrUtil.isNotBlank(node.getServerIpV6())) {
+            return false;
+        }
+
+        String legacy = node.getServerIp();
+        if (StrUtil.isBlank(legacy)) {
+            return false;
+        }
+
+        legacy = legacy.trim();
+        if (looksLikeIpv4(legacy)) {
+            return true;
+        }
+        if (isIPv6Address(legacy)) {
+            return false;
+        }
+
+        // 域名/其它：无法判断，按双栈处理以保持兼容
+        return true;
+    }
+
+    private static boolean supportsV6(Node node) {
+        // New dual-stack fields take precedence over legacy serverIp.
+        // If user explicitly provided only v4, treat as v4-only.
+        if (StrUtil.isNotBlank(node.getServerIpV6())) {
+            return true;
+        }
+
+        if (StrUtil.isNotBlank(node.getServerIpV4())) {
+            return false;
+        }
+
+        String legacy = node.getServerIp();
+        if (StrUtil.isBlank(legacy)) {
+            return false;
+        }
+
+        legacy = legacy.trim();
+        if (isIPv6Address(legacy)) {
+            return true;
+        }
+        if (looksLikeIpv4(legacy)) {
+            return false;
+        }
+
+        // 域名/其它：无法判断，按双栈处理以保持兼容
+        return true;
+    }
+
+    private static String pickToAddressV4(Node toNode) {
+        if (StrUtil.isNotBlank(toNode.getServerIpV4())) {
+            return toNode.getServerIpV4().trim();
+        }
+        String legacy = toNode.getServerIp();
+        return legacy != null ? legacy.trim() : null;
+    }
+
+    private static String pickToAddressV6(Node toNode) {
+        if (StrUtil.isNotBlank(toNode.getServerIpV6())) {
+            return toNode.getServerIpV6().trim();
+        }
+        String legacy = toNode.getServerIp();
+        return legacy != null ? legacy.trim() : null;
+    }
+
+    private static boolean looksLikeIpv4(String value) {
+        Pattern ipv4 = Pattern.compile("^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$");
+        return ipv4.matcher(value).matches();
+    }
 }
@@ -10,7 +10,12 @@ import org.springframework.stereotype.Component;
 import javax.annotation.PreDestroy;
 import javax.sql.DataSource;
 import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
 import java.sql.Statement;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.regex.Pattern;

 /**
 * SQLite 数据库配置
@@ -39,13 +44,98 @@ public class SQLiteConfig implements ApplicationRunner {
            statement.execute("PRAGMA temp_store=MEMORY;");
            statement.execute("PRAGMA busy_timeout=5000;"); // 5秒超时
            statement.execute("PRAGMA wal_autocheckpoint=1000;"); // 每1000页自动checkpoint
-            
+
+            ensureNodeDualStackColumns(connection);
+             
            log.info("SQLite WAL mode configured successfully");
        } catch (Exception e) {
            log.error("Failed to configure SQLite database", e);
            throw e;
        }
    }
+
+    private void ensureNodeDualStackColumns(Connection connection) throws Exception {
+        Set<String> cols = getTableColumns(connection, "node");
+        if (cols.isEmpty()) {
+            return;
+        }
+
+        ensureColumnIfMissing(connection, cols, "node", "server_ip_v4", "VARCHAR(100)");
+        ensureColumnIfMissing(connection, cols, "node", "server_ip_v6", "VARCHAR(100)");
+
+        backfillNodeDualStackColumns(connection);
+    }
+
+    private void backfillNodeDualStackColumns(Connection connection) throws Exception {
+        Pattern ipv4 = Pattern.compile("^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$");
+
+        try (Statement statement = connection.createStatement();
+             ResultSet rs = statement.executeQuery("SELECT id, server_ip, server_ip_v4, server_ip_v6 FROM node;");
+             PreparedStatement updV4 = connection.prepareStatement("UPDATE node SET server_ip_v4 = ? WHERE id = ?;");
+             PreparedStatement updV6 = connection.prepareStatement("UPDATE node SET server_ip_v6 = ? WHERE id = ?;")
+        ) {
+            while (rs.next()) {
+                long id = rs.getLong("id");
+                String serverIp = rs.getString("server_ip");
+                String v4 = rs.getString("server_ip_v4");
+                String v6 = rs.getString("server_ip_v6");
+
+                if (serverIp == null || serverIp.isBlank()) {
+                    continue;
+                }
+                if ((v4 != null && !v4.isBlank()) || (v6 != null && !v6.isBlank())) {
+                    continue;
+                }
+
+                String trimmed = serverIp.trim();
+
+                if (ipv4.matcher(trimmed).matches()) {
+                    updV4.setString(1, trimmed);
+                    updV4.setLong(2, id);
+                    updV4.executeUpdate();
+                } else {
+                    long colonCount = trimmed.chars().filter(ch -> ch == ':').count();
+                    if (colonCount >= 2) {
+                        updV6.setString(1, trimmed);
+                        updV6.setLong(2, id);
+                        updV6.executeUpdate();
+                    }
+                }
+            }
+        }
+    }
+
+    private Set<String> getTableColumns(Connection connection, String table) throws Exception {
+        Set<String> cols = new HashSet<>();
+        try (Statement statement = connection.createStatement();
+             ResultSet rs = statement.executeQuery("PRAGMA table_info(" + table + ");")) {
+            while (rs.next()) {
+                String name = rs.getString("name");
+                if (name != null && !name.isBlank()) {
+                    cols.add(name);
+                }
+            }
+        }
+        return cols;
+    }
+
+    private void ensureColumnIfMissing(
+            Connection connection,
+            Set<String> existingColumns,
+            String table,
+            String column,
+            String type
+    ) throws Exception {
+        if (existingColumns.contains(column)) {
+            return;
+        }
+
+        try (Statement statement = connection.createStatement()) {
+            statement.execute("ALTER TABLE " + table + " ADD COLUMN " + column + " " + type + ";");
+        }
+
+        log.info("SQLite schema updated: added {}.{}", table, column);
+    }
    
    /**
     * 定期执行 checkpoint，确保 WAL 文件内容写入主数据库
@@ -80,4 +170,3 @@ public class SQLiteConfig implements ApplicationRunner {
        }
    }
 }
-
@@ -54,12 +54,24 @@ public class NodeController extends BaseController {
        return nodeService.deleteNode(id);
    }

-    @LogAnnotation
-    @RequireRole
-    @PostMapping("/install")
-    public R getInstallCommand(@RequestBody Map<String, Object> params) {
-        Long id = Long.valueOf(params.get("id").toString());
-        return nodeService.getInstallCommand(id);
-    }
-
-}
+    @LogAnnotation
+    @RequireRole
+    @PostMapping("/install")
+    public R getInstallCommand(@RequestBody Map<String, Object> params) {
+        Long id = Long.valueOf(params.get("id").toString());
+        return nodeService.getInstallCommand(id);
+    }
+
+    /**
+     * 更新节点排序
+     * @param params 包含nodes数组的参数，每个元素包含id和inx
+     * @return 更新结果
+     */
+    @LogAnnotation
+    @RequireRole
+    @PostMapping("/update-order")
+    public R updateNodeOrder(@RequestBody Map<String, Object> params) {
+        return nodeService.updateNodeOrder(params);
+    }
+
+}
@@ -5,6 +5,7 @@ import com.admin.common.annotation.RequireRole;
 import com.admin.common.dto.TunnelDto;
 import com.admin.common.dto.TunnelUpdateDto;

+import com.admin.common.dto.UserTunnelBatchAssignDto;
 import com.admin.common.dto.UserTunnelDto;
 import com.admin.common.dto.UserTunnelQueryDto;
 import com.admin.common.dto.UserTunnelUpdateDto;
@@ -78,6 +79,13 @@ public class TunnelController extends BaseController {
    public R assignUserTunnel(@Validated @RequestBody UserTunnelDto userTunnelDto) {
        return userTunnelService.assignUserTunnel(userTunnelDto);
    }
+
+    @LogAnnotation
+    @RequireRole
+    @PostMapping("/user/batch-assign")
+    public R batchAssignUserTunnel(@Validated @RequestBody UserTunnelBatchAssignDto batchAssignDto) {
+        return userTunnelService.batchAssignUserTunnel(batchAssignDto);
+    }
    
    /**
     * 查询用户隧道权限列表
@@ -137,4 +145,16 @@ public class TunnelController extends BaseController {
        return tunnelService.diagnoseTunnel(tunnelId);
    }

+    /**
+     * 更新隧道排序
+     * @param params 包含tunnels数组的参数，每个元素包含id和inx
+     * @return 更新结果
+     */
+    @LogAnnotation
+    @RequireRole
+    @PostMapping("/update-order")
+    public R updateTunnelOrder(@RequestBody Map<String, Object> params) {
+        return tunnelService.updateTunnelOrder(params);
+    }
+
 }
@@ -14,15 +14,19 @@ import lombok.EqualsAndHashCode;
 */
@Data
@EqualsAndHashCode(callSuper = true)
-public class Node extends BaseEntity {
+public class Node extends BaseEntity {

    private static final long serialVersionUID = 1L;

    private String name;

-    private String secret;
-
-    private String serverIp;
+    private String secret;
+
+    private String serverIp;
+
+    private String serverIpV4;
+
+    private String serverIpV6;

    private String version;

@@ -38,6 +42,11 @@ public class Node extends BaseEntity {

    private String tcpListenAddr;

-    private String udpListenAddr;
-
-}
+    private String udpListenAddr;
+
+    /**
+     * Display/order index for drag-sorting in admin UI.
+     * Lower value appears first.
+     */
+    private Integer inx;
+}
@@ -22,7 +22,7 @@ import lombok.EqualsAndHashCode;
@Data
@EqualsAndHashCode(callSuper = true)
@TableName(autoResultMap = true)
-public class Tunnel extends BaseEntity {
+public class Tunnel extends BaseEntity {

    private static final long serialVersionUID = 1L;

@@ -32,7 +32,13 @@ public class Tunnel extends BaseEntity {

    private int flow;

-    private BigDecimal trafficRatio;
-
-    private String inIp;
-}
+    private BigDecimal trafficRatio;
+
+    private String inIp;
+
+    /**
+     * Display/order index for drag-sorting in admin UI.
+     * Lower value appears first.
+     */
+    private Integer inx;
+}
@@ -3,8 +3,10 @@ package com.admin.service;
 import com.admin.common.dto.NodeDto;
 import com.admin.common.dto.NodeUpdateDto;
 import com.admin.common.lang.R;
-import com.admin.entity.Node;
-import com.baomidou.mybatisplus.extension.service.IService;
+import com.admin.entity.Node;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+import java.util.Map;

 /**
 * <p>
@@ -14,7 +16,7 @@ import com.baomidou.mybatisplus.extension.service.IService;
 * @author QAQ
 * @since 2025-06-03
 */
-public interface NodeService extends IService<Node> {
+public interface NodeService extends IService<Node> {

    R createNode(NodeDto nodeDto);

@@ -24,6 +26,12 @@ public interface NodeService extends IService<Node> {

    R deleteNode(Long id);

-    R getInstallCommand(Long id);
-
-}
+    R getInstallCommand(Long id);
+
+    /**
+     * 更新节点排序（管理员）
+     * @param params 包含nodes数组的参数，每个元素包含id和inx
+     */
+    R updateNodeOrder(Map<String, Object> params);
+
+}
@@ -4,8 +4,10 @@ import com.admin.common.dto.TunnelDto;
 import com.admin.common.dto.TunnelUpdateDto;

 import com.admin.common.lang.R;
-import com.admin.entity.Tunnel;
-import com.baomidou.mybatisplus.extension.service.IService;
+import com.admin.entity.Tunnel;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+import java.util.Map;

 /**
 * <p>
@@ -15,7 +17,7 @@ import com.baomidou.mybatisplus.extension.service.IService;
 * @author QAQ
 * @since 2025-06-03
 */
-public interface TunnelService extends IService<Tunnel> {
+public interface TunnelService extends IService<Tunnel> {

    /**
     * 创建隧道
@@ -55,5 +57,11 @@ public interface TunnelService extends IService<Tunnel> {
     * @param tunnelId 隧道ID
     * @return 诊断结果
     */
-    R diagnoseTunnel(Long tunnelId);
-}
+    R diagnoseTunnel(Long tunnelId);
+
+    /**
+     * 更新隧道排序（管理员）
+     * @param params 包含tunnels数组的参数，每个元素包含id和inx
+     */
+    R updateTunnelOrder(Map<String, Object> params);
+}
@@ -1,49 +1,23 @@
-package com.admin.service;
-
-import com.admin.common.dto.UserTunnelDto;
-import com.admin.common.dto.UserTunnelQueryDto;
-import com.admin.common.dto.UserTunnelUpdateDto;
-import com.admin.common.lang.R;
-import com.admin.entity.UserTunnel;
-import com.baomidou.mybatisplus.extension.service.IService;
-
-/**
- * <p>
- * 用户隧道权限服务类
- * </p>
- *
- * @author QAQ
- * @since 2025-06-03
- */
-public interface UserTunnelService extends IService<UserTunnel> {
-
-    /**
-     * 分配用户隧道权限
-     * @param userTunnelDto 用户隧道权限数据
-     * @return 结果
-     */
-    R assignUserTunnel(UserTunnelDto userTunnelDto);
-    
-    /**
-     * 查询用户隧道权限列表
-     * @param queryDto 查询条件
-     * @return 结果
-     */
-    R getUserTunnelList(UserTunnelQueryDto queryDto);
-    
-    /**
-     * 删除用户隧道权限
-     * @param id ID
-     * @return 结果
-     */
-    R removeUserTunnel(Integer id);
-
-    
-    /**
-     * 更新用户隧道权限（包含流量、流量重置时间、到期时间）
-     * @param updateDto 更新数据
-     * @return 结果
-     */
-    R updateUserTunnel(UserTunnelUpdateDto updateDto);
-
-}
+package com.admin.service;
+
+import com.admin.common.dto.UserTunnelBatchAssignDto;
+import com.admin.common.dto.UserTunnelDto;
+import com.admin.common.dto.UserTunnelQueryDto;
+import com.admin.common.dto.UserTunnelUpdateDto;
+import com.admin.common.lang.R;
+import com.admin.entity.UserTunnel;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+public interface UserTunnelService extends IService<UserTunnel> {
+
+    R assignUserTunnel(UserTunnelDto userTunnelDto);
+    
+    R batchAssignUserTunnel(UserTunnelBatchAssignDto batchAssignDto);
+    
+    R getUserTunnelList(UserTunnelQueryDto queryDto);
+    
+    R removeUserTunnel(Integer id);
+    
+    R updateUserTunnel(UserTunnelUpdateDto updateDto);
+
+}
@@ -209,56 +209,93 @@ public class ForwardServiceImpl extends ServiceImpl<ForwardMapper, Forward> impl
    }

    @Override
+    @Transactional
    public R updateForward(ForwardUpdateDto forwardUpdateDto) {
-        // 1. 获取当前用户信息
        UserInfo currentUser = getCurrentUserInfo();

-
-        // 2. 检查转发是否存在
        Forward existForward = validateForwardExists(forwardUpdateDto.getId(), currentUser);
        if (existForward == null) {
            return R.err("转发不存在");
        }

+        Integer oldTunnelId = existForward.getTunnelId();
+        Integer newTunnelId = forwardUpdateDto.getTunnelId() != null ? forwardUpdateDto.getTunnelId() : oldTunnelId;
+        boolean tunnelChanged = !Objects.equals(oldTunnelId, newTunnelId);

-        Tunnel tunnel = validateTunnel(existForward.getTunnelId());
-        if (tunnel == null) {
-            return R.err("隧道不存在");
+        Tunnel oldTunnel = validateTunnel(oldTunnelId);
+        if (oldTunnel == null) {
+            return R.err("原隧道不存在");
        }

-        UserPermissionResult permissionResult = checkUserPermissions(currentUser, tunnel, null);
-        if (permissionResult.isHasError()) {
-            return R.err(permissionResult.getErrorMessage());
-        }
-
-        UserTunnel userTunnel;
+        UserTunnel oldUserTunnel;
        if (currentUser.getRoleId() != 0) {
-            userTunnel = getUserTunnel(currentUser.getUserId(), tunnel.getId().intValue());
-            if (userTunnel == null) {
-                return R.err("你没有该隧道权限");
+            oldUserTunnel = getUserTunnel(currentUser.getUserId(), oldTunnelId);
+            if (oldUserTunnel == null) {
+                return R.err("你没有原隧道权限");
            }
        } else {
-            // 管理员用户也需要获取UserTunnel（如果存在的话），用于构建正确的服务名称
-            // 通过forward记录获取原始的用户ID
-            userTunnel = getUserTunnel(existForward.getUserId(), tunnel.getId().intValue());
+            oldUserTunnel = getUserTunnel(existForward.getUserId(), oldTunnelId);
+        }
+
+        if (tunnelChanged) {
+            Tunnel newTunnel = validateTunnel(newTunnelId);
+            if (newTunnel == null) {
+                return R.err("新隧道不存在");
+            }
+            if (newTunnel.getStatus() != 1) {
+                return R.err("新隧道已禁用，无法切换");
+            }
+
+            UserPermissionResult newPermResult = checkUserPermissions(currentUser, newTunnel, null);
+            if (newPermResult.isHasError()) {
+                return R.err(newPermResult.getErrorMessage());
+            }
+
+            UserTunnel newUserTunnel;
+            if (currentUser.getRoleId() != 0) {
+                newUserTunnel = getUserTunnel(currentUser.getUserId(), newTunnelId);
+                if (newUserTunnel == null) {
+                    return R.err("你没有新隧道权限");
+                }
+            } else {
+                newUserTunnel = getUserTunnel(existForward.getUserId(), newTunnelId);
+            }
+
+            releaseOldTunnelResources(existForward, oldTunnel, oldUserTunnel);
+
+            existForward.setTunnelId(newTunnelId);
+            existForward.setRemoteAddr(forwardUpdateDto.getRemoteAddr());
+            existForward.setName(forwardUpdateDto.getName());
+            existForward.setStrategy(forwardUpdateDto.getStrategy());
+            existForward.setStatus(1);
+            existForward.setUpdatedTime(System.currentTimeMillis());
+            this.updateById(existForward);
+
+            R allocResult = allocateNewTunnelResources(existForward, newTunnel, forwardUpdateDto.getInPort(), newPermResult, newUserTunnel);
+            if (allocResult.getCode() != 0) {
+                throw new RuntimeException(allocResult.getMsg());
+            }
+
+            return R.ok();
+        }
+
+        UserPermissionResult permissionResult = checkUserPermissions(currentUser, oldTunnel, null);
+        if (permissionResult.isHasError()) {
+            return R.err(permissionResult.getErrorMessage());
        }

        existForward.setRemoteAddr(forwardUpdateDto.getRemoteAddr());
        existForward.setName(forwardUpdateDto.getName());
        existForward.setStrategy(forwardUpdateDto.getStrategy());
        existForward.setStatus(1);
+        existForward.setUpdatedTime(System.currentTimeMillis());
        this.updateById(existForward);

-
-        List<ChainTunnel> chainTunnels = chainTunnelService.list(new QueryWrapper<ChainTunnel>().eq("tunnel_id", tunnel.getId()).eq("chain_type", 1));
-
-        // 自己占用的应该不算
+        List<ChainTunnel> chainTunnels = chainTunnelService.list(new QueryWrapper<ChainTunnel>().eq("tunnel_id", oldTunnel.getId()).eq("chain_type", 1));
        chainTunnels = get_port(chainTunnels, forwardUpdateDto.getInPort(), existForward.getId());

-
-
        for (ChainTunnel chainTunnel : chainTunnels) {
-            String serviceName = buildServiceName(existForward.getId(), existForward.getUserId(), userTunnel);
+            String serviceName = buildServiceName(existForward.getId(), existForward.getUserId(), oldUserTunnel);
            Integer limiter = permissionResult.getLimiter();
            Node node = nodeService.getById(chainTunnel.getNodeId());
            if (node == null) {
@@ -270,13 +307,89 @@ public class ForwardServiceImpl extends ServiceImpl<ForwardMapper, Forward> impl
            }
            forwardPort.setPort(chainTunnel.getPort());
            forwardPortService.updateById(forwardPort);
-            GostDto gostDto = GostUtil.AddAndUpdateService(serviceName, limiter, node, existForward, forwardPort, tunnel, "UpdateService");
+            GostDto gostDto = GostUtil.AddAndUpdateService(serviceName, limiter, node, existForward, forwardPort, oldTunnel, "UpdateService");
            if (!Objects.equals(gostDto.getMsg(), "OK")) return R.err(gostDto.getMsg());
        }

        return R.ok();
    }

+    private void releaseOldTunnelResources(Forward forward, Tunnel oldTunnel, UserTunnel oldUserTunnel) {
+        List<ChainTunnel> oldInNodes = chainTunnelService.list(
+                new QueryWrapper<ChainTunnel>()
+                        .eq("tunnel_id", oldTunnel.getId())
+                        .eq("chain_type", 1)
+        );
+
+        for (ChainTunnel chainTunnel : oldInNodes) {
+            String serviceName = buildServiceName(forward.getId(), forward.getUserId(), oldUserTunnel);
+            Node node = nodeService.getById(chainTunnel.getNodeId());
+            if (node != null) {
+                JSONArray services = new JSONArray();
+                services.add(serviceName + "_tcp");
+                services.add(serviceName + "_udp");
+                GostUtil.DeleteService(node.getId(), services);
+            }
+        }
+
+        forwardPortService.remove(new QueryWrapper<ForwardPort>().eq("forward_id", forward.getId()));
+    }
+
+    private R allocateNewTunnelResources(Forward forward, Tunnel newTunnel, Integer requestedPort,
+                                         UserPermissionResult permResult, UserTunnel newUserTunnel) {
+        List<ChainTunnel> newInNodes = chainTunnelService.list(
+                new QueryWrapper<ChainTunnel>()
+                        .eq("tunnel_id", newTunnel.getId())
+                        .eq("chain_type", 1)
+        );
+
+        newInNodes = get_port(newInNodes, requestedPort, forward.getId());
+
+        List<JSONObject> successServices = new ArrayList<>();
+
+        for (ChainTunnel chainTunnel : newInNodes) {
+            ForwardPort forwardPort = new ForwardPort();
+            forwardPort.setForwardId(forward.getId());
+            forwardPort.setNodeId(chainTunnel.getNodeId());
+            forwardPort.setPort(chainTunnel.getPort());
+            forwardPortService.save(forwardPort);
+
+            String serviceName = buildServiceName(forward.getId(), forward.getUserId(), newUserTunnel);
+            Integer limiter = permResult.getLimiter();
+            Node node = nodeService.getById(chainTunnel.getNodeId());
+
+            if (node == null) {
+                rollbackCreatedServices(successServices);
+                forwardPortService.remove(new QueryWrapper<ForwardPort>().eq("forward_id", forward.getId()));
+                return R.err("新隧道部分节点不存在");
+            }
+
+            GostDto gostDto = GostUtil.AddAndUpdateService(serviceName, limiter, node, forward, forwardPort, newTunnel, "AddService");
+
+            if (!Objects.equals(gostDto.getMsg(), "OK")) {
+                rollbackCreatedServices(successServices);
+                forwardPortService.remove(new QueryWrapper<ForwardPort>().eq("forward_id", forward.getId()));
+                return R.err("在新隧道创建服务失败: " + gostDto.getMsg());
+            }
+
+            JSONObject data = new JSONObject();
+            data.put("node_id", node.getId());
+            data.put("name", serviceName);
+            successServices.add(data);
+        }
+
+        return R.ok();
+    }
+
+    private void rollbackCreatedServices(List<JSONObject> created) {
+        for (JSONObject jsonObject : created) {
+            JSONArray se = new JSONArray();
+            se.add(jsonObject.getString("name") + "_tcp");
+            se.add(jsonObject.getString("name") + "_udp");
+            GostUtil.DeleteService(jsonObject.getLong("node_id"), se);
+        }
+    }
+
    @Override
    public R deleteForward(Long id) {

@@ -435,7 +548,7 @@ public class ForwardServiceImpl extends ServiceImpl<ForwardMapper, Forward> impl
                            Node toNode = nodeService.getById(firstChainNode.getNodeId());
                            if (toNode != null) {
                                DiagnosisResult result = performTcpPingDiagnosisWithConnectionCheck(
-                                        fromNode, toNode.getServerIp(), firstChainNode.getPort(),
+                                    fromNode, GostUtil.selectDialHost(fromNode, toNode), firstChainNode.getPort(),
                                        "入口(" + fromNode.getName() + ")->第1跳(" + toNode.getName() + ")"
                                );
                                result.setFromChainType(1);
@@ -449,7 +562,7 @@ public class ForwardServiceImpl extends ServiceImpl<ForwardMapper, Forward> impl
                            Node toNode = nodeService.getById(outNode.getNodeId());
                            if (toNode != null) {
                                DiagnosisResult result = performTcpPingDiagnosisWithConnectionCheck(
-                                        fromNode, toNode.getServerIp(), outNode.getPort(),
+                                        fromNode, GostUtil.selectDialHost(fromNode, toNode), outNode.getPort(),
                                        "入口(" + fromNode.getName() + ")->出口(" + toNode.getName() + ")"
                                );
                                result.setFromChainType(1);
@@ -474,7 +587,7 @@ public class ForwardServiceImpl extends ServiceImpl<ForwardMapper, Forward> impl
                                Node toNode = nodeService.getById(nextNode.getNodeId());
                                if (toNode != null) {
                                    DiagnosisResult result = performTcpPingDiagnosisWithConnectionCheck(
-                                            fromNode, toNode.getServerIp(), nextNode.getPort(),
+                                            fromNode, GostUtil.selectDialHost(fromNode, toNode), nextNode.getPort(),
                                            "第" + (i + 1) + "跳(" + fromNode.getName() + ")->第" + (i + 2) + "跳(" + toNode.getName() + ")"
                                    );
                                    result.setFromChainType(2);
@@ -489,7 +602,7 @@ public class ForwardServiceImpl extends ServiceImpl<ForwardMapper, Forward> impl
                                Node toNode = nodeService.getById(outNode.getNodeId());
                                if (toNode != null) {
                                    DiagnosisResult result = performTcpPingDiagnosisWithConnectionCheck(
-                                            fromNode, toNode.getServerIp(), outNode.getPort(),
+                                            fromNode, GostUtil.selectDialHost(fromNode, toNode), outNode.getPort(),
                                            "第" + (i + 1) + "跳(" + fromNode.getName() + ")->出口(" + toNode.getName() + ")"
                                    );
                                    result.setFromChainType(2);
@@ -9,26 +9,35 @@ import com.admin.common.lang.R;
 import com.admin.common.utils.GostUtil;
 import com.admin.common.utils.WebSocketServer;
 import com.admin.entity.*;
-import com.admin.mapper.NodeMapper;
-import com.admin.mapper.TunnelMapper;
-import com.admin.service.*;
-import com.alibaba.fastjson.JSONObject;
-import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import org.springframework.beans.BeanUtils;
-import org.springframework.context.annotation.Lazy;
-import org.springframework.stereotype.Service;
+import com.admin.mapper.NodeMapper;
+import com.admin.mapper.TunnelMapper;
+import com.admin.service.*;
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.BeanUtils;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.stereotype.Service;
+ 
+import javax.annotation.Resource;
+import java.util.HashMap;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
+import java.util.regex.Pattern;

-import javax.annotation.Resource;
-import java.util.List;
-import java.util.Objects;
-import java.util.regex.Pattern;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.transaction.annotation.Transactional;

-import org.springframework.beans.factory.annotation.Value;
-
-@Service
-public class NodeServiceImpl extends ServiceImpl<NodeMapper, Node> implements NodeService {
+@Service
+@Slf4j
+public class NodeServiceImpl extends ServiceImpl<NodeMapper, Node> implements NodeService {


    @Resource
@@ -38,33 +47,71 @@ public class NodeServiceImpl extends ServiceImpl<NodeMapper, Node> implements No
    @Resource
    ViteConfigService viteConfigService;

-    @Resource
-    ChainTunnelService chainTunnelService;
+    @Resource
+    ChainTunnelService chainTunnelService;
+
+    @Resource
+    ForwardPortService forwardPortService;


    @Override
-    public R createNode(NodeDto nodeDto) {
-        validatePortRange(nodeDto.getPort());
-        Node node = new Node();
-        node.setSecret(IdUtil.simpleUUID());
-        node.setStatus(0);
-        node.setPort(nodeDto.getPort());
-        node.setName(nodeDto.getName());
-        node.setServerIp(nodeDto.getServerIp());
-        long currentTime = System.currentTimeMillis();
-        node.setCreatedTime(currentTime);
-        node.setUpdatedTime(currentTime);
-        node.setInterfaceName(nodeDto.getInterfaceName());
-        this.save(node);
-        return R.ok();
-    }
+    public R createNode(NodeDto nodeDto) {
+        validatePortRange(nodeDto.getPort());
+
+        String normalizedV4 = normalizeV4(nodeDto.getServerIpV4(), nodeDto.getServerIp());
+        String normalizedV6 = normalizeV6(nodeDto.getServerIpV6(), nodeDto.getServerIp());
+        String primaryServerIp = pickPrimaryServerIp(normalizedV4, normalizedV6, nodeDto.getServerIp());
+
+        Node node = new Node();
+        node.setSecret(IdUtil.simpleUUID());
+        node.setStatus(0);
+        node.setPort(nodeDto.getPort());
+        node.setName(nodeDto.getName());
+        node.setServerIp(primaryServerIp);
+        node.setServerIpV4(normalizedV4);
+        node.setServerIpV6(normalizedV6);
+        long currentTime = System.currentTimeMillis();
+        node.setCreatedTime(currentTime);
+        node.setUpdatedTime(currentTime);
+        node.setInterfaceName(nodeDto.getInterfaceName());
+        this.save(node);
+        return R.ok();
+    }

-    @Override
-    public R getAllNodes() {
-        List<Node> nodeList = this.list(new QueryWrapper<Node>().orderByDesc("status"));
-        nodeList.forEach(node -> node.setSecret(null));
-        return R.ok(nodeList);
-    }
+    @Override
+    public R getAllNodes() {
+        List<Node> nodeList = this.list(new QueryWrapper<Node>().orderByAsc("inx").orderByAsc("id"));
+        nodeList.forEach(node -> node.setSecret(null));
+        return R.ok(nodeList);
+    }
+
+    @Override
+    @Transactional
+    public R updateNodeOrder(Map<String, Object> params) {
+        if (!params.containsKey("nodes")) {
+            return R.err("缺少nodes参数");
+        }
+
+        @SuppressWarnings("unchecked")
+        List<Map<String, Object>> nodesList = (List<Map<String, Object>>) params.get("nodes");
+        if (nodesList == null || nodesList.isEmpty()) {
+            return R.err("nodes参数不能为空");
+        }
+
+        List<Node> nodesToUpdate = new ArrayList<>();
+        for (Map<String, Object> nodeData : nodesList) {
+            Long id = Long.valueOf(nodeData.get("id").toString());
+            Integer inx = Integer.valueOf(nodeData.get("inx").toString());
+
+            Node node = new Node();
+            node.setId(id);
+            node.setInx(inx);
+            nodesToUpdate.add(node);
+        }
+
+        this.updateBatchById(nodesToUpdate);
+        return R.ok();
+    }

    @Override
    public R updateNode(NodeUpdateDto nodeUpdateDto) {
@@ -96,25 +143,253 @@ public class NodeServiceImpl extends ServiceImpl<NodeMapper, Node> implements No



-        Node updateNode = buildUpdateNode(nodeUpdateDto);
-        this.updateById(updateNode);
-        return R.ok();
-    }
+        Node updateNode = buildUpdateNode(nodeUpdateDto);
+        // Use LambdaUpdateWrapper to explicitly set nullable fields (serverIpV4/V6)
+        // because updateById() skips null fields by default
+        LambdaUpdateWrapper<Node> wrapper = new LambdaUpdateWrapper<>();
+        wrapper.eq(Node::getId, updateNode.getId())
+               .set(Node::getName, updateNode.getName())
+               .set(Node::getServerIp, updateNode.getServerIp())
+               .set(Node::getServerIpV4, updateNode.getServerIpV4())
+               .set(Node::getServerIpV6, updateNode.getServerIpV6())
+               .set(Node::getPort, updateNode.getPort())
+               .set(Node::getHttp, updateNode.getHttp())
+               .set(Node::getTls, updateNode.getTls())
+               .set(Node::getSocks, updateNode.getSocks())
+               .set(Node::getInterfaceName, updateNode.getInterfaceName())
+               .set(Node::getTcpListenAddr, updateNode.getTcpListenAddr())
+               .set(Node::getUdpListenAddr, updateNode.getUdpListenAddr())
+               .set(Node::getUpdatedTime, updateNode.getUpdatedTime());
+        this.update(wrapper);
+        return R.ok();
+    }

-    @Override
-    public R deleteNode(Long id) {
-        Node node = this.getById(id);
-        if (node == null) {
-            return R.err("节点不存在");
-        }
-
-        List<ChainTunnel> list = chainTunnelService.list(new QueryWrapper<ChainTunnel>().eq("node_id", id).groupBy("tunnel_id"));
-        for (ChainTunnel tunnel : list) {
-            tunnelService.deleteTunnel(tunnel.getTunnelId());
-        }
-        this.removeById(id);
-        return R.ok();
-    }
+    @Override
+    public R deleteNode(Long id) {
+        Node node = this.getById(id);
+        if (node == null) {
+            return R.err("节点不存在");
+        }
+
+        List<ChainTunnel> affected = chainTunnelService.list(new QueryWrapper<ChainTunnel>().eq("node_id", id));
+        Map<Long, List<ChainTunnel>> byTunnelId = affected.stream()
+                .filter(ct -> ct.getTunnelId() != null)
+                .collect(Collectors.groupingBy(ChainTunnel::getTunnelId));
+
+        for (Map.Entry<Long, List<ChainTunnel>> entry : byTunnelId.entrySet()) {
+            Long tunnelId = entry.getKey();
+            Tunnel tunnel = tunnelService.getById(tunnelId);
+
+            List<ChainTunnel> before = chainTunnelService.list(new QueryWrapper<ChainTunnel>().eq("tunnel_id", tunnelId));
+
+            // Remove the node from the tunnel definition (do NOT delete the tunnel).
+            chainTunnelService.remove(new QueryWrapper<ChainTunnel>().eq("tunnel_id", tunnelId).eq("node_id", id));
+
+            if (tunnel == null) {
+                continue;
+            }
+
+            List<ChainTunnel> after = chainTunnelService.list(new QueryWrapper<ChainTunnel>().eq("tunnel_id", tunnelId));
+            Integer removedChainType = entry.getValue().isEmpty() ? null : entry.getValue().get(0).getChainType();
+
+            // Keep tunnel.inIp consistent when it was auto-derived from entry nodes.
+            String oldDerivedInIp = buildDerivedInIp(before);
+            String newDerivedInIp = buildDerivedInIp(after);
+            if (shouldUpdateTunnelInIp(tunnel.getInIp(), oldDerivedInIp)) {
+                updateTunnelInIp(tunnelId, newDerivedInIp);
+            }
+
+            boolean valid = isTunnelConfigValid(tunnel, after);
+            if (!valid) {
+                disableTunnelAndCleanupGostIfNeeded(tunnel, after, "node-delete");
+                continue;
+            }
+
+            // For tunnel-forwarding (type=2), removing a chain/out node requires rebuilding config.
+            // Removing an entry node (chainType=1) does not affect remaining nodes' chain targets.
+            if (tunnel.getType() != null && tunnel.getType() == 2 && removedChainType != null && removedChainType != 1) {
+                try {
+                    cleanupGostConfig(after, tunnelId);
+                    rebuildGostConfig(after, tunnel);
+                } catch (Exception e) {
+                    log.warn("Failed to rebuild gost config after node delete. tunnelId={}, nodeId={}, err={}", tunnelId, id, e.getMessage(), e);
+                    disableTunnelAndCleanupGostIfNeeded(tunnel, after, "node-delete:rebuild-failed");
+                }
+            }
+        }
+
+        // Remove per-forward port allocations on this node (avoid orphan ForwardPort rows).
+        try {
+            forwardPortService.remove(new QueryWrapper<ForwardPort>().eq("node_id", id));
+        } catch (Exception e) {
+            log.warn("Failed to cleanup forward ports when deleting node. nodeId={}, err={}", id, e.getMessage(), e);
+        }
+
+        this.removeById(id);
+        return R.ok();
+    }
+
+    private boolean isTunnelConfigValid(Tunnel tunnel, List<ChainTunnel> chainTunnels) {
+        if (tunnel == null || chainTunnels == null) {
+            return false;
+        }
+
+        long inCount = chainTunnels.stream()
+                .filter(ct -> ct.getChainType() != null && ct.getChainType() == 1)
+                .count();
+        if (inCount <= 0) {
+            return false;
+        }
+
+        if (tunnel.getType() != null && tunnel.getType() == 2) {
+            long outCount = chainTunnels.stream()
+                    .filter(ct -> ct.getChainType() != null && ct.getChainType() == 3)
+                    .count();
+            return outCount > 0;
+        }
+
+        return true;
+    }
+
+    private boolean shouldUpdateTunnelInIp(String currentInIp, String oldDerivedInIp) {
+        if (StrUtil.isBlank(currentInIp)) {
+            return true;
+        }
+        if (oldDerivedInIp == null) {
+            return false;
+        }
+        return Objects.equals(currentInIp, oldDerivedInIp);
+    }
+
+    private void updateTunnelInIp(Long tunnelId, String derivedInIp) {
+        Tunnel update = new Tunnel();
+        update.setId(tunnelId);
+        update.setInIp(derivedInIp == null ? "" : derivedInIp);
+        update.setUpdatedTime(System.currentTimeMillis());
+        tunnelService.updateById(update);
+    }
+
+    private String buildDerivedInIp(List<ChainTunnel> chainTunnels) {
+        if (chainTunnels == null) {
+            return "";
+        }
+        List<ChainTunnel> inNodes = chainTunnels.stream()
+                .filter(ct -> ct.getChainType() != null && ct.getChainType() == 1)
+                .collect(Collectors.toList());
+        if (inNodes.isEmpty()) {
+            return "";
+        }
+
+        StringBuilder inIp = new StringBuilder();
+        for (ChainTunnel inNode : inNodes) {
+            Node n = this.getById(inNode.getNodeId());
+            if (n == null || StrUtil.isBlank(n.getServerIp())) {
+                return null;
+            }
+            inIp.append(n.getServerIp()).append(",");
+        }
+        inIp.deleteCharAt(inIp.length() - 1);
+        return inIp.toString();
+    }
+
+    private void disableTunnelAndCleanupGostIfNeeded(Tunnel tunnel, List<ChainTunnel> remaining, String reason) {
+        try {
+            Tunnel update = new Tunnel();
+            update.setId(tunnel.getId());
+            update.setStatus(0);
+            update.setUpdatedTime(System.currentTimeMillis());
+            tunnelService.updateById(update);
+        } catch (Exception e) {
+            log.warn("Failed to disable tunnel. tunnelId={}, reason={}, err={}", tunnel.getId(), reason, e.getMessage(), e);
+        }
+
+        if (tunnel.getType() != null && tunnel.getType() == 2) {
+            try {
+                cleanupGostConfig(remaining, tunnel.getId());
+            } catch (Exception e) {
+                log.warn("Failed to cleanup gost config when disabling tunnel. tunnelId={}, reason={}, err={}", tunnel.getId(), reason, e.getMessage(), e);
+            }
+        }
+    }
+
+    private void cleanupGostConfig(List<ChainTunnel> chainTunnels, Long tunnelId) {
+        if (chainTunnels == null) {
+            return;
+        }
+        for (ChainTunnel chainTunnel : chainTunnels) {
+            if (chainTunnel.getChainType() == null) {
+                continue;
+            }
+            if (chainTunnel.getChainType() == 1) {
+                GostUtil.DeleteChains(chainTunnel.getNodeId(), "chains_" + tunnelId);
+            } else if (chainTunnel.getChainType() == 2) {
+                GostUtil.DeleteChains(chainTunnel.getNodeId(), "chains_" + tunnelId);
+                JSONArray services = new JSONArray();
+                services.add(tunnelId + "_tls");
+                GostUtil.DeleteService(chainTunnel.getNodeId(), services);
+            } else if (chainTunnel.getChainType() == 3) {
+                JSONArray services = new JSONArray();
+                services.add(tunnelId + "_tls");
+                GostUtil.DeleteService(chainTunnel.getNodeId(), services);
+            }
+        }
+    }
+
+    private void rebuildGostConfig(List<ChainTunnel> chainTunnels, Tunnel tunnel) {
+        if (tunnel == null || chainTunnels == null) {
+            return;
+        }
+
+        Map<Long, Node> nodes = new HashMap<>();
+        for (ChainTunnel ct : chainTunnels) {
+            Node n = this.getById(ct.getNodeId());
+            if (n != null) {
+                nodes.put(n.getId(), n);
+            }
+        }
+
+        List<ChainTunnel> inNodes = chainTunnels.stream()
+                .filter(ct -> ct.getChainType() != null && ct.getChainType() == 1)
+                .collect(Collectors.toList());
+
+        Map<Integer, List<ChainTunnel>> chainNodesMap = chainTunnels.stream()
+                .filter(ct -> ct.getChainType() != null && ct.getChainType() == 2)
+                .collect(Collectors.groupingBy(ct -> ct.getInx() != null ? ct.getInx() : 0));
+
+        List<List<ChainTunnel>> chainNodesList = chainNodesMap.entrySet().stream()
+                .sorted(Map.Entry.comparingByKey())
+                .map(Map.Entry::getValue)
+                .collect(Collectors.toList());
+
+        List<ChainTunnel> outNodes = chainTunnels.stream()
+                .filter(ct -> ct.getChainType() != null && ct.getChainType() == 3)
+                .collect(Collectors.toList());
+
+        if (tunnel.getType() != null && tunnel.getType() == 2) {
+            for (ChainTunnel inNode : inNodes) {
+                if (chainNodesList.isEmpty()) {
+                    GostUtil.AddChains(inNode.getNodeId(), outNodes, nodes);
+                } else {
+                    GostUtil.AddChains(inNode.getNodeId(), chainNodesList.get(0), nodes);
+                }
+            }
+
+            for (int i = 0; i < chainNodesList.size(); i++) {
+                for (ChainTunnel chainNode : chainNodesList.get(i)) {
+                    if (i + 1 >= chainNodesList.size()) {
+                        GostUtil.AddChains(chainNode.getNodeId(), outNodes, nodes);
+                    } else {
+                        GostUtil.AddChains(chainNode.getNodeId(), chainNodesList.get(i + 1), nodes);
+                    }
+                    GostUtil.AddChainService(chainNode.getNodeId(), chainNode, nodes);
+                }
+            }
+
+            for (ChainTunnel outNode : outNodes) {
+                GostUtil.AddChainService(outNode.getNodeId(), outNode, nodes);
+            }
+        }
+    }


    @Override
@@ -126,8 +401,8 @@ public class NodeServiceImpl extends ServiceImpl<NodeMapper, Node> implements No
        ViteConfig viteConfig = viteConfigService.getOne(new QueryWrapper<ViteConfig>().eq("name", "ip"));
        if (viteConfig == null) return R.err("请先前往网站配置中设置ip");
        StringBuilder command = new StringBuilder();
-        command.append("curl -L https://github.com/bqlpfy/flux-panel/releases/download/2.0.7-beta/install.sh")
-                .append(" -o ./install.sh && chmod +x ./install.sh && ");
+        command.append("curl -L https://github.com/Sagit-chu/flux-panel/releases/latest/download/install.sh")
+                .append(" -o ./install.sh && chmod +x ./install.sh && ");
        String processedServerAddr = GostUtil.processServerAddress(viteConfig.getValue());
        command.append("./install.sh")
                .append(" -a ").append(processedServerAddr)  // 服务器地址
@@ -137,22 +412,71 @@ public class NodeServiceImpl extends ServiceImpl<NodeMapper, Node> implements No
    }


-    private Node buildUpdateNode(NodeUpdateDto nodeUpdateDto) {
-        validatePortRange(nodeUpdateDto.getPort());
-        Node node = new Node();
-        node.setId(nodeUpdateDto.getId());
-        node.setName(nodeUpdateDto.getName());
-        node.setServerIp(nodeUpdateDto.getServerIp());
-        node.setPort(nodeUpdateDto.getPort());
-        node.setHttp(nodeUpdateDto.getHttp());
-        node.setTls(nodeUpdateDto.getTls());
-        node.setSocks(nodeUpdateDto.getSocks());
-        node.setUpdatedTime(System.currentTimeMillis());
-        node.setInterfaceName(nodeUpdateDto.getInterfaceName());
-        node.setTcpListenAddr(nodeUpdateDto.getTcpListenAddr());
-        node.setUdpListenAddr(nodeUpdateDto.getUdpListenAddr());
-        return node;
-    }
+    private Node buildUpdateNode(NodeUpdateDto nodeUpdateDto) {
+        validatePortRange(nodeUpdateDto.getPort());
+
+        String normalizedV4 = normalizeV4(nodeUpdateDto.getServerIpV4(), nodeUpdateDto.getServerIp());
+        String normalizedV6 = normalizeV6(nodeUpdateDto.getServerIpV6(), nodeUpdateDto.getServerIp());
+        String primaryServerIp = pickPrimaryServerIp(normalizedV4, normalizedV6, nodeUpdateDto.getServerIp());
+
+        Node node = new Node();
+        node.setId(nodeUpdateDto.getId());
+        node.setName(nodeUpdateDto.getName());
+        node.setServerIp(primaryServerIp);
+        node.setServerIpV4(normalizedV4);
+        node.setServerIpV6(normalizedV6);
+        node.setPort(nodeUpdateDto.getPort());
+        node.setHttp(nodeUpdateDto.getHttp());
+        node.setTls(nodeUpdateDto.getTls());
+        node.setSocks(nodeUpdateDto.getSocks());
+        node.setUpdatedTime(System.currentTimeMillis());
+        node.setInterfaceName(nodeUpdateDto.getInterfaceName());
+        node.setTcpListenAddr(nodeUpdateDto.getTcpListenAddr());
+        node.setUdpListenAddr(nodeUpdateDto.getUdpListenAddr());
+        return node;
+    }
+
+    private String pickPrimaryServerIp(String serverIpV4, String serverIpV6, String fallback) {
+        if (StrUtil.isNotBlank(serverIpV4)) {
+            return serverIpV4.trim();
+        }
+        if (StrUtil.isNotBlank(serverIpV6)) {
+            return serverIpV6.trim();
+        }
+        return fallback != null ? fallback.trim() : null;
+    }
+
+    private String normalizeV4(String serverIpV4, String legacyServerIp) {
+        if (StrUtil.isNotBlank(serverIpV4)) {
+            return serverIpV4.trim();
+        }
+        if (StrUtil.isNotBlank(legacyServerIp) && looksLikeIpv4(legacyServerIp.trim())) {
+            return legacyServerIp.trim();
+        }
+        return null;
+    }
+
+    private String normalizeV6(String serverIpV6, String legacyServerIp) {
+        if (StrUtil.isNotBlank(serverIpV6)) {
+            return serverIpV6.trim();
+        }
+        if (StrUtil.isNotBlank(legacyServerIp) && looksLikeIpv6(legacyServerIp.trim())) {
+            return legacyServerIp.trim();
+        }
+        return null;
+    }
+
+    private boolean looksLikeIpv4(String value) {
+        // 仅用于判定地址族（不解析域名）
+        Pattern ipv4 = Pattern.compile("^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$");
+        return ipv4.matcher(value).matches();
+    }
+
+    private boolean looksLikeIpv6(String value) {
+        // 粗略判定 IPv6（与 GostUtil.processServerAddress 一致思路）
+        long colonCount = value.chars().filter(ch -> ch == ':').count();
+        return colonCount >= 2;
+    }


    private void validatePortRange(String port) {
@@ -18,6 +18,7 @@ import lombok.Data;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;

 import javax.annotation.Resource;
 import java.util.*;
@@ -116,14 +117,39 @@ public class TunnelServiceImpl extends ServiceImpl<TunnelMapper, Tunnel> impleme
        long currentTime = System.currentTimeMillis();
        tunnel.setCreatedTime(currentTime);
        tunnel.setUpdatedTime(currentTime);
+
+        // When tunnels are ordered via `inx`, new tunnels should be appended.
+        // Only apply this when an order already exists (max `inx` > 0) to avoid
+        // changing behavior for deployments still relying on local ordering.
+        Tunnel lastByInx = this.getOne(new QueryWrapper<Tunnel>()
+                .select("inx")
+                .orderByDesc("inx")
+                .orderByDesc("id")
+                .last("LIMIT 1"));
+        Integer maxInx = lastByInx == null ? null : lastByInx.getInx();
+        if (maxInx != null && maxInx > 0) {
+            tunnel.setInx(maxInx + 1);
+        }
        if (StringUtils.isEmpty(tunnel.getInIp())){
-            StringBuilder in_ip = new StringBuilder();
+            java.util.LinkedHashSet<String> inIps = new java.util.LinkedHashSet<>();
            for (ChainTunnel chainTunnel : tunnelDto.getInNodeId()) {
                Node node = nodes.get(chainTunnel.getNodeId());
-                in_ip.append(node.getServerIp()).append(",");
+                if (node == null) continue;
+                if (cn.hutool.core.util.StrUtil.isNotBlank(node.getServerIpV4())) {
+                    inIps.add(node.getServerIpV4().trim());
+                }
+                if (cn.hutool.core.util.StrUtil.isNotBlank(node.getServerIpV6())) {
+                    inIps.add(node.getServerIpV6().trim());
+                }
+                if (cn.hutool.core.util.StrUtil.isBlank(node.getServerIpV4())
+                        && cn.hutool.core.util.StrUtil.isBlank(node.getServerIpV6())
+                        && cn.hutool.core.util.StrUtil.isNotBlank(node.getServerIp())) {
+                    inIps.add(node.getServerIp().trim());
+                }
+            }
+            if (!inIps.isEmpty()) {
+                tunnel.setInIp(String.join(",", inIps));
            }
-            in_ip.deleteCharAt(in_ip.length() - 1);
-            tunnel.setInIp(in_ip.toString());
        }

        this.save(tunnel);
@@ -142,11 +168,33 @@ public class TunnelServiceImpl extends ServiceImpl<TunnelMapper, Tunnel> impleme
            for (ChainTunnel in_node : tunnelDto.getInNodeId()) {
                // 创建Chain， 指向chainNode的第一跳。如果chainNode为空就是指向出口
                if (tunnelDto.getChainNodes().isEmpty()) { // 指向出口
-                    GostDto gostDto = GostUtil.AddChains(in_node.getNodeId(), tunnelDto.getOutNodeId(), nodes);
-                    isError(gostDto);
+                    GostDto gostDto;
+                    try {
+                        gostDto = GostUtil.AddChains(in_node.getNodeId(), tunnelDto.getOutNodeId(), nodes);
+                    } catch (RuntimeException e) {
+                        this.removeById(tunnel.getId());
+                        chainTunnelService.remove(new QueryWrapper<ChainTunnel>().eq("tunnel_id", tunnel.getId()));
+                        return R.err(e.getMessage());
+                    }
+                    if (!Objects.equals(gostDto.getMsg(), "OK")) {
+                        this.removeById(tunnel.getId());
+                        chainTunnelService.remove(new QueryWrapper<ChainTunnel>().eq("tunnel_id", tunnel.getId()));
+                        return R.err(gostDto.getMsg());
+                    }

                } else {
-                    GostDto gostDto = GostUtil.AddChains(in_node.getNodeId(), tunnelDto.getChainNodes().getFirst(), nodes);// 指向第一跳
+                    GostDto gostDto;
+                    try {
+                        gostDto = GostUtil.AddChains(in_node.getNodeId(), tunnelDto.getChainNodes().getFirst(), nodes);// 指向第一跳
+                    } catch (RuntimeException e) {
+                        this.removeById(tunnel.getId());
+                        chainTunnelService.remove(new QueryWrapper<ChainTunnel>().eq("tunnel_id", tunnel.getId()));
+                        for (JSONObject chainSuccess : chain_success) {
+                            GostDto deleteChains = GostUtil.DeleteChains(chainSuccess.getLong("node_id"), chainSuccess.getString("name"));
+                            System.out.println(deleteChains);
+                        }
+                        return R.err(e.getMessage());
+                    }
                    if (Objects.equals(gostDto.getMsg(), "OK")){
                        JSONObject data = new JSONObject();
                        data.put("node_id", in_node.getNodeId());
@@ -170,7 +218,18 @@ public class TunnelServiceImpl extends ServiceImpl<TunnelMapper, Tunnel> impleme
                for (ChainTunnel chainTunnel : chainTunnels1) {
                    int inx = i+1;
                    if (inx >= tunnelDto.getChainNodes().size()) { // 指向出口
-                        GostDto gostDto = GostUtil.AddChains(chainTunnel.getNodeId(), tunnelDto.getOutNodeId(), nodes);
+                        GostDto gostDto;
+                        try {
+                            gostDto = GostUtil.AddChains(chainTunnel.getNodeId(), tunnelDto.getOutNodeId(), nodes);
+                        } catch (RuntimeException e) {
+                            this.removeById(tunnel.getId());
+                            chainTunnelService.remove(new QueryWrapper<ChainTunnel>().eq("tunnel_id", tunnel.getId()));
+                            for (JSONObject chainSuccess : chain_success) {
+                                GostDto deleteChains = GostUtil.DeleteChains(chainSuccess.getLong("node_id"), chainSuccess.getString("name"));
+                                System.out.println(deleteChains);
+                            }
+                            return R.err(e.getMessage());
+                        }
                        if (Objects.equals(gostDto.getMsg(), "OK")){
                            JSONObject data = new JSONObject();
                            data.put("node_id", chainTunnel.getNodeId());
@@ -186,7 +245,18 @@ public class TunnelServiceImpl extends ServiceImpl<TunnelMapper, Tunnel> impleme
                            return R.err(gostDto.getMsg());
                        }
                    } else {
-                        GostDto gostDto = GostUtil.AddChains(chainTunnel.getNodeId(), tunnelDto.getChainNodes().get(inx), nodes);
+                        GostDto gostDto;
+                        try {
+                            gostDto = GostUtil.AddChains(chainTunnel.getNodeId(), tunnelDto.getChainNodes().get(inx), nodes);
+                        } catch (RuntimeException e) {
+                            this.removeById(tunnel.getId());
+                            chainTunnelService.remove(new QueryWrapper<ChainTunnel>().eq("tunnel_id", tunnel.getId()));
+                            for (JSONObject chainSuccess : chain_success) {
+                                GostDto deleteChains = GostUtil.DeleteChains(chainSuccess.getLong("node_id"), chainSuccess.getString("name"));
+                                System.out.println(deleteChains);
+                            }
+                            return R.err(e.getMessage());
+                        }
                        if (Objects.equals(gostDto.getMsg(), "OK")){
                            JSONObject data = new JSONObject();
                            data.put("node_id", chainTunnel.getNodeId());
@@ -252,7 +322,7 @@ public class TunnelServiceImpl extends ServiceImpl<TunnelMapper, Tunnel> impleme

    @Override
    public R getAllTunnels() {
-        List<Tunnel> tunnelList = this.list();
+        List<Tunnel> tunnelList = this.list(new QueryWrapper<Tunnel>().orderByAsc("inx").orderByAsc("id"));
        
        // 查询所有隧道的ChainTunnel信息
        List<Long> tunnelIds = tunnelList.stream()
@@ -317,6 +387,34 @@ public class TunnelServiceImpl extends ServiceImpl<TunnelMapper, Tunnel> impleme
        return R.ok(detailDtoList);
    }

+    @Override
+    @Transactional
+    public R updateTunnelOrder(Map<String, Object> params) {
+        if (!params.containsKey("tunnels")) {
+            return R.err("缺少tunnels参数");
+        }
+
+        @SuppressWarnings("unchecked")
+        List<Map<String, Object>> tunnelsList = (List<Map<String, Object>>) params.get("tunnels");
+        if (tunnelsList == null || tunnelsList.isEmpty()) {
+            return R.err("tunnels参数不能为空");
+        }
+
+        List<Tunnel> tunnelsToUpdate = new ArrayList<>();
+        for (Map<String, Object> tunnelData : tunnelsList) {
+            Long id = Long.valueOf(tunnelData.get("id").toString());
+            Integer inx = Integer.valueOf(tunnelData.get("inx").toString());
+
+            Tunnel tunnel = new Tunnel();
+            tunnel.setId(id);
+            tunnel.setInx(inx);
+            tunnelsToUpdate.add(tunnel);
+        }
+
+        this.updateBatchById(tunnelsToUpdate);
+        return R.ok();
+    }
+

    @Override
    public R updateTunnel(TunnelUpdateDto tunnelUpdateDto) {
@@ -332,6 +430,15 @@ public class TunnelServiceImpl extends ServiceImpl<TunnelMapper, Tunnel> impleme
        if (hasNodeChanges && tunnelUpdateDto.getInNodeId() != null) {
            List<ChainTunnel> backupChains = deepCopyChainTunnels(oldChainTunnels);

+            Set<Long> oldEntryNodeIds = oldChainTunnels.stream()
+                    .filter(ct -> ct.getChainType() != null && ct.getChainType() == 1)
+                    .map(ChainTunnel::getNodeId)
+                    .collect(Collectors.toSet());
+
+            Set<Long> newEntryNodeIds = tunnelUpdateDto.getInNodeId().stream()
+                    .map(ChainTunnel::getNodeId)
+                    .collect(Collectors.toSet());
+
            List<Long> nodeIds = new ArrayList<>();
            Map<Long, Node> nodes = new HashMap<>();

@@ -413,6 +520,8 @@ public class TunnelServiceImpl extends ServiceImpl<TunnelMapper, Tunnel> impleme

                chainTunnelService.saveBatch(newChainTunnels);

+                syncForwardsForEntryNodeChanges(existingTunnel.getId(), oldEntryNodeIds, newEntryNodeIds);
+
            } catch (Exception e) {
                chainTunnelService.saveBatch(backupChains);
                rebuildGostConfig(backupChains, existingTunnel);
@@ -427,20 +536,31 @@ public class TunnelServiceImpl extends ServiceImpl<TunnelMapper, Tunnel> impleme
        tunnel.setTrafficRatio(tunnelUpdateDto.getTrafficRatio());
        tunnel.setInIp(tunnelUpdateDto.getInIp());

-        if (StringUtils.isEmpty(tunnel.getInIp())) {
-            StringBuilder inIp = new StringBuilder();
+        boolean forceRegenerateInIp = hasNodeChanges && tunnelUpdateDto.getInNodeId() != null;
+        if (StringUtils.isEmpty(tunnel.getInIp()) || forceRegenerateInIp) {
+            java.util.LinkedHashSet<String> inIps = new java.util.LinkedHashSet<>();
            List<ChainTunnel> chainTunnels = chainTunnelService.list(
                    new QueryWrapper<ChainTunnel>().eq("tunnel_id", tunnel.getId()).eq("chain_type", 1)
            );
            for (ChainTunnel chainTunnel : chainTunnels) {
                Node node = nodeService.getById(chainTunnel.getNodeId());
                if (node == null) return R.err("隧道节点数据错误，部分节点不存在");
-                inIp.append(node.getServerIp()).append(",");
+
+                if (cn.hutool.core.util.StrUtil.isNotBlank(node.getServerIpV4())) {
+                    inIps.add(node.getServerIpV4().trim());
+                }
+                if (cn.hutool.core.util.StrUtil.isNotBlank(node.getServerIpV6())) {
+                    inIps.add(node.getServerIpV6().trim());
+                }
+                if (cn.hutool.core.util.StrUtil.isBlank(node.getServerIpV4())
+                        && cn.hutool.core.util.StrUtil.isBlank(node.getServerIpV6())
+                        && cn.hutool.core.util.StrUtil.isNotBlank(node.getServerIp())) {
+                    inIps.add(node.getServerIp().trim());
+                }
            }
-            if (inIp.length() > 0) {
-                inIp.deleteCharAt(inIp.length() - 1);
+            if (!inIps.isEmpty()) {
+                tunnel.setInIp(String.join(",", inIps));
            }
-            tunnel.setInIp(inIp.toString());
        }

        tunnel.setUpdatedTime(System.currentTimeMillis());
@@ -489,7 +609,10 @@ public class TunnelServiceImpl extends ServiceImpl<TunnelMapper, Tunnel> impleme
        Integer roleId = JwtUtil.getRoleIdFromToken();
        Integer userId = JwtUtil.getUserIdFromToken();
        if (roleId == 0) {
-            tunnelEntities = this.list(new QueryWrapper<Tunnel>().eq("status", 1));
+            tunnelEntities = this.list(new QueryWrapper<Tunnel>()
+                    .eq("status", 1)
+                    .orderByAsc("inx")
+                    .orderByAsc("id"));
        } else {
            tunnelEntities = java.util.Collections.emptyList(); // 返回空列表
            List<UserTunnel> userTunnels = userTunnelMapper.selectList(
@@ -501,7 +624,9 @@ public class TunnelServiceImpl extends ServiceImpl<TunnelMapper, Tunnel> impleme
                        .collect(Collectors.toList());
                tunnelEntities = this.list(new QueryWrapper<Tunnel>()
                        .in("id", tunnelIds)
-                        .eq("status", 1));
+                        .eq("status", 1)
+                        .orderByAsc("inx")
+                        .orderByAsc("id"));
            }

        }
@@ -567,7 +692,7 @@ public class TunnelServiceImpl extends ServiceImpl<TunnelMapper, Tunnel> impleme
                            Node toNode = nodeService.getById(firstChainNode.getNodeId());
                            if (toNode != null) {
                                DiagnosisResult result = performTcpPingDiagnosisWithConnectionCheck(
-                                        fromNode, toNode.getServerIp(), firstChainNode.getPort(),
+                                        fromNode, GostUtil.selectDialHost(fromNode, toNode), firstChainNode.getPort(),
                                        "入口(" + fromNode.getName() + ")->第1跳(" + toNode.getName() + ")"
                                );
                                result.setFromChainType(1); // 入口
@@ -581,7 +706,7 @@ public class TunnelServiceImpl extends ServiceImpl<TunnelMapper, Tunnel> impleme
                            Node toNode = nodeService.getById(outNode.getNodeId());
                            if (toNode != null) {
                                DiagnosisResult result = performTcpPingDiagnosisWithConnectionCheck(
-                                        fromNode, toNode.getServerIp(), outNode.getPort(),
+                                        fromNode, GostUtil.selectDialHost(fromNode, toNode), outNode.getPort(),
                                        "入口(" + fromNode.getName() + ")->出口(" + toNode.getName() + ")"
                                );
                                result.setFromChainType(1);
@@ -605,7 +730,7 @@ public class TunnelServiceImpl extends ServiceImpl<TunnelMapper, Tunnel> impleme
                                Node toNode = nodeService.getById(nextNode.getNodeId());
                                if (toNode != null) {
                                    DiagnosisResult result = performTcpPingDiagnosisWithConnectionCheck(
-                                            fromNode, toNode.getServerIp(), nextNode.getPort(),
+                                                fromNode, GostUtil.selectDialHost(fromNode, toNode), nextNode.getPort(),
                                            "第" + (i + 1) + "跳(" + fromNode.getName() + ")->第" + (i + 2) + "跳(" + toNode.getName() + ")"
                                    );
                                    result.setFromChainType(2);
@@ -620,7 +745,7 @@ public class TunnelServiceImpl extends ServiceImpl<TunnelMapper, Tunnel> impleme
                                Node toNode = nodeService.getById(outNode.getNodeId());
                                if (toNode != null) {
                                    DiagnosisResult result = performTcpPingDiagnosisWithConnectionCheck(
-                                            fromNode, toNode.getServerIp(), outNode.getPort(),
+                                                fromNode, GostUtil.selectDialHost(fromNode, toNode), outNode.getPort(),
                                            "第" + (i + 1) + "跳(" + fromNode.getName() + ")->出口(" + toNode.getName() + ")"
                                    );
                                    result.setFromChainType(2);
@@ -711,7 +836,12 @@ public class TunnelServiceImpl extends ServiceImpl<TunnelMapper, Tunnel> impleme
    }

    private void isError(GostDto gostDto){
-
+        if (gostDto == null) {
+            throw new RuntimeException("节点无响应");
+        }
+        if (!Objects.equals(gostDto.getMsg(), "OK")) {
+            throw new RuntimeException(gostDto.getMsg());
+        }
    }

    private DiagnosisResult performTcpPingDiagnosis(Node node, String targetIp, int port, String description) {
@@ -1035,5 +1165,148 @@ public class TunnelServiceImpl extends ServiceImpl<TunnelMapper, Tunnel> impleme
        }
    }

+    private void syncForwardsForEntryNodeChanges(Long tunnelId, Set<Long> oldEntryNodeIds, Set<Long> newEntryNodeIds) {
+        Set<Long> addedNodeIds = new HashSet<>(newEntryNodeIds);
+        addedNodeIds.removeAll(oldEntryNodeIds);
+
+        Set<Long> removedNodeIds = new HashSet<>(oldEntryNodeIds);
+        removedNodeIds.removeAll(newEntryNodeIds);
+
+        if (addedNodeIds.isEmpty() && removedNodeIds.isEmpty()) {
+            return;
+        }
+
+        List<Forward> forwards = forwardService.list(
+                new QueryWrapper<Forward>().eq("tunnel_id", tunnelId.intValue())
+        );
+
+        if (forwards.isEmpty()) {
+            return;
+        }
+
+        Tunnel tunnel = this.getById(tunnelId);
+        if (tunnel == null) {
+            return;
+        }
+
+        for (Forward forward : forwards) {
+            if (forward.getStatus() != 1) {
+                continue;
+            }
+
+            UserTunnel userTunnel = userTunnelService.getOne(
+                    new QueryWrapper<UserTunnel>()
+                            .eq("user_id", forward.getUserId())
+                            .eq("tunnel_id", tunnelId.intValue())
+            );
+
+            for (Long removedNodeId : removedNodeIds) {
+                ForwardPort forwardPort = forwardPortService.getOne(
+                        new QueryWrapper<ForwardPort>()
+                                .eq("forward_id", forward.getId())
+                                .eq("node_id", removedNodeId)
+                );
+
+                if (forwardPort != null) {
+                    String serviceName = buildForwardServiceName(forward.getId(), forward.getUserId(), userTunnel);
+                    JSONArray services = new JSONArray();
+                    services.add(serviceName + "_tcp");
+                    services.add(serviceName + "_udp");
+                    GostUtil.DeleteService(removedNodeId, services);
+
+                    forwardPortService.removeById(forwardPort.getId());
+                }
+            }
+
+            for (Long addedNodeId : addedNodeIds) {
+                ForwardPort existingPort = forwardPortService.getOne(
+                        new QueryWrapper<ForwardPort>()
+                                .eq("forward_id", forward.getId())
+                                .eq("node_id", addedNodeId)
+                );
+
+                if (existingPort != null) {
+                    continue;
+                }
+
+                List<ForwardPort> existingPorts = forwardPortService.list(
+                        new QueryWrapper<ForwardPort>().eq("forward_id", forward.getId())
+                );
+
+                Integer targetPort = null;
+                if (!existingPorts.isEmpty()) {
+                    targetPort = existingPorts.get(0).getPort();
+                }
+
+                Integer allocatedPort = allocatePortForNode(addedNodeId, targetPort, forward.getId());
+                if (allocatedPort == null) {
+                    System.err.println("Failed to allocate port on node " + addedNodeId + " for forward " + forward.getId());
+                    continue;
+                }
+
+                ForwardPort newForwardPort = new ForwardPort();
+                newForwardPort.setForwardId(forward.getId());
+                newForwardPort.setNodeId(addedNodeId);
+                newForwardPort.setPort(allocatedPort);
+                forwardPortService.save(newForwardPort);
+
+                Node node = nodeService.getById(addedNodeId);
+                if (node != null) {
+                    String serviceName = buildForwardServiceName(forward.getId(), forward.getUserId(), userTunnel);
+                    Integer limiter = (userTunnel != null && userTunnel.getSpeedId() != null) ? userTunnel.getSpeedId() : null;
+                    GostUtil.AddAndUpdateService(serviceName, limiter, node, forward, newForwardPort, tunnel, "AddService");
+                }
+            }
+        }
+    }
+
+    private Integer allocatePortForNode(Long nodeId, Integer preferredPort, Long forwardId) {
+        Node node = nodeService.getById(nodeId);
+        if (node == null || node.getPort() == null) {
+            return null;
+        }
+
+        Set<Integer> usedPorts = new HashSet<>();
+
+        List<ChainTunnel> chainTunnels = chainTunnelService.list(
+                new QueryWrapper<ChainTunnel>().eq("node_id", nodeId)
+        );
+        for (ChainTunnel ct : chainTunnels) {
+            if (ct.getPort() != null) {
+                usedPorts.add(ct.getPort());
+            }
+        }
+
+        List<ForwardPort> forwardPorts = forwardPortService.list(
+                new QueryWrapper<ForwardPort>()
+                        .eq("node_id", nodeId)
+                        .ne("forward_id", forwardId)
+        );
+        for (ForwardPort fp : forwardPorts) {
+            if (fp.getPort() != null) {
+                usedPorts.add(fp.getPort());
+            }
+        }
+
+        List<Integer> availablePorts = parsePorts(node.getPort());
+
+        if (preferredPort != null && availablePorts.contains(preferredPort) && !usedPorts.contains(preferredPort)) {
+            return preferredPort;
+        }
+
+        for (Integer port : availablePorts) {
+            if (!usedPorts.contains(port)) {
+                return port;
+            }
+        }
+
+        return null;
+    }
+
+    private String buildForwardServiceName(Long forwardId, Integer userId, UserTunnel userTunnel) {
+        int userTunnelId = (userTunnel != null) ? userTunnel.getId() : 0;
+        return forwardId + "_" + userId + "_" + userTunnelId;
+    }
+

 }
@@ -1,120 +1,181 @@
-package com.admin.service.impl;
-
-import com.admin.common.dto.*;
-import com.admin.common.lang.R;
-import com.admin.entity.UserTunnel;
-import com.admin.mapper.TunnelMapper;
-import com.admin.mapper.UserTunnelMapper;
-import com.admin.service.TunnelService;
-import com.admin.service.UserTunnelService;
-import com.admin.service.ForwardService;
-import com.admin.service.NodeService;
-import com.admin.common.utils.GostUtil;
-import com.admin.entity.Forward;
-import com.admin.entity.Tunnel;
-import com.admin.entity.Node;
-import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
-import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
-import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
-import org.springframework.beans.BeanUtils;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.context.annotation.Lazy;
-import org.springframework.stereotype.Service;
-
-import javax.annotation.Resource;
-import java.util.List;
-import java.util.Map;
-
-/**
- * <p>
- * 用户隧道权限服务实现类
- * 提供用户隧道权限的分配、查询、更新和删除功能
- * 支持流量限制、数量限制、过期时间和限速规则的管理
- * </p>
- *
- * @author QAQ
- * @since 2025-06-03
- */
-@Service
-public class UserTunnelServiceImpl extends ServiceImpl<UserTunnelMapper, UserTunnel> implements UserTunnelService {
-
-
-    @Resource
-    @Lazy
-    private ForwardService forwardService;
-
-    @Override
-    public R assignUserTunnel(UserTunnelDto userTunnelDto) {
-        int count = this.count(new QueryWrapper<UserTunnel>().eq("user_id", userTunnelDto.getUserId()).eq("tunnel_id", userTunnelDto.getTunnelId()));
-        if (count > 0) return R.err("该用户已拥有此隧道权限");
-        UserTunnel userTunnel = new UserTunnel();
-        BeanUtils.copyProperties(userTunnelDto, userTunnel);
-        userTunnel.setStatus(1);
-        this.save(userTunnel);
-        return R.ok();
-    }
-
-    @Override
-    public R getUserTunnelList(UserTunnelQueryDto queryDto) {
-        List<UserTunnelWithDetailDto> userTunnelWithDetails = this.baseMapper.getUserTunnelWithDetails(queryDto.getUserId());
-        return R.ok(userTunnelWithDetails);
-    }
-
-    @Override
-    public R removeUserTunnel(Integer id) {
-        UserTunnel userTunnel = this.getById(id);
-        if (userTunnel == null) return R.err("未找到对应的用户隧道权限记录");
-
-        List<Forward> forwardList = forwardService.list(new QueryWrapper<Forward>().eq("user_id", userTunnel.getUserId()).eq("tunnel_id", userTunnel.getTunnelId()));
-        for (Forward forward : forwardList) {
-            forwardService.deleteForward(forward.getId());
-        }
-        this.removeById(id);
-        return R.ok();
-    }
-
-    @Override
-    public R updateUserTunnel(UserTunnelUpdateDto updateDto) {
-        UserTunnel userTunnel = this.getById(updateDto.getId());
-        if (userTunnel == null) return R.err("隧道不存在");
-        boolean speedChanged = hasSpeedChanged(userTunnel.getSpeedId(), updateDto.getSpeedId());
-        userTunnel.setFlow(updateDto.getFlow());
-        userTunnel.setNum(updateDto.getNum());
-        updateOptionalProperty(userTunnel::setFlowResetTime, updateDto.getFlowResetTime());
-        updateOptionalProperty(userTunnel::setExpTime, updateDto.getExpTime());
-        updateOptionalProperty(userTunnel::setStatus, updateDto.getStatus());
-        userTunnel.setSpeedId(updateDto.getSpeedId());
-        this.updateById(userTunnel);
-        if (speedChanged) {
-            List<Forward> forwardList = forwardService.list(new QueryWrapper<Forward>().eq("user_id", userTunnel.getUserId()).eq("tunnel_id", userTunnel.getTunnelId()));
-            for (Forward forward : forwardList) {
-                ForwardUpdateDto forwardUpdateDto = new ForwardUpdateDto();
-                forwardUpdateDto.setId(forward.getId());
-                forwardUpdateDto.setUserId(forward.getUserId());
-                forwardUpdateDto.setName(forward.getName());
-                forwardUpdateDto.setRemoteAddr(forward.getRemoteAddr());
-                forwardUpdateDto.setStrategy(forward.getStrategy());
-                forwardService.updateForward(forwardUpdateDto);
-            }
-        }
-        return R.err("用户隧道权限更新失败");
-    }
-
-    private <T> void updateOptionalProperty(java.util.function.Consumer<T> setter, T value) {
-        if (value != null) {
-            setter.accept(value);
-        }
-    }
-
-    private boolean hasSpeedChanged(Integer oldSpeedId, Integer newSpeedId) {
-        if (oldSpeedId == null && newSpeedId == null) {
-            return false;
-        }
-        if (oldSpeedId == null || newSpeedId == null) {
-            return true;
-        }
-        return !oldSpeedId.equals(newSpeedId);
-    }
-
-}
+package com.admin.service.impl;
+
+import com.admin.common.dto.*;
+import com.admin.common.lang.R;
+import com.admin.entity.User;
+import com.admin.entity.UserTunnel;
+import com.admin.mapper.UserTunnelMapper;
+import com.admin.service.UserService;
+import com.admin.service.UserTunnelService;
+import com.admin.service.ForwardService;
+import com.admin.entity.Forward;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.beans.BeanUtils;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+@Service
+public class UserTunnelServiceImpl extends ServiceImpl<UserTunnelMapper, UserTunnel> implements UserTunnelService {
+
+    @Resource
+    @Lazy
+    private ForwardService forwardService;
+
+    @Resource
+    @Lazy
+    private UserService userService;
+
+    @Override
+    public R assignUserTunnel(UserTunnelDto userTunnelDto) {
+        int count = this.count(new QueryWrapper<UserTunnel>()
+                .eq("user_id", userTunnelDto.getUserId())
+                .eq("tunnel_id", userTunnelDto.getTunnelId()));
+        if (count > 0) return R.err("该用户已拥有此隧道权限");
+
+        User user = userService.getById(userTunnelDto.getUserId());
+        if (user == null) return R.err("用户不存在");
+
+        UserTunnel userTunnel = new UserTunnel();
+        userTunnel.setUserId(userTunnelDto.getUserId());
+        userTunnel.setTunnelId(userTunnelDto.getTunnelId());
+        userTunnel.setSpeedId(userTunnelDto.getSpeedId());
+        userTunnel.setStatus(1);
+        userTunnel.setInFlow(0L);
+        userTunnel.setOutFlow(0L);
+
+        userTunnel.setFlow(userTunnelDto.getFlow() != null ? userTunnelDto.getFlow() : user.getFlow());
+        userTunnel.setNum(userTunnelDto.getNum() != null ? userTunnelDto.getNum() : user.getNum());
+        userTunnel.setFlowResetTime(userTunnelDto.getFlowResetTime() != null ? userTunnelDto.getFlowResetTime() : user.getFlowResetTime());
+        userTunnel.setExpTime(userTunnelDto.getExpTime() != null ? userTunnelDto.getExpTime() : user.getExpTime());
+
+        this.save(userTunnel);
+        return R.ok();
+    }
+
+    @Override
+    public R batchAssignUserTunnel(UserTunnelBatchAssignDto batchAssignDto) {
+        User user = userService.getById(batchAssignDto.getUserId());
+        if (user == null) return R.err("用户不存在");
+
+        Map<Integer, UserTunnelBatchAssignDto.TunnelAssignItem> uniqueTunnels = new LinkedHashMap<>();
+        for (UserTunnelBatchAssignDto.TunnelAssignItem item : batchAssignDto.getTunnels()) {
+            uniqueTunnels.putIfAbsent(item.getTunnelId(), item);
+        }
+
+        Set<Integer> existingTunnelIds = this.list(
+                new QueryWrapper<UserTunnel>()
+                        .eq("user_id", batchAssignDto.getUserId())
+                        .in("tunnel_id", uniqueTunnels.keySet())
+        ).stream().map(UserTunnel::getTunnelId).collect(Collectors.toSet());
+
+        List<UserTunnel> toSave = new ArrayList<>();
+        List<Integer> skippedIds = new ArrayList<>();
+
+        for (UserTunnelBatchAssignDto.TunnelAssignItem item : uniqueTunnels.values()) {
+            if (existingTunnelIds.contains(item.getTunnelId())) {
+                skippedIds.add(item.getTunnelId());
+                continue;
+            }
+
+            UserTunnel ut = new UserTunnel();
+            ut.setUserId(batchAssignDto.getUserId());
+            ut.setTunnelId(item.getTunnelId());
+            ut.setSpeedId(item.getSpeedId());
+            ut.setStatus(1);
+            ut.setInFlow(0L);
+            ut.setOutFlow(0L);
+            ut.setFlow(user.getFlow());
+            ut.setNum(user.getNum());
+            ut.setFlowResetTime(user.getFlowResetTime());
+            ut.setExpTime(user.getExpTime());
+            toSave.add(ut);
+        }
+
+        if (toSave.isEmpty()) {
+            return R.err("所选隧道用户均已拥有权限");
+        }
+
+        this.saveBatch(toSave);
+
+        if (!skippedIds.isEmpty()) {
+            return R.ok("成功分配 " + toSave.size() + " 个隧道，跳过 " + skippedIds.size() + " 个已有权限的隧道");
+        }
+        return R.ok();
+    }
+
+    @Override
+    public R getUserTunnelList(UserTunnelQueryDto queryDto) {
+        List<UserTunnelWithDetailDto> userTunnelWithDetails = this.baseMapper.getUserTunnelWithDetails(queryDto.getUserId());
+        return R.ok(userTunnelWithDetails);
+    }
+
+    @Override
+    public R removeUserTunnel(Integer id) {
+        UserTunnel userTunnel = this.getById(id);
+        if (userTunnel == null) return R.err("未找到对应的用户隧道权限记录");
+
+        List<Forward> forwardList = forwardService.list(new QueryWrapper<Forward>()
+                .eq("user_id", userTunnel.getUserId())
+                .eq("tunnel_id", userTunnel.getTunnelId()));
+        for (Forward forward : forwardList) {
+            forwardService.deleteForward(forward.getId());
+        }
+        this.removeById(id);
+        return R.ok();
+    }
+
+    @Override
+    public R updateUserTunnel(UserTunnelUpdateDto updateDto) {
+        UserTunnel userTunnel = this.getById(updateDto.getId());
+        if (userTunnel == null) return R.err("隧道不存在");
+        boolean speedChanged = hasSpeedChanged(userTunnel.getSpeedId(), updateDto.getSpeedId());
+        userTunnel.setFlow(updateDto.getFlow());
+        userTunnel.setNum(updateDto.getNum());
+        updateOptionalProperty(userTunnel::setFlowResetTime, updateDto.getFlowResetTime());
+        updateOptionalProperty(userTunnel::setExpTime, updateDto.getExpTime());
+        updateOptionalProperty(userTunnel::setStatus, updateDto.getStatus());
+        userTunnel.setSpeedId(updateDto.getSpeedId());
+        this.updateById(userTunnel);
+        if (speedChanged) {
+            List<Forward> forwardList = forwardService.list(new QueryWrapper<Forward>()
+                    .eq("user_id", userTunnel.getUserId())
+                    .eq("tunnel_id", userTunnel.getTunnelId()));
+            for (Forward forward : forwardList) {
+                ForwardUpdateDto forwardUpdateDto = new ForwardUpdateDto();
+                forwardUpdateDto.setId(forward.getId());
+                forwardUpdateDto.setUserId(forward.getUserId());
+                forwardUpdateDto.setName(forward.getName());
+                forwardUpdateDto.setRemoteAddr(forward.getRemoteAddr());
+                forwardUpdateDto.setStrategy(forward.getStrategy());
+                forwardService.updateForward(forwardUpdateDto);
+            }
+        }
+        return R.ok();
+    }
+
+    private <T> void updateOptionalProperty(java.util.function.Consumer<T> setter, T value) {
+        if (value != null) {
+            setter.accept(value);
+        }
+    }
+
+    private boolean hasSpeedChanged(Integer oldSpeedId, Integer newSpeedId) {
+        if (oldSpeedId == null && newSpeedId == null) {
+            return false;
+        }
+        if (oldSpeedId == null || newSpeedId == null) {
+            return true;
+        }
+        return !oldSpeedId.equals(newSpeedId);
+    }
+
+}
@@ -29,6 +29,8 @@ CREATE TABLE IF NOT EXISTS node (
  name VARCHAR(100) NOT NULL,
  secret VARCHAR(100) NOT NULL,
  server_ip VARCHAR(100) NOT NULL,
+  server_ip_v4 VARCHAR(100),
+  server_ip_v6 VARCHAR(100),
  port TEXT NOT NULL,
  interface_name VARCHAR(200),
  version VARCHAR(100),
@@ -39,7 +41,8 @@ CREATE TABLE IF NOT EXISTS node (
  updated_time INTEGER,
  status INTEGER NOT NULL,
  tcp_listen_addr VARCHAR(100) NOT NULL DEFAULT '[::]',
-  udp_listen_addr VARCHAR(100) NOT NULL DEFAULT '[::]'
+  udp_listen_addr VARCHAR(100) NOT NULL DEFAULT '[::]',
+  inx INTEGER NOT NULL DEFAULT 0
 );

 CREATE TABLE IF NOT EXISTS speed_limit (
@@ -72,7 +75,8 @@ CREATE TABLE IF NOT EXISTS tunnel (
  created_time INTEGER NOT NULL,
  updated_time INTEGER NOT NULL,
  status INTEGER NOT NULL,
-  in_ip TEXT
+  in_ip TEXT,
+  inx INTEGER NOT NULL DEFAULT 0
 );

 CREATE TABLE IF NOT EXISTS chain_tunnel (
@@ -123,4 +127,3 @@ CREATE TABLE IF NOT EXISTS vite_config (
  value VARCHAR(200) NOT NULL,
  time INTEGER NOT NULL
 );
-
@@ -0,0 +1,162 @@
+package com.admin;
+
+import com.admin.common.lang.R;
+import com.admin.entity.Node;
+import com.admin.entity.Tunnel;
+import com.admin.service.NodeService;
+import com.admin.service.TunnelService;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.jdbc.core.JdbcTemplate;
+
+import javax.annotation.Resource;
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@SpringBootTest(properties = {
+        // use a local sqlite file for tests (resolved via ${DB_PATH} placeholder)
+        "DB_PATH=./target/test-gost-ordering.db",
+})
+class OrderingUpdateTests {
+
+    @Resource
+    private JdbcTemplate jdbcTemplate;
+
+    @Resource
+    private NodeService nodeService;
+
+    @Resource
+    private TunnelService tunnelService;
+
+    @BeforeEach
+    void cleanup() {
+        // keep it simple; other tables may have foreign references in real runs
+        jdbcTemplate.execute("DELETE FROM node");
+        jdbcTemplate.execute("DELETE FROM tunnel");
+    }
+
+    @Test
+    void updateNodeOrder_updatesInx() {
+        Node n1 = new Node();
+        n1.setName("n1");
+        n1.setSecret("s1");
+        n1.setServerIp("127.0.0.1");
+        n1.setPort("1000-2000");
+        n1.setInterfaceName("");
+        n1.setHttp(0);
+        n1.setTls(0);
+        n1.setSocks(0);
+        n1.setTcpListenAddr("[::]");
+        n1.setUdpListenAddr("[::]");
+        n1.setStatus(0);
+        n1.setInx(0);
+        long now = System.currentTimeMillis();
+        n1.setCreatedTime(now);
+        n1.setUpdatedTime(now);
+        assertTrue(nodeService.save(n1));
+
+        Node n2 = new Node();
+        n2.setName("n2");
+        n2.setSecret("s2");
+        n2.setServerIp("127.0.0.2");
+        n2.setPort("1000-2000");
+        n2.setInterfaceName("");
+        n2.setHttp(0);
+        n2.setTls(0);
+        n2.setSocks(0);
+        n2.setTcpListenAddr("[::]");
+        n2.setUdpListenAddr("[::]");
+        n2.setStatus(0);
+        n2.setInx(0);
+        n2.setCreatedTime(now);
+        n2.setUpdatedTime(now);
+        assertTrue(nodeService.save(n2));
+
+        Node n3 = new Node();
+        n3.setName("n3");
+        n3.setSecret("s3");
+        n3.setServerIp("127.0.0.3");
+        n3.setPort("1000-2000");
+        n3.setInterfaceName("");
+        n3.setHttp(0);
+        n3.setTls(0);
+        n3.setSocks(0);
+        n3.setTcpListenAddr("[::]");
+        n3.setUdpListenAddr("[::]");
+        n3.setStatus(0);
+        n3.setInx(0);
+        n3.setCreatedTime(now);
+        n3.setUpdatedTime(now);
+        assertTrue(nodeService.save(n3));
+
+        List<Map<String, Object>> nodes = new ArrayList<>();
+        nodes.add(mapIdInx(n2.getId(), 0));
+        nodes.add(mapIdInx(n1.getId(), 1));
+        nodes.add(mapIdInx(n3.getId(), 2));
+
+        Map<String, Object> params = new HashMap<>();
+        params.put("nodes", nodes);
+
+        R res = nodeService.updateNodeOrder(params);
+        assertEquals(0, res.getCode());
+
+        assertEquals(1, nodeService.getById(n1.getId()).getInx());
+        assertEquals(0, nodeService.getById(n2.getId()).getInx());
+        assertEquals(2, nodeService.getById(n3.getId()).getInx());
+    }
+
+    @Test
+    void updateTunnelOrder_updatesInx() {
+        long now = System.currentTimeMillis();
+
+        Tunnel t1 = new Tunnel();
+        t1.setName("t1");
+        t1.setType(1);
+        t1.setFlow(1);
+        t1.setTrafficRatio(new BigDecimal("1.0"));
+        t1.setInIp("");
+        t1.setStatus(1);
+        t1.setInx(0);
+        t1.setCreatedTime(now);
+        t1.setUpdatedTime(now);
+        assertTrue(tunnelService.save(t1));
+
+        Tunnel t2 = new Tunnel();
+        t2.setName("t2");
+        t2.setType(2);
+        t2.setFlow(2);
+        t2.setTrafficRatio(new BigDecimal("1.0"));
+        t2.setInIp("");
+        t2.setStatus(1);
+        t2.setInx(0);
+        t2.setCreatedTime(now);
+        t2.setUpdatedTime(now);
+        assertTrue(tunnelService.save(t2));
+
+        List<Map<String, Object>> tunnels = new ArrayList<>();
+        tunnels.add(mapIdInx(t2.getId(), 0));
+        tunnels.add(mapIdInx(t1.getId(), 1));
+
+        Map<String, Object> params = new HashMap<>();
+        params.put("tunnels", tunnels);
+
+        R res = tunnelService.updateTunnelOrder(params);
+        assertEquals(0, res.getCode());
+
+        assertEquals(1, tunnelService.getById(t1.getId()).getInx());
+        assertEquals(0, tunnelService.getById(t2.getId()).getInx());
+    }
+
+    private static Map<String, Object> mapIdInx(Long id, int inx) {
+        Map<String, Object> m = new HashMap<>();
+        m.put("id", id);
+        m.put("inx", inx);
+        return m;
+    }
+}
@@ -1,34 +1,36 @@
 # VITE FRONTEND KNOWLEDGE BASE

+**Generated:** Mon Feb 02 2026
+
 ## OVERVIEW
 Web management console for Flux Panel.
-**Stack:** React 18, Vite 5, TypeScript, TailwindCSS 4, HeroUI (NextUI).
+**Stack:** React 18, Vite 5, TypeScript, TailwindCSS 4, HeroUI.

 ## STRUCTURE
 ```
 vite-frontend/
 ├── src/
-│   ├── pages/        # Route views
+│   ├── pages/        # Route views (some very large single-file pages)
 │   ├── components/   # Reusable UI parts
-│   ├── layouts/      # Page wrappers
-│   ├── api/          # Axios wrappers
-│   ├── config/       # App settings
-│   └── utils/        # Helpers
-├── vite.config.ts    # Vite config (Base: '/')
+│   ├── layouts/      # Admin vs H5 layouts
+│   ├── api/          # API functions + axios wrapper
+│   ├── config/       # Site config (title, repo, version)
+│   └── utils/        # Auth/JWT + WebView helpers
+├── vite.config.ts    # base '/', host 0.0.0.0:3000; build minify/treeshake disabled
+├── eslint.config.mjs  # ESLint 9 flat config
 └── package.json
 ```

 ## CONVENTIONS
- **UI Lib**: HeroUI (formerly NextUI) + Tailwind CSS 4.
- **Routing**: React Router DOM 6.
- **State**: Check `provider.tsx` or local state.
- **Build**: Output to `dist/`.
+- **Routing**: React Router v6 routes in `vite-frontend/src/App.tsx`.
+- **Auth**: JWT stored as `localStorage.token`; sent as `Authorization` header (no prefix) in `vite-frontend/src/api/network.ts`.
+- **Base URL**: Defaults to `/api/v1/` (or `VITE_API_BASE`); WebView mode selects a panel address via `vite-frontend/src/utils/panel.ts`.
+- **UI**: HeroUI provider + theme + toast wired in `vite-frontend/src/provider.tsx`.

 ## COMMANDS
 ```bash
-# Dev
+cd vite-frontend
 npm run dev
-
-# Build
 npm run build
+npm run lint
 ```
@@ -0,0 +1,38 @@
+# VITE FRONTEND (src) KNOWLEDGE BASE
+
+## OVERVIEW
+React app entry + routing + providers. This is where UI architecture decisions live.
+
+## STRUCTURE
+```
+vite-frontend/src/
+├── main.tsx        # ReactDOM + BrowserRouter + Provider
+├── provider.tsx    # HeroUI + theme + toaster + i18n wrapper
+├── App.tsx         # Routes + ProtectedRoute + H5 layout selection
+├── api/            # Axios wrapper + typed endpoint helpers
+├── pages/          # Route views (large)
+├── layouts/        # Admin/H5 page chrome
+├── components/     # Shared UI components
+├── utils/          # JWT parsing + auth helpers + WebView utilities
+└── styles/         # globals.css
+```
+
+## WHERE TO LOOK
+| Task | Location | Notes |
+|------|----------|-------|
+| Route definitions | `vite-frontend/src/App.tsx` | React Router v6 |
+| API client baseURL | `vite-frontend/src/api/network.ts` | `/api/v1/` + token header |
+| Token decoding | `vite-frontend/src/utils/jwt.ts` | Checks `exp` vs now |
+| Role checks | `vite-frontend/src/utils/auth.ts` | `isAdmin()` is `role_id == 0` |
+| WebView integration | `vite-frontend/src/api/network.ts` | Panel address selection in WebView mode |
+
+## CONVENTIONS
+- Token is stored in `localStorage.token` and sent as `Authorization` header (raw token string).
+- H5 mode detection is in `vite-frontend/src/App.tsx` (screen/user-agent/query param `h5=true`).
+
+## COMMANDS
+```bash
+cd vite-frontend
+npm run dev
+npm run lint
+```
@@ -0,0 +1,16 @@
+# VITE FRONTEND (src/api) KNOWLEDGE BASE
+
+## OVERVIEW
+API client layer. Wraps axios and normalizes backend responses (`{ code, msg, data }`).
+
+## WHERE TO LOOK
+| Task | Location | Notes |
+|------|----------|-------|
+| Axios wrapper | `vite-frontend/src/api/network.ts` | Sets `axios.defaults.baseURL`; adds `Authorization` header |
+| BaseURL init (WebView vs web) | `vite-frontend/src/api/network.ts` | WebView mode calls `getPanelAddresses()` |
+| Endpoint functions | `vite-frontend/src/api/index.ts` | Mostly `Network.post("/…")` |
+
+## CONVENTIONS
+- Default baseURL is `/api/v1/` (or `${VITE_API_BASE}/api/v1/`).
+- In WebView mode, baseURL is derived from the selected panel address; if unset, requests return `code: -1` with a “set panel address” message.
+- 401 responses clear localStorage and redirect to `/`.
@@ -29,6 +29,7 @@ export const getNodeList = () => Network.post("/node/list");
 export const updateNode = (data: any) => Network.post("/node/update", data);
 export const deleteNode = (id: number) => Network.post("/node/delete", { id });
 export const getNodeInstallCommand = (id: number) => Network.post("/node/install", { id });
+export const updateNodeOrder = (data: { nodes: Array<{ id: number; inx: number }> }) => Network.post("/node/update-order", data);
 export const checkNodeStatus = (nodeId?: number) => {
  const params = nodeId ? { nodeId } : {};
  return Network.post("/node/check-status", params);
@@ -41,9 +42,12 @@ export const getTunnelById = (id: number) => Network.post("/tunnel/get", { id })
 export const updateTunnel = (data: any) => Network.post("/tunnel/update", data);
 export const deleteTunnel = (id: number) => Network.post("/tunnel/delete", { id });
 export const diagnoseTunnel = (tunnelId: number) => Network.post("/tunnel/diagnose", { tunnelId });
+export const updateTunnelOrder = (data: { tunnels: Array<{ id: number; inx: number }> }) => Network.post("/tunnel/update-order", data);

 // 用户隧道权限管理操作 - 全部使用POST请求
 export const assignUserTunnel = (data: any) => Network.post("/tunnel/user/assign", data);
+export const batchAssignUserTunnel = (data: { userId: number; tunnels: Array<{ tunnelId: number; speedId?: number | null }> }) => 
+  Network.post("/tunnel/user/batch-assign", data);
 export const getUserTunnelList = (queryData: any = {}) => Network.post("/tunnel/user/list", queryData);
 export const removeUserTunnel = (params: any) => Network.post("/tunnel/user/remove", params);
 export const updateUserTunnel = (data: any) => Network.post("/tunnel/user/update", data);
@@ -88,4 +92,4 @@ export const updateConfig = (name: string, value: string) => Network.post("/conf
 // 验证码相关接口
 export const checkCaptcha = () => Network.post("/captcha/check");
 export const generateCaptcha = () => Network.post(`/captcha/generate`);
-export const verifyCaptcha = (data: { captchaId: string; trackData: string }) => Network.post("/captcha/verify", data); 
+export const verifyCaptcha = (data: { captchaId: string; trackData: string }) => Network.post("/captcha/verify", data); 
@@ -4,7 +4,7 @@ export type SiteConfig = typeof siteConfig;

 // 缓存相关常量
 const CACHE_PREFIX = 'vite_config_';
-const VERSION = "2.0.7-beta";
+const VERSION = import.meta.env.VITE_APP_VERSION || "dev";
 const APP_VERSION = "1.0.3";
 const GITHUB_REPO = import.meta.env.VITE_GITHUB_REPO || "https://github.com/Sagit-chu/flux-panel";

@@ -0,0 +1,30 @@
+# VITE FRONTEND (pages) KNOWLEDGE BASE
+
+## OVERVIEW
+Route views rendered by `vite-frontend/src/App.tsx`. Several pages are large, single-file screens.
+
+## STRUCTURE
+```
+vite-frontend/src/pages/
+├── index.tsx            # Login + captcha flow
+├── dashboard.tsx
+├── forward.tsx          # Large
+├── tunnel.tsx           # Large
+├── node.tsx             # Large
+├── user.tsx             # Large
+├── config.tsx
+├── limit.tsx
+├── profile.tsx
+├── settings.tsx
+└── change-password.tsx
+```
+
+## WHERE TO LOOK
+| Task | Location | Notes |
+|------|----------|-------|
+| Login flow | `vite-frontend/src/pages/index.tsx` | Calls `login()` and stores `localStorage.token` |
+| API calls | `vite-frontend/src/api/index.ts` | Thin wrappers around `Network.post` |
+| Token expiration behavior | `vite-frontend/src/api/network.ts` | Clears localStorage + redirects on 401 |
+
+## CONVENTIONS
+- Pages call API wrappers from `vite-frontend/src/api/index.ts` (most endpoints are POST).
@@ -741,31 +741,45 @@ export default function DashboardPage() {
                           tickLine={false}
                           axisLine={{ stroke: '#e5e7eb', strokeWidth: 1 }}
                         />
-                         <YAxis 
-                           tick={{ fontSize: 12 }}
-                           tickLine={false}
-                           axisLine={{ stroke: '#e5e7eb', strokeWidth: 1 }}
-                           tickFormatter={(value) => {
-                             if (value === 0) return '0';
-                             if (value < 1024) return `${value}B`;
-                             if (value < 1024 * 1024) return `${(value / 1024).toFixed(1)}K`;
-                             if (value < 1024 * 1024 * 1024) return `${(value / (1024 * 1024)).toFixed(1)}M`;
-                             return `${(value / (1024 * 1024 * 1024)).toFixed(1)}G`;
-                           }}
-                         />
-                         <Tooltip 
-                           content={({ active, payload, label }) => {
-                             if (active && payload && payload.length) {
-                               return (
-                                 <div className="bg-white dark:bg-default-100 border border-default-200 rounded-lg shadow-lg p-3">
-                                   <p className="font-medium text-foreground">{`时间: ${label}`}</p>
-                                   <p className="text-primary">
-                                     {`流量: ${formatFlow(payload[0]?.value as number || 0)}`}
-                                   </p>
-                                 </div>
-                               );
-                             }
-                             return null;
+                          <YAxis 
+                            tick={{ fontSize: 12 }}
+                            tickLine={false}
+                            axisLine={{ stroke: '#e5e7eb', strokeWidth: 1 }}
+                            tickFormatter={(value: number | string) => {
+                              const v = typeof value === 'number' ? value : Number(value);
+                              if (!Number.isFinite(v)) return String(value);
+                              if (v === 0) return '0';
+                              if (v < 1024) return `${v}B`;
+                              if (v < 1024 * 1024) return `${(v / 1024).toFixed(1)}K`;
+                              if (v < 1024 * 1024 * 1024) return `${(v / (1024 * 1024)).toFixed(1)}M`;
+                              return `${(v / (1024 * 1024 * 1024)).toFixed(1)}G`;
+                            }}
+                          />
+                          <Tooltip 
+                            content={({
+                              active,
+                              payload,
+                              label,
+                            }: {
+                              active?: boolean;
+                              payload?: Array<{ value?: number | string }>;
+                              label?: string | number;
+                            }) => {
+                              if (active && payload && payload.length) {
+                                const firstValue = payload[0]?.value;
+                                const numericValue = typeof firstValue === 'number' ? firstValue : Number(firstValue);
+                                const flowValue = Number.isFinite(numericValue) ? numericValue : 0;
+
+                                return (
+                                  <div className="bg-white dark:bg-default-100 border border-default-200 rounded-lg shadow-lg p-3">
+                                    <p className="font-medium text-foreground">{`时间: ${label ?? ''}`}</p>
+                                    <p className="text-primary">
+                                      {`流量: ${formatFlow(flowValue)}`}
+                                    </p>
+                                  </div>
+                                );
+                              }
+                              return null;
                           }}
                         />
                         <Line
@@ -983,4 +997,4 @@ export default function DashboardPage() {
      </div>
          
  );
-} 
+} 
@@ -1,4 +1,4 @@
-import { useState, useEffect } from "react";
+import { useState, useEffect, useMemo } from "react";
 import { Card, CardBody, CardHeader } from "@heroui/card";
 import { Button } from "@heroui/button";
 import { Input } from "@heroui/input";
@@ -15,7 +15,8 @@ import {
  DndContext,
  closestCenter,
  KeyboardSensor,
-  PointerSensor,
+  MouseSensor,
+  TouchSensor,
  useSensor,
  useSensors,
  DragEndEvent,
@@ -353,8 +354,6 @@ export default function ForwardPage() {
    const userMap = new Map<string, UserGroup>();
    
    // 获取排序后的转发列表
-    const sortedForwards = getSortedForwards();
-    
    sortedForwards.forEach(forward => {
      const userKey = forward.userId ? forward.userId.toString() : 'unknown';
      const userName = forward.userName || '未知用户';
@@ -855,7 +854,7 @@ export default function ForwardPage() {
        );
      } else {
        // 直接显示模式下，过滤指定隧道的转发
-        forwardsToExport = getSortedForwards().filter(forward => forward.tunnelId === selectedTunnelForExport);
+        forwardsToExport = sortedForwards.filter(forward => forward.tunnelId === selectedTunnelForExport);
      }
      
      if (forwardsToExport.length === 0) {
@@ -1102,64 +1101,80 @@ export default function ForwardPage() {

  // 传感器配置 - 使用默认配置避免错误
  const sensors = useSensors(
-    useSensor(PointerSensor),
+    useSensor(MouseSensor, {
+      activationConstraint: {
+        distance: 8,
+      },
+    }),
+    useSensor(TouchSensor, {
+      activationConstraint: {
+        delay: 250,
+        tolerance: 8,
+      },
+    }),
    useSensor(KeyboardSensor, {
      coordinateGetter: sortableKeyboardCoordinates,
    })
  );

+  const tokenUserId = JwtUtil.getUserIdFromToken();
+
  // 根据排序顺序获取转发列表
-  const getSortedForwards = (): Forward[] => {
+  const sortedForwards = useMemo((): Forward[] => {
    // 确保 forwards 数组存在且有效
    if (!forwards || forwards.length === 0) {
      return [];
    }
-    
+
    // 在平铺模式下，只显示当前用户的转发
    let filteredForwards = forwards;
    if (viewMode === 'direct') {
-      const currentUserId = JwtUtil.getUserIdFromToken();
-      if (currentUserId !== null) {
-        filteredForwards = forwards.filter(forward => forward.userId === currentUserId);
+      if (tokenUserId !== null) {
+        filteredForwards = forwards.filter(forward => forward.userId === tokenUserId);
      }
    }
-    
+
    // 确保过滤后的转发列表有效
    if (!filteredForwards || filteredForwards.length === 0) {
      return [];
    }
-    
+
    // 优先使用数据库中的 inx 字段进行排序
-    const sortedForwards = [...filteredForwards].sort((a, b) => {
+    const sortedByDb = [...filteredForwards].sort((a, b) => {
      const aInx = a.inx ?? 0;
      const bInx = b.inx ?? 0;
      return aInx - bInx;
    });
-    
+
    // 如果数据库中没有排序信息，则使用本地存储的顺序
-    if (forwardOrder && forwardOrder.length > 0 && sortedForwards.every(f => f.inx === undefined || f.inx === 0)) {
+    if (forwardOrder && forwardOrder.length > 0 && sortedByDb.every(f => f.inx === undefined || f.inx === 0)) {
      const forwardMap = new Map(filteredForwards.map(f => [f.id, f]));
      const localSortedForwards: Forward[] = [];
-      
+
      forwardOrder.forEach(id => {
        const forward = forwardMap.get(id);
        if (forward) {
          localSortedForwards.push(forward);
        }
      });
-      
+
      // 添加不在排序列表中的转发（新添加的）
      filteredForwards.forEach(forward => {
        if (!forwardOrder.includes(forward.id)) {
          localSortedForwards.push(forward);
        }
      });
-      
+
      return localSortedForwards;
    }
-    
-    return sortedForwards;
-  };
+
+    return sortedByDb;
+  }, [forwards, forwardOrder, viewMode, tokenUserId]);
+
+  const sortableForwardIds = useMemo(
+    () => sortedForwards.map(f => f.id).filter(id => id > 0),
+    [sortedForwards]
+  );

  // 可拖拽的转发卡片组件
  const SortableForwardCard = ({ forward }: { forward: Forward }) => {
@@ -1179,8 +1194,9 @@ export default function ForwardPage() {

    const style = {
      transform: transform ? CSS.Transform.toString(transform) : undefined,
-      transition: transition || undefined,
+      transition: isDragging ? undefined : transition || undefined,
      opacity: isDragging ? 0.5 : 1,
+      willChange: 'transform',
    };

    return (
@@ -1529,11 +1545,11 @@ export default function ForwardPage() {
              onDragStart={() => {}} // 添加空的 onDragStart 处理器
            >
              <SortableContext
-                items={getSortedForwards().map(f => f.id || 0).filter(id => id > 0)}
+                items={sortableForwardIds}
                strategy={rectSortingStrategy}
              >
                <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 2xl:grid-cols-5 gap-4">
-                  {getSortedForwards().map((forward) => (
+                  {sortedForwards.map((forward) => (
                    forward && forward.id ? (
                      <SortableForwardCard key={forward.id} forward={forward} />
                    ) : null
@@ -1606,8 +1622,7 @@ export default function ForwardPage() {
                      isInvalid={!!errors.tunnelId}
                      errorMessage={errors.tunnelId}
                      variant="bordered"
-                      isDisabled={isEdit}
-                      description={isEdit ? "编辑时无法修改关联隧道" : undefined}
+                      description={isEdit ? "更改隧道将释放原端口并在新隧道分配端口" : undefined}
                    >
                      {tunnels.map((tunnel) => (
                        <SelectItem key={tunnel.id} >
@@ -2395,4 +2410,4 @@ export default function ForwardPage() {
      </div>
    
  );
-} 
+} 
@@ -1,4 +1,4 @@
-import { useState, useEffect, useRef } from "react";
+import { useState, useEffect, useMemo, useRef } from "react";
 import { Card, CardBody, CardHeader } from "@heroui/card";
 import { Button } from "@heroui/button";
 import { Input } from "@heroui/input";
@@ -13,20 +13,42 @@ import { Accordion, AccordionItem } from "@heroui/accordion";
 import toast from 'react-hot-toast';
 import axios from 'axios';

+import {
+  DndContext,
+  KeyboardSensor,
+  MouseSensor,
+  TouchSensor,
+  type DragEndEvent,
+  useSensor,
+  useSensors,
+} from '@dnd-kit/core';
+import {
+  SortableContext,
+  arrayMove,
+  rectSortingStrategy,
+  sortableKeyboardCoordinates,
+  useSortable,
+} from '@dnd-kit/sortable';
+import { CSS } from '@dnd-kit/utilities';
+

 import { 
  createNode, 
  getNodeList, 
  updateNode, 
  deleteNode,
-  getNodeInstallCommand
+  getNodeInstallCommand,
+  updateNodeOrder
 } from "@/api";

 interface Node {
  id: number;
+  inx?: number;
  name: string;
  ip: string;
  serverIp: string;
+  serverIpV4?: string;
+  serverIpV6?: string;
  port: string;
  tcpListenAddr?: string;
  udpListenAddr?: string;
@@ -51,7 +73,9 @@ interface Node {
 interface NodeForm {
  id: number | null;
  name: string;
-  serverIp: string;
+  serverHost: string;
+  serverIpV4: string;
+  serverIpV6: string;
  port: string;
  tcpListenAddr: string;
  udpListenAddr: string;
@@ -61,9 +85,42 @@ interface NodeForm {
  socks: number; // 0 关 1 开
 }

+const SortableItem = ({
+  id,
+  children,
+}: {
+  id: number;
+  children: (listeners: any) => any;
+}) => {
+  const {
+    attributes,
+    listeners,
+    setNodeRef,
+    transform,
+    transition,
+    isDragging,
+  } = useSortable({ id });
+
+  const style = {
+    transform: transform ? CSS.Transform.toString(transform) : undefined,
+    transition: isDragging ? undefined : transition || undefined,
+    opacity: isDragging ? 0.5 : 1,
+    willChange: 'transform',
+  };
+
+  return (
+    <div ref={setNodeRef} style={style} {...attributes}>
+      {children(listeners)}
+    </div>
+  );
+};
+
 export default function NodePage() {
  const [nodeList, setNodeList] = useState<Node[]>([]);
+  const [nodeOrder, setNodeOrder] = useState<number[]>([]);
  const [loading, setLoading] = useState(false);
+  const [wsConnected, setWsConnected] = useState(false);
+  const [wsConnecting, setWsConnecting] = useState(false);
  const [dialogVisible, setDialogVisible] = useState(false);
  const [dialogTitle, setDialogTitle] = useState('');
  const [isEdit, setIsEdit] = useState(false);
@@ -76,7 +133,9 @@ export default function NodePage() {
  const [form, setForm] = useState<NodeForm>({
    id: null,
    name: '',
-    serverIp: '',
+    serverHost: '',
+    serverIpV4: '',
+    serverIpV6: '',
    port: '1000-65535',
    tcpListenAddr: '[::]',
    udpListenAddr: '[::]',
@@ -96,6 +155,31 @@ export default function NodePage() {
  const reconnectTimerRef = useRef<NodeJS.Timeout | null>(null);
  const reconnectAttemptsRef = useRef(0);
  const maxReconnectAttempts = 5;
+  const offlineTimersRef = useRef<Map<number, ReturnType<typeof setTimeout>>>(new Map());
+  const offlineDelayMs = 3000;
+
+  const clearOfflineTimer = (nodeId: number) => {
+    const timer = offlineTimersRef.current.get(nodeId);
+    if (timer) {
+      clearTimeout(timer);
+      offlineTimersRef.current.delete(nodeId);
+    }
+  };
+
+  const scheduleNodeOffline = (nodeId: number) => {
+    if (offlineTimersRef.current.has(nodeId)) return;
+    const timer = setTimeout(() => {
+      offlineTimersRef.current.delete(nodeId);
+      setNodeList((prev) =>
+        prev.map((node) => {
+          if (node.id !== nodeId) return node;
+          if (node.connectionStatus === 'offline' && node.systemInfo === null) return node;
+          return { ...node, connectionStatus: 'offline', systemInfo: null };
+        })
+      );
+    }, offlineDelayMs);
+    offlineTimersRef.current.set(nodeId, timer);
+  };

  useEffect(() => {
    loadNodes();
@@ -112,12 +196,49 @@ export default function NodePage() {
    try {
      const res = await getNodeList();
      if (res.code === 0) {
-        setNodeList(res.data.map((node: any) => ({
+        const nodesData: Node[] = (res.data || []).map((node: any) => ({
          ...node,
+          inx: node.inx ?? 0,
          connectionStatus: node.status === 1 ? 'online' : 'offline',
          systemInfo: null,
-          copyLoading: false
-        })));
+          copyLoading: false,
+        }));
+
+        setNodeList(nodesData);
+
+        // 优先使用数据库中的 inx 字段进行排序，否则回退到本地排序
+        const hasDbOrdering = nodesData.some((n) => n.inx !== undefined && n.inx !== 0);
+        if (hasDbOrdering) {
+          const dbOrder = [...nodesData]
+            .sort((a, b) => (a.inx ?? 0) - (b.inx ?? 0))
+            .map((n) => n.id);
+          setNodeOrder(dbOrder);
+        } else {
+          try {
+            const stored = localStorage.getItem('node-order');
+            if (stored) {
+              const parsed = JSON.parse(stored);
+              if (Array.isArray(parsed)) {
+                const existingIds = new Set(nodesData.map((n) => n.id));
+                const validOrder = parsed
+                  .map((id: any) => Number(id))
+                  .filter((id: number) => existingIds.has(id));
+
+                if (validOrder.length > 0) {
+                  setNodeOrder(validOrder);
+                } else {
+                  setNodeOrder(nodesData.map((n) => n.id));
+                }
+              } else {
+                setNodeOrder(nodesData.map((n) => n.id));
+              }
+            } else {
+              setNodeOrder(nodesData.map((n) => n.id));
+            }
+          } catch {
+            setNodeOrder(nodesData.map((n) => n.id));
+          }
+        }
      } else {
        toast.error(res.msg || '加载节点列表失败');
      }
@@ -143,12 +264,15 @@ export default function NodePage() {
    // 构建WebSocket URL，使用axios的baseURL
    const baseUrl = axios.defaults.baseURL || (import.meta.env.VITE_API_BASE ? `${import.meta.env.VITE_API_BASE}/api/v1/` : '/api/v1/');
    const wsUrl = baseUrl.replace(/^http/, 'ws').replace(/\/api\/v1\/$/, '') + `/system-info?type=0&secret=${localStorage.getItem('token')}`;
-    
+
    try {
+      setWsConnecting(true);
      websocketRef.current = new WebSocket(wsUrl);
      
      websocketRef.current.onopen = () => {
        reconnectAttemptsRef.current = 0;
+        setWsConnected(true);
+        setWsConnecting(false);
      };
      
      websocketRef.current.onmessage = (event) => {
@@ -166,9 +290,13 @@ export default function NodePage() {
      
      websocketRef.current.onclose = () => {
        websocketRef.current = null;
+        setWsConnected(false);
+        setWsConnecting(false);
        attemptReconnect();
      };
    } catch (error) {
+      setWsConnected(false);
+      setWsConnecting(false);
      attemptReconnect();
    }
  };
@@ -176,21 +304,27 @@ export default function NodePage() {
  // 处理WebSocket消息
  const handleWebSocketMessage = (data: any) => {
    const { id, type, data: messageData } = data;
+    const nodeId = Number(id);
+    if (Number.isNaN(nodeId)) return;
    
    if (type === 'status') {
-      setNodeList(prev => prev.map(node => {
-        if (node.id == id) {
-          return {
-            ...node,
-            connectionStatus: messageData === 1 ? 'online' : 'offline',
-            systemInfo: messageData === 0 ? null : node.systemInfo
-          };
-        }
-        return node;
-      }));
+      if (messageData === 1) {
+        clearOfflineTimer(nodeId);
+        setNodeList((prev) =>
+          prev.map((node) => {
+            if (node.id !== nodeId) return node;
+            if (node.connectionStatus === 'online') return node;
+            return { ...node, connectionStatus: 'online' };
+          })
+        );
+      } else {
+        // 离线事件做延迟处理，避免短抖动导致频繁闪烁
+        scheduleNodeOffline(nodeId);
+      }
    } else if (type === 'info') {
+      clearOfflineTimer(nodeId);
      setNodeList(prev => prev.map(node => {
-        if (node.id == id) {
+        if (node.id === nodeId) {
          try {
            let systemInfo;
            if (typeof messageData === 'string') {
@@ -253,10 +387,12 @@ export default function NodePage() {

  // 尝试重新连接
  const attemptReconnect = () => {
+    if (reconnectTimerRef.current) return;
    if (reconnectAttemptsRef.current < maxReconnectAttempts) {
      reconnectAttemptsRef.current++;
      
      reconnectTimerRef.current = setTimeout(() => {
+        reconnectTimerRef.current = null;
        initWebSocket();
      }, 3000 * reconnectAttemptsRef.current);
    }
@@ -268,8 +404,13 @@ export default function NodePage() {
      clearTimeout(reconnectTimerRef.current);
      reconnectTimerRef.current = null;
    }
+
+    offlineTimersRef.current.forEach((timer) => clearTimeout(timer));
+    offlineTimersRef.current.clear();
    
    reconnectAttemptsRef.current = 0;
+    setWsConnected(false);
+    setWsConnecting(false);
    
    if (websocketRef.current) {
      websocketRef.current.onopen = null;
@@ -284,12 +425,6 @@ export default function NodePage() {
      
      websocketRef.current = null;
    }
-    
-    setNodeList(prev => prev.map(node => ({
-      ...node,
-      connectionStatus: 'offline',
-      systemInfo: null
-    })));
  };


@@ -341,29 +476,20 @@ export default function NodePage() {
    return "danger";
  };

-  // 验证IP地址格式
-  const validateIp = (ip: string): boolean => {
-    if (!ip || !ip.trim()) return false;
-    
-    const trimmedIp = ip.trim();
-    
-    // IPv4格式验证
-    const ipv4Regex = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
-    
-    // IPv6格式验证
-    const ipv6Regex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/;
-    
-    if (ipv4Regex.test(trimmedIp) || ipv6Regex.test(trimmedIp) || trimmedIp === 'localhost') {
-      return true;
-    }
-    
-    // 验证域名格式
-    if (/^\d+$/.test(trimmedIp)) return false;
-    
-    const domainRegex = /^[a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?)+$/;
-    const singleLabelDomain = /^[a-zA-Z][a-zA-Z0-9\-]{0,62}$/;
-    
-    return domainRegex.test(trimmedIp) || singleLabelDomain.test(trimmedIp);
+  // IPv4/IPv6 格式验证（仅用于判定地址族）
+  const ipv4Regex = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+  const ipv6Regex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/;
+
+  const validateIpv4Literal = (ip: string): boolean => ipv4Regex.test(ip.trim());
+  const validateIpv6Literal = (ip: string): boolean => ipv6Regex.test(ip.trim());
+
+  // Hostname/domain validation (no scheme/port)
+  const hostnameRegex = /^(?=.{1,253}$)(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)(?:\.(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?))*$/;
+  const validateHostname = (host: string): boolean => {
+    const v = host.trim();
+    if (!v) return false;
+    if (v === 'localhost') return true;
+    return hostnameRegex.test(v);
  };

  // 验证端口格式：支持 80,443,100-600
@@ -429,10 +555,25 @@ export default function NodePage() {
      newErrors.name = '节点名称长度不能超过50位';
    }
    
-    if (!form.serverIp.trim()) {
-      newErrors.serverIp = '请输入服务器IP地址';
-    } else if (!validateIp(form.serverIp.trim())) {
-      newErrors.serverIp = '请输入有效的IPv4、IPv6地址或域名';
+    const v4 = form.serverIpV4.trim();
+    const v6 = form.serverIpV6.trim();
+    const host = form.serverHost.trim();
+
+    if (!v4 && !v6 && !host) {
+      const msg = '请至少填写一个 IPv4/IPv6 地址或域名';
+      newErrors.serverIpV4 = msg;
+      newErrors.serverIpV6 = msg;
+      newErrors.serverHost = msg;
+    } else {
+      if (v4 && !validateIpv4Literal(v4)) {
+        newErrors.serverIpV4 = '请输入有效的IPv4地址';
+      }
+      if (v6 && !validateIpv6Literal(v6)) {
+        newErrors.serverIpV6 = '请输入有效的IPv6地址';
+      }
+      if (host && !validateHostname(host)) {
+        newErrors.serverHost = '请输入有效的域名/主机名';
+      }
    }
    
    const portValidation = validatePort(form.port);
@@ -458,10 +599,18 @@ export default function NodePage() {
  const handleEdit = (node: Node) => {
    setDialogTitle('编辑节点');
    setIsEdit(true);
+
+    const legacy = (node.serverIp || '').trim();
+    const normalizedV4 = node.serverIpV4?.trim() || (validateIpv4Literal(legacy) ? legacy : '');
+    const normalizedV6 = node.serverIpV6?.trim() || (validateIpv6Literal(legacy) ? legacy : '');
+    const normalizedHost = (!normalizedV4 && !normalizedV6 && legacy) ? legacy : '';
+
    setForm({
      id: node.id,
      name: node.name,
-      serverIp: node.serverIp || '',
+      serverHost: normalizedHost,
+      serverIpV4: normalizedV4,
+      serverIpV6: normalizedV6,
      port: node.port || '1000-65535',
      tcpListenAddr: node.tcpListenAddr || '[::]',
      udpListenAddr: node.udpListenAddr || '[::]',
@@ -552,8 +701,10 @@ export default function NodePage() {
    
    try {
      const apiCall = isEdit ? updateNode : createNode;
-      const data = { 
-        ...form
+      const { serverHost: _serverHost, ...rest } = form;
+      const data = {
+        ...rest,
+        serverIp: form.serverIpV4?.trim() || form.serverIpV6?.trim() || form.serverHost?.trim() || ''
      };
      
      const res = await apiCall(data);
@@ -562,20 +713,22 @@ export default function NodePage() {
        setDialogVisible(false);
        
        if (isEdit) {
-          setNodeList(prev => prev.map(n => 
-            n.id === form.id ? {
-              ...n,
-              name: form.name,
-              serverIp: form.serverIp,
-              port: form.port,
-              tcpListenAddr: form.tcpListenAddr,
-              udpListenAddr: form.udpListenAddr,
-              interfaceName: form.interfaceName,
-              http: form.http,
-              tls: form.tls,
-              socks: form.socks
-            } : n
-          ));
+            setNodeList(prev => prev.map(n => 
+              n.id === form.id ? {
+                ...n,
+                name: form.name,
+                serverIp: form.serverIpV4?.trim() || form.serverIpV6?.trim() || form.serverHost?.trim() || '',
+                serverIpV4: form.serverIpV4,
+                serverIpV6: form.serverIpV6,
+                port: form.port,
+                tcpListenAddr: form.tcpListenAddr,
+                udpListenAddr: form.udpListenAddr,
+                interfaceName: form.interfaceName,
+                http: form.http,
+                tls: form.tls,
+                socks: form.socks
+              } : n
+            ));
        } else {
          loadNodes();
        }
@@ -594,7 +747,9 @@ export default function NodePage() {
    setForm({
      id: null,
      name: '',
-      serverIp: '',
+      serverHost: '',
+      serverIpV4: '',
+      serverIpV6: '',
      port: '1000-65535',
      tcpListenAddr: '[::]',
      udpListenAddr: '[::]',
@@ -606,6 +761,103 @@ export default function NodePage() {
    setErrors({});
  };

+  // 处理拖拽结束
+  const handleDragEnd = async (event: DragEndEvent) => {
+    const { active, over } = event;
+
+    if (!active || !over || active.id === over.id) return;
+    if (!nodeOrder || nodeOrder.length === 0) return;
+
+    const activeId = Number(active.id);
+    const overId = Number(over.id);
+    if (isNaN(activeId) || isNaN(overId)) return;
+
+    const oldIndex = nodeOrder.indexOf(activeId);
+    const newIndex = nodeOrder.indexOf(overId);
+    if (oldIndex === -1 || newIndex === -1 || oldIndex === newIndex) return;
+
+    const newOrder = arrayMove(nodeOrder, oldIndex, newIndex);
+    setNodeOrder(newOrder);
+
+    // 保存到 localStorage
+    try {
+      localStorage.setItem('node-order', JSON.stringify(newOrder));
+    } catch (error) {
+      console.warn('无法保存节点排序到localStorage:', error);
+    }
+
+    // 持久化到数据库
+    try {
+      const nodesToUpdate = newOrder.map((id, index) => ({ id, inx: index }));
+      const response = await updateNodeOrder({ nodes: nodesToUpdate });
+      if (response.code === 0) {
+        setNodeList((prev) =>
+          prev.map((node) => {
+            const updated = nodesToUpdate.find((n) => n.id === node.id);
+            return updated ? { ...node, inx: updated.inx } : node;
+          })
+        );
+      } else {
+        toast.error('保存排序失败：' + (response.msg || '未知错误'));
+      }
+    } catch (error) {
+      console.error('保存节点排序到数据库失败:', error);
+      toast.error('保存排序失败，请重试');
+    }
+  };
+
+  // 传感器配置
+  const sensors = useSensors(
+    useSensor(MouseSensor, {
+      activationConstraint: {
+        distance: 8,
+      },
+    }),
+    useSensor(TouchSensor, {
+      activationConstraint: {
+        delay: 250,
+        tolerance: 8,
+      },
+    }),
+    useSensor(KeyboardSensor, {
+      coordinateGetter: sortableKeyboardCoordinates,
+    })
+  );
+
+  // 根据排序顺序获取节点列表
+  const sortedNodes = useMemo((): Node[] => {
+    if (!nodeList || nodeList.length === 0) return [];
+
+    const sortedByDb = [...nodeList].sort((a, b) => {
+      const aInx = a.inx ?? 0;
+      const bInx = b.inx ?? 0;
+      return aInx - bInx;
+    });
+
+    // 如果数据库中没有排序信息，则使用本地存储的顺序
+    if (nodeOrder && nodeOrder.length > 0 && sortedByDb.every((n) => n.inx === undefined || n.inx === 0)) {
+      const nodeMap = new Map(nodeList.map((n) => [n.id, n] as const));
+      const localSorted: Node[] = [];
+
+      nodeOrder.forEach((id) => {
+        const node = nodeMap.get(id);
+        if (node) localSorted.push(node);
+      });
+
+      nodeList.forEach((node) => {
+        if (!nodeOrder.includes(node.id)) {
+          localSorted.push(node);
+        }
+      });
+
+      return localSorted;
+    }
+
+    return sortedByDb;
+  }, [nodeList, nodeOrder]);
+
+  const sortableNodeIds = useMemo(() => sortedNodes.map((n) => n.id), [sortedNodes]);
+
  return (
    
      <div className="px-3 lg:px-6 py-8">
@@ -626,6 +878,15 @@ export default function NodePage() {
     
        </div>

+        {!wsConnected && (
+          <Alert
+            color="warning"
+            variant="flat"
+            description={wsConnecting ? '监控连接中...' : '监控连接已断开，正在重连...'}
+            className="mb-4"
+          />
+        )}
+
        {/* 节点列表 */}
        {loading ? (
          <div className="flex items-center justify-center h-64">
@@ -651,18 +912,35 @@ export default function NodePage() {
            </CardBody>
          </Card>
        ) : (
-          <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 2xl:grid-cols-5 gap-4">
-            {nodeList.map((node) => (
-              <Card 
-                key={node.id} 
-                className="shadow-sm border border-divider hover:shadow-md transition-shadow duration-200"
-              >
+          <DndContext sensors={sensors} onDragEnd={handleDragEnd}>
+            <SortableContext
+              items={sortableNodeIds}
+              strategy={rectSortingStrategy}
+            >
+              <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 2xl:grid-cols-5 gap-4">
+                {sortedNodes.map((node) => (
+                  <SortableItem key={node.id} id={node.id}>
+                    {(listeners) => (
+                      <Card 
+                        key={node.id} 
+                        className="group shadow-sm border border-divider hover:shadow-md transition-shadow duration-200"
+                      >
                <CardHeader className="pb-2">
                  <div className="flex justify-between items-start w-full">
                    <div className="flex-1 min-w-0">
                      <h3 className="font-semibold text-foreground truncate text-sm">{node.name}</h3>
                    </div>
                    <div className="flex items-center gap-1.5 ml-2">
+                      <div
+                        className="cursor-grab active:cursor-grabbing p-2 text-default-400 hover:text-default-600 transition-colors touch-manipulation opacity-100 sm:opacity-0 sm:group-hover:opacity-100"
+                        {...listeners}
+                        title="拖拽排序"
+                        style={{ touchAction: 'none' }}
+                      >
+                        <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 20 20">
+                          <path d="M7 2a2 2 0 1 1 .001 4.001A2 2 0 0 1 7 2zm0 6a2 2 0 1 1 .001 4.001A2 2 0 0 1 7 8zm0 6a2 2 0 1 1 .001 4.001A2 2 0 0 1 7 14zm6-8a2 2 0 1 1-.001-4.001A2 2 0 0 1 13 6zm0 2a2 2 0 1 1 .001 4.001A2 2 0 0 1 13 8zm0 6a2 2 0 1 1 .001 4.001A2 2 0 0 1 13 14z" />
+                        </svg>
+                      </div>
                      <Chip 
                        color={node.connectionStatus === 'online' ? 'success' : 'danger'} 
                        variant="flat" 
@@ -681,9 +959,24 @@ export default function NodePage() {
                    <div className="flex justify-between items-center text-sm min-w-0">
                      <span className="text-default-600 flex-shrink-0">IP</span>
                      <div className="text-right text-xs min-w-0 flex-1 ml-2">
-                      <span className="font-mono truncate block" title={node.serverIp.trim()}>
-                              {node.serverIp.trim()}
-                      </span>
+                      {(node.serverIpV4?.trim() || node.serverIpV6?.trim()) ? (
+                        <div className="space-y-0.5">
+                          {node.serverIpV4?.trim() && (
+                            <span className="font-mono truncate block" title={node.serverIpV4.trim()}>
+                              {node.serverIpV4.trim()}
+                            </span>
+                          )}
+                          {node.serverIpV6?.trim() && (
+                            <span className="font-mono truncate block" title={node.serverIpV6.trim()}>
+                              {node.serverIpV6.trim()}
+                            </span>
+                          )}
+                        </div>
+                      ) : (
+                        <span className="font-mono truncate block" title={node.serverIp.trim()}>
+                          {node.serverIp.trim()}
+                        </span>
+                      )}
                      </div>
                    </div>
                    <div className="flex justify-between text-sm">
@@ -825,9 +1118,13 @@ export default function NodePage() {
                  </div>
                </CardBody>
              </Card>
-            ))}
-          </div>
-        )}
+            )}
+          </SortableItem>
+        ))}
+      </div>
+    </SortableContext>
+  </DndContext>
+)}

        {/* 新增/编辑节点对话框 */}
        <Modal 
@@ -853,15 +1150,40 @@ export default function NodePage() {
                />

                <Input
-                  label="服务器IP"
-                  placeholder="请输入服务器IP地址，如: 192.168.1.100 或 example.com"
-                  value={form.serverIp}
-                  onChange={(e) => setForm(prev => ({ ...prev, serverIp: e.target.value }))}
-                  isInvalid={!!errors.serverIp}
-                  errorMessage={errors.serverIp}
+                  label="服务器域名/主机名"
+                  placeholder="例如: node.example.com"
+                  value={form.serverHost}
+                  onChange={(e) => setForm(prev => ({ ...prev, serverHost: e.target.value }))}
+                  isInvalid={!!errors.serverHost}
+                  errorMessage={errors.serverHost}
                  variant="bordered"
+                  description="可选：不带协议、不带端口。至少填写一个 IPv4/IPv6/域名"
                />

+                <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+                  <Input
+                    label="服务器IPv4"
+                    placeholder="例如: 203.0.113.10"
+                    value={form.serverIpV4}
+                    onChange={(e) => setForm(prev => ({ ...prev, serverIpV4: e.target.value }))}
+                    isInvalid={!!errors.serverIpV4}
+                    errorMessage={errors.serverIpV4}
+                    variant="bordered"
+                    description="双栈节点组隧道时优先使用 IPv4"
+                  />
+
+                  <Input
+                    label="服务器IPv6"
+                    placeholder="例如: 2001:db8::10"
+                    value={form.serverIpV6}
+                    onChange={(e) => setForm(prev => ({ ...prev, serverIpV6: e.target.value }))}
+                    isInvalid={!!errors.serverIpV6}
+                    errorMessage={errors.serverIpV6}
+                    variant="bordered"
+                    description="至少填写一个 IPv4/IPv6/域名"
+                  />
+                </div>
+
                <Input
                  label="可用端口"
                  placeholder="例如: 80,443,1000-65535"
@@ -1123,4 +1445,4 @@ export default function NodePage() {
      </div>
    
  );
-} 
+} 
@@ -1,4 +1,4 @@
-import { useState, useEffect } from "react";
+import { useState, useEffect, useMemo } from "react";
 import { Card, CardBody, CardHeader } from "@heroui/card";
 import { Button } from "@heroui/button";
 import { Input, Textarea } from "@heroui/input";
@@ -10,6 +10,24 @@ import { Divider } from "@heroui/divider";
 import { Alert } from "@heroui/alert";
 import toast from 'react-hot-toast';

+import {
+  DndContext,
+  KeyboardSensor,
+  MouseSensor,
+  TouchSensor,
+  type DragEndEvent,
+  useSensor,
+  useSensors,
+} from '@dnd-kit/core';
+import {
+  SortableContext,
+  arrayMove,
+  rectSortingStrategy,
+  sortableKeyboardCoordinates,
+  useSortable,
+} from '@dnd-kit/sortable';
+import { CSS } from '@dnd-kit/utilities';
+

 import { 
  createTunnel, 
@@ -17,7 +35,8 @@ import {
  updateTunnel, 
  deleteTunnel,
  getNodeList,
-  diagnoseTunnel
+  diagnoseTunnel,
+  updateTunnelOrder
 } from "@/api";

 interface ChainTunnel {
@@ -30,6 +49,7 @@ interface ChainTunnel {

 interface Tunnel {
  id: number;
+  inx?: number;
  name: string;
  type: number; // 1: 端口转发, 2: 隧道转发
  inNodeId: ChainTunnel[]; // 入口节点列表
@@ -87,6 +107,7 @@ interface DiagnosisResult {
 export default function TunnelPage() {
  const [loading, setLoading] = useState(true);
  const [tunnels, setTunnels] = useState<Tunnel[]>([]);
+  const [tunnelOrder, setTunnelOrder] = useState<number[]>([]);
  const [nodes, setNodes] = useState<Node[]>([]);
  
  // 模态框状态
@@ -131,7 +152,45 @@ export default function TunnelPage() {
      ]);
      
      if (tunnelsRes.code === 0) {
-        setTunnels(tunnelsRes.data || []);
+        const tunnelsData: Tunnel[] = (tunnelsRes.data || []).map((t: any) => ({
+          ...t,
+          inx: t.inx ?? 0,
+        }));
+        setTunnels(tunnelsData);
+
+        // 优先使用数据库中的 inx 字段进行排序，否则回退到本地排序
+        const hasDbOrdering = tunnelsData.some((t) => t.inx !== undefined && t.inx !== 0);
+        if (hasDbOrdering) {
+          const dbOrder = [...tunnelsData]
+            .sort((a, b) => (a.inx ?? 0) - (b.inx ?? 0))
+            .map((t) => t.id);
+          setTunnelOrder(dbOrder);
+        } else {
+          try {
+            const stored = localStorage.getItem('tunnel-order');
+            if (stored) {
+              const parsed = JSON.parse(stored);
+              if (Array.isArray(parsed)) {
+                const existingIds = new Set(tunnelsData.map((t) => t.id));
+                const validOrder = parsed
+                  .map((id: any) => Number(id))
+                  .filter((id: number) => existingIds.has(id));
+
+                if (validOrder.length > 0) {
+                  setTunnelOrder(validOrder);
+                } else {
+                  setTunnelOrder(tunnelsData.map((t) => t.id));
+                }
+              } else {
+                setTunnelOrder(tunnelsData.map((t) => t.id));
+              }
+            } else {
+              setTunnelOrder(tunnelsData.map((t) => t.id));
+            }
+          } catch {
+            setTunnelOrder(tunnelsData.map((t) => t.id));
+          }
+        }
      } else {
        toast.error(tunnelsRes.msg || '获取隧道列表失败');
      }
@@ -481,6 +540,133 @@ export default function TunnelPage() {
    return { text: '😵 很差', color: 'danger' };
  };

+  // 处理拖拽结束
+  const handleDragEnd = async (event: DragEndEvent) => {
+    const { active, over } = event;
+
+    if (!active || !over || active.id === over.id) return;
+    if (!tunnelOrder || tunnelOrder.length === 0) return;
+
+    const activeId = Number(active.id);
+    const overId = Number(over.id);
+    if (isNaN(activeId) || isNaN(overId)) return;
+
+    const oldIndex = tunnelOrder.indexOf(activeId);
+    const newIndex = tunnelOrder.indexOf(overId);
+    if (oldIndex === -1 || newIndex === -1 || oldIndex === newIndex) return;
+
+    const newOrder = arrayMove(tunnelOrder, oldIndex, newIndex);
+    setTunnelOrder(newOrder);
+
+    // 保存到 localStorage
+    try {
+      localStorage.setItem('tunnel-order', JSON.stringify(newOrder));
+    } catch (error) {
+      console.warn('无法保存隧道排序到localStorage:', error);
+    }
+
+    // 持久化到数据库
+    try {
+      const tunnelsToUpdate = newOrder.map((id, index) => ({ id, inx: index }));
+      const response = await updateTunnelOrder({ tunnels: tunnelsToUpdate });
+      if (response.code === 0) {
+        setTunnels((prev) =>
+          prev.map((tunnel) => {
+            const updated = tunnelsToUpdate.find((t) => t.id === tunnel.id);
+            return updated ? { ...tunnel, inx: updated.inx } : tunnel;
+          })
+        );
+      } else {
+        toast.error('保存排序失败：' + (response.msg || '未知错误'));
+      }
+    } catch (error) {
+      console.error('保存隧道排序到数据库失败:', error);
+      toast.error('保存排序失败，请重试');
+    }
+  };
+
+  // 传感器配置
+  const sensors = useSensors(
+    useSensor(MouseSensor, {
+      activationConstraint: {
+        distance: 8,
+      },
+    }),
+    useSensor(TouchSensor, {
+      activationConstraint: {
+        delay: 250,
+        tolerance: 8,
+      },
+    }),
+    useSensor(KeyboardSensor, {
+      coordinateGetter: sortableKeyboardCoordinates,
+    })
+  );
+
+  // 根据排序顺序获取隧道列表
+  const sortedTunnels = useMemo((): Tunnel[] => {
+    if (!tunnels || tunnels.length === 0) return [];
+
+    const sortedByDb = [...tunnels].sort((a, b) => {
+      const aInx = a.inx ?? 0;
+      const bInx = b.inx ?? 0;
+      return aInx - bInx;
+    });
+
+    // 如果数据库中没有排序信息，则使用本地存储的顺序
+    if (tunnelOrder && tunnelOrder.length > 0 && sortedByDb.every((t) => t.inx === undefined || t.inx === 0)) {
+      const tunnelMap = new Map(tunnels.map((t) => [t.id, t] as const));
+      const localSorted: Tunnel[] = [];
+
+      tunnelOrder.forEach((id) => {
+        const tunnel = tunnelMap.get(id);
+        if (tunnel) localSorted.push(tunnel);
+      });
+
+      tunnels.forEach((tunnel) => {
+        if (!tunnelOrder.includes(tunnel.id)) {
+          localSorted.push(tunnel);
+        }
+      });
+
+      return localSorted;
+    }
+
+    return sortedByDb;
+  }, [tunnels, tunnelOrder]);
+
+  const sortableTunnelIds = useMemo(() => sortedTunnels.map((t) => t.id), [sortedTunnels]);
+
+  const SortableItem = ({
+    id,
+    children,
+  }: {
+    id: number;
+    children: (listeners: any) => any;
+  }) => {
+    const {
+      attributes,
+      listeners,
+      setNodeRef,
+      transform,
+      transition,
+      isDragging,
+    } = useSortable({ id });
+
+    const style = {
+      transform: transform ? CSS.Transform.toString(transform) : undefined,
+      transition: isDragging ? undefined : transition || undefined,
+      opacity: isDragging ? 0.5 : 1,
+      willChange: 'transform',
+    };
+
+    return (
+      <div ref={setNodeRef} style={style} {...attributes}>
+        {children(listeners)}
+      </div>
+    );
+  };
+
  if (loading) {
    return (
      
@@ -516,17 +702,24 @@ export default function TunnelPage() {

        {/* 隧道卡片网格 */}
        {tunnels.length > 0 ? (
-          <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 2xl:grid-cols-5 gap-4">
-            {tunnels.map((tunnel) => {
+          <DndContext sensors={sensors} onDragEnd={handleDragEnd}>
+            <SortableContext
+              items={sortableTunnelIds}
+              strategy={rectSortingStrategy}
+            >
+              <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 2xl:grid-cols-5 gap-4">
+                {sortedTunnels.map((tunnel) => {
              const typeDisplay = getTypeDisplay(tunnel.type);
              
              return (
-                <Card key={tunnel.id} className="shadow-sm border border-divider hover:shadow-md transition-shadow duration-200">
-                  <CardHeader className="pb-2">
-                    <div className="flex justify-between items-start w-full">
-                      <div className="flex-1 min-w-0">
-                        <h3 className="font-semibold text-foreground truncate text-sm">{tunnel.name}</h3>
-                        <div className="flex items-center gap-1.5 mt-1">
+                <SortableItem key={tunnel.id} id={tunnel.id}>
+                  {(listeners) => (
+                    <Card key={tunnel.id} className="group shadow-sm border border-divider hover:shadow-md transition-shadow duration-200">
+                      <CardHeader className="pb-2">
+                        <div className="flex justify-between items-start w-full">
+                          <div className="flex-1 min-w-0">
+                            <h3 className="font-semibold text-foreground truncate text-sm">{tunnel.name}</h3>
+                            <div className="flex items-center gap-1.5 mt-1">
                          <Chip 
                            color={typeDisplay.color as any} 
                            variant="flat" 
@@ -535,13 +728,23 @@ export default function TunnelPage() {
                          >
                            {typeDisplay.text}
                          </Chip>
-                         
+                          
+                            </div>
+                          </div>
+                          <div
+                            className="cursor-grab active:cursor-grabbing p-2 text-default-400 hover:text-default-600 transition-colors touch-manipulation opacity-100 sm:opacity-0 sm:group-hover:opacity-100"
+                            {...listeners}
+                            title="拖拽排序"
+                            style={{ touchAction: 'none' }}
+                          >
+                            <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 20 20">
+                              <path d="M7 2a2 2 0 1 1 .001 4.001A2 2 0 0 1 7 2zm0 6a2 2 0 1 1 .001 4.001A2 2 0 0 1 7 8zm0 6a2 2 0 1 1 .001 4.001A2 2 0 0 1 7 14zm6-8a2 2 0 1 1-.001-4.001A2 2 0 0 1 13 6zm0 2a2 2 0 1 1 .001 4.001A2 2 0 0 1 13 8zm0 6a2 2 0 1 1 .001 4.001A2 2 0 0 1 13 14z" />
+                            </svg>
+                          </div>
                        </div>
-                      </div>
-                    </div>
-                  </CardHeader>
+                      </CardHeader>
                  
-                  <CardBody className="pt-0 pb-3">
+                      <CardBody className="pt-0 pb-3">
                    <div className="space-y-3">
                      {/* 拓扑结构 */}
                      <div className="pt-2 border-t border-divider">
@@ -654,10 +857,14 @@ export default function TunnelPage() {
                    </div>
                  </CardBody>
                </Card>
-              );
-            })}
-          </div>
-        ) : (
+              )}
+            </SortableItem>
+          );
+        })}
+      </div>
+    </SortableContext>
+  </DndContext>
+) : (
          /* 空状态 */
          <Card className="shadow-sm border border-gray-200 dark:border-gray-700">
            <CardBody className="text-center py-16">
@@ -1629,4 +1836,4 @@ export default function TunnelPage() {
      </div>
    
  );
-} 
+} 
@@ -30,7 +30,7 @@ import {
  User, 
  UserForm, 
  UserTunnel, 
-  UserTunnelForm, 
+  TunnelAssignItem,
  Tunnel, 
  SpeedLimit, 
  Pagination as PaginationType 
@@ -41,7 +41,7 @@ import {
  updateUser,
  deleteUser,
  getTunnelList,
-  assignUserTunnel,
+  batchAssignUserTunnel,
  getUserTunnelList,
  removeUserTunnel,
  updateUserTunnel,
@@ -134,15 +134,8 @@ export default function UserPage() {
  const [tunnelListLoading, setTunnelListLoading] = useState(false);  
  
  // 分配新隧道权限相关状态
-  const [tunnelForm, setTunnelForm] = useState<UserTunnelForm>({
-    tunnelId: null,
-    flow: 100,
-    num: 10,
-    expTime: null,
-    flowResetTime: 0,
-    speedId: null
-  });
  const [assignLoading, setAssignLoading] = useState(false);
+  const [batchTunnelSelections, setBatchTunnelSelections] = useState<Map<number, number | null>>(new Map());

  // 编辑隧道权限相关状态
  const { isOpen: isEditTunnelModalOpen, onOpen: onEditTunnelModalOpen, onClose: onEditTunnelModalClose } = useDisclosure();
@@ -334,46 +327,31 @@ export default function UserPage() {
  // 隧道权限管理操作
  const handleManageTunnels = (user: User) => {
    setCurrentUser(user);
-    setTunnelForm({
-      tunnelId: null,
-      flow: 100,
-      num: 10,
-      expTime: null,
-      flowResetTime: 0,
-      speedId: null
-    });
+    setBatchTunnelSelections(new Map());
    onTunnelModalOpen();
    loadUserTunnels(user.id);
  };

-  const handleAssignTunnel = async () => {
-    if (!tunnelForm.tunnelId || !tunnelForm.expTime || !currentUser) {
-      toast.error('请填写完整信息');
+  const handleBatchAssignTunnel = async () => {
+    if (batchTunnelSelections.size === 0 || !currentUser) {
+      toast.error('请选择至少一个隧道');
      return;
    }

    setAssignLoading(true);
    try {
-      const response = await assignUserTunnel({
+      const tunnelsToAssign: TunnelAssignItem[] = Array.from(batchTunnelSelections.entries()).map(
+        ([tunnelId, speedId]) => ({ tunnelId, speedId })
+      );
+      
+      const response = await batchAssignUserTunnel({
        userId: currentUser.id,
-        tunnelId: tunnelForm.tunnelId,
-        flow: tunnelForm.flow,
-        num: tunnelForm.num,
-        expTime: tunnelForm.expTime.getTime(),
-        flowResetTime: tunnelForm.flowResetTime,
-        speedId: tunnelForm.speedId
+        tunnels: tunnelsToAssign
      });

      if (response.code === 0) {
-        toast.success('分配成功');
-        setTunnelForm({
-          tunnelId: null,
-          flow: 100,
-          num: 10,
-          expTime: null,
-          flowResetTime: 0,
-          speedId: null
-        });
+        toast.success(response.msg || '分配成功');
+        setBatchTunnelSelections(new Map());
        loadUserTunnels(currentUser.id);
      } else {
        toast.error(response.msg || '分配失败');
@@ -513,19 +491,38 @@ export default function UserPage() {
    }
  };

-  // 过滤数据
-  const availableTunnels = tunnels.filter(
-    tunnel => !userTunnels.some(ut => ut.tunnelId === tunnel.id)
-  );
-
-  const availableSpeedLimits = speedLimits.filter(
-    speedLimit => speedLimit.tunnelId === tunnelForm.tunnelId
-  );
-
  const editAvailableSpeedLimits = speedLimits.filter(
    speedLimit => speedLimit.tunnelId === editTunnelForm?.tunnelId
  );

+  const getSpeedLimitsForTunnel = (tunnelId: number) => {
+    return speedLimits.filter(sl => sl.tunnelId === tunnelId);
+  };
+
+  const toggleTunnelSelection = (tunnelId: number) => {
+    setBatchTunnelSelections(prev => {
+      const newMap = new Map(prev);
+      if (newMap.has(tunnelId)) {
+        newMap.delete(tunnelId);
+      } else {
+        newMap.set(tunnelId, null);
+      }
+      return newMap;
+    });
+  };
+
+  const updateTunnelSpeedLimit = (tunnelId: number, speedId: number | null) => {
+    setBatchTunnelSelections(prev => {
+      const newMap = new Map(prev);
+      newMap.set(tunnelId, speedId);
+      return newMap;
+    });
+  };
+
+  const isTunnelAssigned = (tunnelId: number) => {
+    return userTunnels.some(ut => ut.tunnelId === tunnelId);
+  };
+
  return (
    
      <div className="px-3 lg:px-6 py-8">
@@ -878,107 +875,73 @@ export default function UserPage() {
              <div>
                <h3 className="text-lg font-semibold mb-4">分配新权限</h3>
                <div className="space-y-4">
-                  <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
-                    <Select
-                      label="选择隧道"
-                      selectedKeys={tunnelForm.tunnelId ? [tunnelForm.tunnelId.toString()] : []}
-                      onSelectionChange={(keys) => {
-                        const value = Array.from(keys)[0] as string;
-                        setTunnelForm(prev => ({ ...prev, tunnelId: Number(value) || null, speedId: null }));
-                      }}
-                    >
-                      {availableTunnels.map(tunnel => (
-                        <SelectItem key={tunnel.id.toString()} textValue={tunnel.name}>
-                          {tunnel.name}
-                        </SelectItem>
-                      ))}
-                    </Select>
-                    
-                    <Select
-                      label="限速规则"
-                      selectedKeys={tunnelForm.speedId ? [tunnelForm.speedId.toString()] : ["null"]}
-                      onSelectionChange={(keys) => {
-                        const value = Array.from(keys)[0] as string;
-                        setTunnelForm(prev => ({ ...prev, speedId: value === "null" ? null : Number(value) }));
-                      }}
-                      isDisabled={!tunnelForm.tunnelId}
-                    >
-                      {[
-                        <SelectItem key="null" textValue="不限速">不限速</SelectItem>,
-                        ...availableSpeedLimits.map(speedLimit => (
-                          <SelectItem key={speedLimit.id.toString()} textValue={speedLimit.name}>
-                            {speedLimit.name}
-                          </SelectItem>
-                        ))
-                      ]}
-                    </Select>
-                    
-                    <Input
-                      label="流量限制(GB)"
-                      type="number"
-                      value={tunnelForm.flow.toString()}
-                      onChange={(e) => {
-                        const value = Math.min(Math.max(Number(e.target.value) || 0, 1), 99999);
-                        setTunnelForm(prev => ({ ...prev, flow: value }));
-                      }}
-                      min="1"
-                      max="99999"
-                    />
-                    
-                    <Input
-                      label="转发数量"
-                      type="number"
-                      value={tunnelForm.num.toString()}
-                      onChange={(e) => {
-                        const value = Math.min(Math.max(Number(e.target.value) || 0, 1), 99999);
-                        setTunnelForm(prev => ({ ...prev, num: value }));
-                      }}
-                      min="1"
-                      max="99999"
-                    />
-                    
-                    <Select
-                      label="流量重置日期"
-                      selectedKeys={[tunnelForm.flowResetTime.toString()]}
-                      onSelectionChange={(keys) => {
-                        const value = Array.from(keys)[0] as string;
-                        setTunnelForm(prev => ({ ...prev, flowResetTime: Number(value) }));
-                      }}
-                    >
-                      <>
-                        <SelectItem key="0" textValue="不重置">
-                          不重置
-                        </SelectItem>
-                      {Array.from({ length: 31 }, (_, i) => i + 1).map(day => (
-                        <SelectItem key={day.toString()} textValue={`每月${day}号（0点重置）`}>
-                          每月{day}号（0点重置）
-                        </SelectItem>
-                      ))}
-                      </>
-                    </Select>
-                    
-                    <DatePicker
-                      label="到期时间"
-                      value={tunnelForm.expTime ? parseDate(tunnelForm.expTime.toISOString().split('T')[0]) as any : null}
-                      onChange={(date) => {
-                        if (date) {
-                          const jsDate = new Date(date.year, date.month - 1, date.day, 23, 59, 59);
-                          setTunnelForm(prev => ({ ...prev, expTime: jsDate }));
-                        } else {
-                          setTunnelForm(prev => ({ ...prev, expTime: null }));
-                        }
-                      }}
-                      showMonthAndYearPickers
-                      className="cursor-pointer"
-                    />
+                  <div className="text-sm text-gray-500 bg-gray-50 dark:bg-gray-800 p-3 rounded-lg">
+                    流量限制、转发数量、到期时间、流量重置时间将自动继承用户设置
+                  </div>
+                  
+                  <div className="border rounded-lg divide-y dark:divide-gray-700 max-h-64 overflow-y-auto">
+                    {tunnels.map(tunnel => {
+                      const isAssigned = isTunnelAssigned(tunnel.id);
+                      const isSelected = batchTunnelSelections.has(tunnel.id);
+                      const tunnelSpeedLimits = getSpeedLimitsForTunnel(tunnel.id);
+                      
+                      return (
+                        <div 
+                          key={tunnel.id} 
+                          className={`p-3 flex items-center justify-between gap-4 ${isAssigned ? 'bg-gray-100 dark:bg-gray-800' : ''}`}
+                        >
+                          <div className="flex items-center gap-3 flex-1">
+                            <input
+                              type="checkbox"
+                              checked={isSelected}
+                              disabled={isAssigned}
+                              onChange={() => toggleTunnelSelection(tunnel.id)}
+                              className="w-4 h-4 rounded border-gray-300 text-primary focus:ring-primary disabled:opacity-50"
+                            />
+                            <span className={isAssigned ? 'text-gray-400' : ''}>
+                              {tunnel.name}
+                            </span>
+                            {isAssigned && (
+                              <Chip size="sm" variant="flat" color="default">已分配</Chip>
+                            )}
+                          </div>
+                          
+                          {isSelected && !isAssigned && (
+                            <Select
+                              size="sm"
+                              label="限速规则"
+                              className="w-40"
+                              selectedKeys={batchTunnelSelections.get(tunnel.id) !== null && batchTunnelSelections.get(tunnel.id) !== undefined ? [batchTunnelSelections.get(tunnel.id)!.toString()] : ["null"]}
+                              onSelectionChange={(keys) => {
+                                const value = Array.from(keys)[0] as string;
+                                updateTunnelSpeedLimit(tunnel.id, value === "null" ? null : Number(value));
+                              }}
+                            >
+                              {[
+                                <SelectItem key="null" textValue="不限速">不限速</SelectItem>,
+                                ...tunnelSpeedLimits.map(sl => (
+                                  <SelectItem key={sl.id.toString()} textValue={sl.name}>
+                                    {sl.name}
+                                  </SelectItem>
+                                ))
+                              ]}
+                            </Select>
+                          )}
+                        </div>
+                      );
+                    })}
+                    {tunnels.length === 0 && (
+                      <div className="p-4 text-center text-gray-500">暂无可用隧道</div>
+                    )}
                  </div>
                  
                  <Button
                    color="primary"
-                    onPress={handleAssignTunnel}
+                    onPress={handleBatchAssignTunnel}
                    isLoading={assignLoading}
+                    isDisabled={batchTunnelSelections.size === 0}
                  >
-                    分配权限
+                    分配权限 {batchTunnelSelections.size > 0 && `(${batchTunnelSelections.size}个隧道)`}
                  </Button>
                </div>
              </div>
@@ -58,6 +58,15 @@ export interface UserTunnelForm {
  speedId: number | null;
 }

+export interface TunnelAssignItem {
+  tunnelId: number;
+  speedId: number | null;
+}
+
+export interface UserTunnelBatchAssignForm {
+  tunnels: TunnelAssignItem[];
+}
+
 export interface Tunnel {
  id: number;
  name: string;
@@ -0,0 +1,11 @@
+declare module 'recharts' {
+  import * as React from 'react';
+
+  export const LineChart: React.ComponentType<Record<string, unknown>>;
+  export const Line: React.ComponentType<Record<string, unknown>>;
+  export const XAxis: React.ComponentType<Record<string, unknown>>;
+  export const YAxis: React.ComponentType<Record<string, unknown>>;
+  export const CartesianGrid: React.ComponentType<Record<string, unknown>>;
+  export const Tooltip: React.ComponentType<Record<string, unknown>>;
+  export const ResponsiveContainer: React.ComponentType<Record<string, unknown>>;
+}
@@ -1 +1,10 @@
 /// <reference types="vite/client" />
+
+interface ImportMetaEnv {
+  readonly VITE_APP_VERSION?: string;
+  readonly VITE_GITHUB_REPO?: string;
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv;
+}
Author	SHA1	Message	Date
root	72c2e28667	fix: 移除未使用的变量修复TypeScript编译错误	2026-02-03 15:55:30 +00:00
sagit	74c78851ca	Merge pull request #11 from Sagit-chu/opencode/neon-rocket feat: 简化用户隧道权限分配，支持多选隧道批量分配 (#8)	2026-02-03 23:28:55 +08:00
root	42732f844a	fix: 为嵌套的TunnelAssignItem添加@Valid注解确保校验生效	2026-02-03 15:16:43 +00:00
root	99b8ac206a	fix: 批量分配时对请求中的重复tunnelId进行去重防止同一请求中包含重复tunnelId导致创建多条权限记录	2026-02-03 14:43:34 +00:00
root	0e5cd86ed1	feat: 简化用户隧道权限分配，支持多选隧道批量分配 (#8 ) - 新增批量分配接口 POST /tunnel/user/batch-assign - 支持一次选择多个隧道进行分配 - 每个隧道可单独设置限速规则 - flow/num/flowResetTime/expTime 自动从用户设置继承 - 前端表单简化为隧道多选列表+限速选择 - 已分配的隧道显示'已分配'标记且不可重复选择	2026-02-03 13:59:05 +00:00
root	60fc80b6ac	fix: 节点更新时serverIpV4/V6/域名字段无法正确清空的问题使用LambdaUpdateWrapper替代updateById以确保null值能正确更新到数据库 Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-opencode) Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>	2026-02-03 12:57:39 +00:00
root	c8f0c55fda	fix: 隧道新增入口节点后转发管理的入口IP不自动更新	2026-02-03 11:30:31 +00:00
root	bfdaa47ea5	修复隧道编辑新增入口节点后转发规则不生效的问题 (#9 ) 当编辑隧道添加新入口节点时，现有转发规则的ForwardPort和GOST服务未同步更新，导致新入口节点的端口实际不可用。修复方案：在updateTunnel成功更新节点后，同步更新所有使用该隧道的转发规则： - 对移除的入口节点：删除ForwardPort记录和GOST服务 - 对新增的入口节点：分配端口、创建ForwardPort记录和GOST服务	2026-02-03 09:28:38 +00:00
sagit	d7b76b4590	Update README.md	2026-02-02 15:51:24 +08:00
root	2c2262b55d	完善分层 AGENTS.md，便于快速定位代码	2026-02-02 07:41:27 +00:00
root	7ca01aba5d	修复转发管理隧道下拉顺序不同步	2026-02-02 06:28:45 +00:00
sagit	0f57ec58b3	Merge pull request #10 from Sagit-chu/opencode/silent-falcon 优化拖拽排序顺滑度	2026-02-02 12:55:09 +08:00
root	ac30f0172f	修复平铺模式用户切换与图表TS构建	2026-02-02 04:50:22 +00:00
root	531ba0bfed	新建隧道默认追加到末尾	2026-02-02 03:29:47 +00:00
root	d787e4b07a	优化拖拽排序顺滑度	2026-02-02 03:14:18 +00:00
root	68e5d0ac0b	修复节点监控进度条频繁重置	2026-02-01 15:39:23 +00:00
root	38b70821c5	节点监控离线延迟去抖	2026-02-01 14:41:23 +00:00
root	936158dd32	节点地址输入支持域名	2026-02-01 12:34:31 +00:00
root	e0d0553fd3	修复v6-only入口优先选择出口IPv6	2026-02-01 12:34:31 +00:00
root	78aa86b23c	前端版本号从tag注入并提交本地配置	2026-02-01 12:10:17 +00:00
root	1f850593dd	节点管理页支持填写IPv4/IPv6	2026-02-01 11:14:19 +00:00
root	c4519c243a	组隧道链路按地址族自动匹配节点IP（v4优先）	2026-02-01 11:14:19 +00:00
root	31ccc48436	启动时迁移并回填节点双栈IP列	2026-02-01 11:14:19 +00:00
root	1c4914ec77	支持节点双栈IP字段	2026-02-01 11:14:19 +00:00
sagit	71c40127d5	Merge pull request #2 from Sagit-chu/opencode/sunny-island fix: fix some bugs	2026-01-31 13:56:12 +08:00
root	aac1d63ac0	feat: enable drag-sort in node monitoring	2026-01-31 05:52:52 +00:00
root	8222b31917	feat: enable drag-sort in tunnel management	2026-01-31 05:52:39 +00:00
root	81c9c117a2	feat: add tunnel/node update-order API clients	2026-01-31 05:52:26 +00:00
root	de8e487dff	feat: add update-order APIs for tunnel and node	2026-01-31 05:52:14 +00:00
root	f4c59f64b0	feat: add inx ordering for tunnel and node	2026-01-31 05:51:20 +00:00
root	6adf90d45c	fix: make node deletion detach tunnels safely When deleting a node, detach it from affected tunnel chains and keep tunnel config consistent instead of deleting entire tunnels.	2026-01-31 05:00:18 +00:00
root	71eab8e07e	chore: resolve latest release in install scripts Install scripts now derive the release tag dynamically (with a CN mirror fallback) instead of being pinned to a single version.	2026-01-31 05:00:11 +00:00
sagit	dd58ac67de	feat: allow changing tunnel when editing forward rules - Add tunnelId field to ForwardUpdateDto - Refactor updateForward to support tunnel change: - Release old tunnel resources (GOST services + ForwardPort) - Allocate new tunnel resources with proper rollback - Preserve flow statistics (inFlow/outFlow) - Remove tunnel selector disabled state in forward.tsx - Bump version to 2.0.9	2026-01-24 05:27:51 +00:00
sagit	e6226d8069	chore: update install scripts to use Sagit-chu repo and version 2.0.8	2026-01-24 04:59:39 +00:00